Initial open-source release

scripts/published-package-smoke.mjs

@@ -0,0 +1,164 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { execFile } from 'node:child_process';
+import { mkdir, mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { promisify } from 'node:util';
+
+import {
+  buildPublishedPackageSmokeCommands,
+  readPublishedPackageSmokeConfigFromPolicyFile,
+} from './published-package-smoke-config.mjs';
+
+export {
+  buildPublishedPackageNpxCommand,
+  buildPublishedPackageSmokeCommands,
+  publishedPackageSpec,
+  readPublishedPackageSmokeConfig,
+} from './published-package-smoke-config.mjs';
+
+const execFileAsync = promisify(execFile);
+const SMOKE_TIMEOUT_MS = 180_000;
+
+function scriptRootDir() {
+  return resolve(dirname(fileURLToPath(import.meta.url)), '..');
+}
+
+function releasePolicyPath(rootDir = scriptRootDir()) {
+  return join(rootDir, 'release-policy.json');
+}
+
+async function runCommand(command, args, options = {}) {
+  process.stdout.write(`$ ${command} ${args.join(' ')}\n`);
+  try {
+    const result = await execFileAsync(command, args, {
+      cwd: options.cwd,
+      env: Object.assign({}, process.env, options.env ?? {}),
+      encoding: 'utf8',
+      maxBuffer: 10 * 1024 * 1024,
+      timeout: SMOKE_TIMEOUT_MS,
+    });
+    return { code: 0, stdout: result.stdout, stderr: result.stderr };
+  } catch (error) {
+    return {
+      code: typeof error.code === 'number' ? error.code : 1,
+      stdout: error.stdout ?? '',
+      stderr: error.stderr ?? error.message,
+    };
+  }
+}
+
+function requireSuccess(label, result) {
+  assert.equal(
+    result.code,
+    0,
+    `${label} failed with code ${result.code}\nstdout:\n${result.stdout}\nstderr:\n${result.stderr}`,
+  );
+}
+
+function parseJson(label, text) {
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    throw new Error(`${label} did not produce JSON: ${error instanceof Error ? error.message : String(error)}\n${text}`);
+  }
+}
+
+function assertHybridWikiSearch(result) {
+  const payload = parseJson('published package wiki search', result.stdout);
+  assert.ok(payload.totalFound > 0, 'published package wiki search should return results');
+  assert.ok(
+    payload.results.some((entry) => Array.isArray(entry.matchReasons) && entry.matchReasons.length > 0),
+    'published package wiki search should expose match reasons',
+  );
+}
+
+function assertHybridSlSearch(result) {
+  const payload = parseJson('published package semantic-layer search', result.stdout);
+  assert.ok(payload.totalSources > 0, 'published package semantic-layer search should return sources');
+  assert.ok(
+    payload.sources.some((entry) => Array.isArray(entry.matchReasons) && entry.matchReasons.length > 0),
+    'published package semantic-layer search should expose match reasons',
+  );
+}
+
+function assertMissingProjectReadiness(result, emptyProjectDir) {
+  assert.equal(result.code, 1, 'missing-project semantic-layer search should exit 1');
+  assert.equal(result.stdout, '', 'missing-project semantic-layer search should not write JSON errors to stdout');
+
+  const payload = parseJson('published package missing-project semantic-layer search', result.stderr);
+  assert.deepEqual(payload, {
+    ok: false,
+    error: {
+      code: 'agent_sl_search_missing_project',
+      message: `Semantic-layer search needs an initialized KLO project at ${emptyProjectDir}.`,
+      nextSteps: [
+        'klo demo',
+        `klo setup --project-dir ${emptyProjectDir}`,
+        'klo ingest <connection>',
+        `klo agent sl list --json --query "revenue" --project-dir ${emptyProjectDir}`,
+      ],
+    },
+  });
+}
+
+export async function runPublishedPackageSmoke(config) {
+  const root = await mkdtemp(join(tmpdir(), 'klo-published-package-smoke-'));
+  try {
+    const projectDir = join(root, 'demo-project');
+    const emptyProjectDir = join(root, 'empty-project');
+    await mkdir(emptyProjectDir, { recursive: true });
+
+    const commands = buildPublishedPackageSmokeCommands(config, projectDir, emptyProjectDir);
+    for (const command of commands.slice(0, 4)) {
+      const result = await runCommand(command.command, command.args, { env: command.env });
+      requireSuccess(command.label, result);
+      if (command.label === 'published package wiki hybrid search') {
+        assertHybridWikiSearch(result);
+      }
+      if (command.label === 'published package semantic-layer hybrid search') {
+        assertHybridSlSearch(result);
+      }
+    }
+
+    const missingProjectCommand = commands[4];
+    const missingProject = await runCommand(missingProjectCommand.command, missingProjectCommand.args, {
+      env: missingProjectCommand.env,
+    });
+    assertMissingProjectReadiness(missingProject, emptyProjectDir);
+
+    process.stdout.write('published package hybrid search smoke verified\n');
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+}
+
+async function main() {
+  const config = await readPublishedPackageSmokeConfigFromPolicyFile(
+    releasePolicyPath(),
+    process.env,
+    process.argv.slice(2),
+  );
+
+  if (!config.enabled) {
+    if (config.requireConfig) {
+      throw new Error(config.reason);
+    }
+    process.stdout.write(`Published KLO package smoke skipped: ${config.reason}\n`);
+    return;
+  }
+
+  await runPublishedPackageSmoke(config);
+}
+
+if (import.meta.url === pathToFileURL(process.argv[1] ?? '').href) {
+  try {
+    await main();
+  } catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.stack : String(error)}\n`);
+    process.exitCode = 1;
+  }
+}