@interf/compiler 0.9.5 → 0.13.0

package/dist/cli/commands/test.js

@@ -1,188 +1,72 @@
+/**
+ * `interf test <prep-id>` — start a readiness-check (test) run for a preparation.
+ *
+ *   interf test bristol
+ *   interf test bristol --target source-files
+ *   interf test bristol --target portable-context
+ *   interf test bristol --target both
+ */
 import chalk from "chalk";
-import * as p from "@clack/prompts";
-import { detectInterf, resolveSourceControlPath, } from "../../packages/project-model/interf.js";
-import { loadCompiledPreparationConfig, sourcePreparationConfigFromInterfConfig, } from "../../packages/project-model/source-config.js";
-import { choosePreparationConfig, } from "./preparation-picker.js";
-import { findBuiltPortableContextPath, } from "../../packages/project-model/preparation-entries.js";
-import { resolveConfiguredPreparationSelection } from "./preparation-selection.js";
-import { createCompiledTestTarget } from "../../packages/testing/test-targets.js";
-import { resolveMethodId } from "../../packages/methods/method-resolution.js";
-import { submitTestRunToLocalService, waitForLocalTestRun, } from "../../packages/local-service/index.js";
-import { resolveCommandControlPath } from "./control-path.js";
+import { CONNECT_OR_ERROR_HINT, readActiveConnection } from "../../packages/local-service/connection-config.js";
+function resolveConnection(args) {
+    const conn = readActiveConnection({
+        urlOverride: args.url,
+        authTokenOverride: args.token,
+    });
+    if (!conn) {
+        console.error(CONNECT_OR_ERROR_HINT);
+        process.exit(1);
+    }
+    return { url: conn.url.replace(/\/+$/, ""), token: conn.auth_token };
+}
+async function callJson(url, token, init = {}) {
+    const headers = new Headers(init.headers ?? {});
+    if (token)
+        headers.set("authorization", `Bearer ${token}`);
+    if (init.body && !headers.has("content-type"))
+        headers.set("content-type", "application/json");
+    const response = await fetch(url, { ...init, headers });
+    const raw = await response.text();
+    let body = null;
+    if (raw.length > 0) {
+        try {
+            body = JSON.parse(raw);
+        }
+        catch {
+            body = null;
+        }
+    }
+    return { status: response.status, body, raw };
+}
 export const testCommand = {
-    command: "test",
-    describe: "Run readiness checks against source files and Portable Context",
+    command: "test <prep-id>",
+    describe: "Run readiness checks for a preparation",
     builder: (yargs) => yargs
-        .option("preparation", {
+        .positional("prep-id", { type: "string", demandOption: true, describe: "Preparation id" })
+        .option("target", {
         type: "string",
-        describe: "Preparation id to check when this Source Folder has more than one Preparation",
+        choices: ["source-files", "portable-context", "both"],
+        default: "both",
+        describe: "Which surface to test against",
     })
-        .option("target", {
-        choices: ["both", "source-files", "portable-context"],
-        describe: "Check source files, Portable Context, or both. Default: both when Portable Context exists, otherwise source files.",
-    }),
-    handler: async (argv) => {
-        await runTestCommand(argv);
+        .option("url", { type: "string", describe: "Override the active connection URL" })
+        .option("token", { type: "string", describe: "Override the active bearer token" }),
+    handler: async (args) => {
+        const { url, token } = resolveConnection(args);
+        const mode = args.target === "portable-context" ? "compiled" : args.target === "source-files" ? "source-files" : "both";
+        const { status, body, raw } = await callJson(`${url}/v1/preparations/${encodeURIComponent(args.prepId)}/test-runs`, token, { method: "POST", body: JSON.stringify({ mode }) });
+        if (status !== 201 && status !== 200) {
+            console.error(chalk.red(`Failed to start test run for ${args.prepId} (HTTP ${status}).`));
+            if (raw)
+                console.error(raw);
+            process.exit(1);
+        }
+        console.log();
+        console.log(`  Run ${chalk.bold(body?.run_id ?? "(?)")} ${chalk.dim(`(${body?.status ?? "started"})`)}`);
+        if (body?.readiness?.status)
+            console.log(`  Readiness: ${body.readiness.status}`);
+        if (body?.error)
+            console.log(chalk.red(`  Error: ${body.error}`));
+        console.log();
     },
 };
-function readRequestedMode(argv) {
-    const value = argv.target;
-    const target = value === "source-files" || value === "portable-context" || value === "both"
-        ? value
-        : null;
-    if (!target)
-        return null;
-    return modeFromTargetChoice(target);
-}
-function modeFromTargetChoice(target) {
-    if (target === "source-files")
-        return "raw";
-    if (target === "portable-context")
-        return "compiled";
-    return "both";
-}
-function reportTestCommandFailure(argv, message, hints = []) {
-    process.exitCode = 1;
-    console.log(chalk.red(`  ${message}`));
-    for (const hint of hints) {
-        console.log(chalk.dim(`  ${hint}`));
-    }
-    const onFailure = typeof argv.onFailure === "function"
-        ? argv.onFailure
-        : null;
-    void onFailure?.({ message, hints });
-    return false;
-}
-async function promptTestMode(hasBuiltCompiled) {
-    if (!hasBuiltCompiled) {
-        return "raw";
-    }
-    const selected = await p.select({
-        message: "What do you want to check?",
-        options: [
-            {
-                value: "both",
-                label: "Source files and Portable Context (Recommended)",
-                hint: "Check whether the data is ready with and without Portable Context",
-            },
-            {
-                value: "raw",
-                label: "Source files only",
-                hint: "Measure the current baseline on the Source Folder files",
-            },
-            {
-                value: "compiled",
-                label: "Portable Context only",
-                hint: "Run the saved readiness checks against the current Portable Context",
-            },
-        ],
-    });
-    if (p.isCancel(selected))
-        return null;
-    return selected;
-}
-export async function runTestCommand(argv = {}) {
-    const cwd = process.cwd();
-    const detected = detectInterf(cwd);
-    const sourcePath = typeof argv.sourcePath === "string" && argv.sourcePath.trim().length > 0
-        ? argv.sourcePath.trim()
-        : (detected ? resolveSourceControlPath(detected.path) : resolveCommandControlPath(cwd));
-    const requestedPreparation = argv.preparation;
-    const requestedPreparationName = typeof requestedPreparation === "string" && requestedPreparation.trim().length > 0
-        ? requestedPreparation.trim()
-        : null;
-    const hintedPreparationConfig = (argv.preparationConfig ?? null);
-    const selectedCompiled = detected
-        ? (() => {
-            const targetName = requestedPreparationName ?? hintedPreparationConfig?.name ?? detected.config.name;
-            return resolveConfiguredPreparationSelection({
-                sourcePath,
-                requestedPreparationName: targetName,
-                hintedPreparationConfig,
-            }) ?? (targetName === detected.config.name
-                ? (loadCompiledPreparationConfig(detected.path)
-                    ?? sourcePreparationConfigFromInterfConfig(detected.config))
-                : null);
-        })()
-        : requestedPreparationName || hintedPreparationConfig
-            ? resolveConfiguredPreparationSelection({
-                sourcePath,
-                requestedPreparationName,
-                hintedPreparationConfig,
-            })
-            : await choosePreparationConfig({
-                sourcePath,
-                selectMessage: "Which saved Preparation do you want to test?",
-            });
-    if (selectedCompiled === undefined)
-        return false;
-    if (!selectedCompiled) {
-        if (requestedPreparationName) {
-            return reportTestCommandFailure(argv, `Preparation "${requestedPreparationName}" is not saved in this Source Folder.`, ["Run `interf list` to see the saved Preparations."]);
-        }
-        return reportTestCommandFailure(argv, "No saved Preparations are configured for this Source Folder yet.", ["Start with `interf` or `interf init`."]);
-    }
-    if (selectedCompiled.checks.length === 0) {
-        return reportTestCommandFailure(argv, `Preparation "${selectedCompiled.name}" does not have any readiness checks yet.`, [
-            "Run `interf`, edit this Preparation, and add a few readiness checks first.",
-            "Then rerun `interf test`.",
-        ]);
-    }
-    const builtCompiledPath = detected?.config.name === selectedCompiled.name
-        ? detected.path
-        : findBuiltPortableContextPath(sourcePath, selectedCompiled.name);
-    const hasBuiltCompiled = builtCompiledPath
-        ? createCompiledTestTarget(builtCompiledPath, selectedCompiled.name, resolveMethodId(selectedCompiled)).eligible
-        : false;
-    const requestedMode = readRequestedMode(argv);
-    const selectedMode = requestedMode ?? (process.stdin.isTTY && process.stdout.isTTY
-        ? await promptTestMode(hasBuiltCompiled)
-        : (hasBuiltCompiled ? "both" : "raw"));
-    if (!selectedMode)
-        return false;
-    const mode = selectedMode;
-    const submitted = await submitTestRunToLocalService({
-        projectPath: sourcePath,
-        request: {
-            preparation: selectedCompiled.name,
-            mode,
-        },
-    });
-    if (!submitted) {
-        return reportTestCommandFailure(argv, "Interf local service is not running for this Workspace.", ["Start it with `interf web`, then rerun `interf test` so the readiness-check run is visible in Interf."]);
-    }
-    console.log(chalk.dim(`  Visible in Interf: ${submitted.serviceUrl}/`));
-    let lastStatus = "";
-    const completed = await waitForLocalTestRun({
-        serviceUrl: submitted.serviceUrl,
-        runId: submitted.resource.run_id,
-        onUpdate(resource) {
-            if (resource.status === lastStatus)
-                return;
-            lastStatus = resource.status;
-            console.log(chalk.dim(`  Readiness check run: ${resource.status}`));
-        },
-    });
-    if (completed.status !== "succeeded") {
-        return reportTestCommandFailure(argv, `Readiness check run ${completed.status}.`, completed.error ? [completed.error] : []);
-    }
-    const compiledScore = completed.readiness_run?.compiled;
-    const rawScore = completed.readiness_run?.raw;
-    if (compiledScore) {
-        console.log(chalk.green(`  Portable Context readiness checks: ${compiledScore.passed_cases}/${compiledScore.total_cases}`));
-    }
-    if (rawScore) {
-        console.log(chalk.dim(`  Source files readiness checks: ${rawScore.passed_cases}/${rawScore.total_cases}`));
-    }
-    const onComplete = typeof argv.onComplete === "function"
-        ? argv.onComplete
-        : null;
-    await onComplete?.({
-        sourcePath,
-        preparationConfig: selectedCompiled,
-        builtCompiledPath: builtCompiledPath ?? null,
-        mode,
-        rows: [],
-    });
-    return true;
-}

package/dist/cli/commands/web.d.ts

@@ -1,11 +1,2 @@
 import type { CommandModule } from "yargs";
 export declare const webCommand: CommandModule;
-export interface WebProjectPaths {
-    controlPath: string;
-    sourceFolderPath: string | null;
-}
-export declare function resolveWebProjectPaths(argv?: Record<string, unknown>, cwd?: string): WebProjectPaths;
-export declare function ensureWebProjectInitialized(controlPath: string, options?: {
-    sourceFolderPath?: string | null;
-}): void;
-export declare function runWebCommand(argv?: Record<string, unknown>): Promise<void>;

package/dist/cli/commands/web.js

@@ -1,132 +1,159 @@
-import { existsSync, } from "node:fs";
-import { resolve } from "node:path";
+/**
+ * `interf web` — start the engine in the foreground until Ctrl-C.
+ *
+ *   interf web                # start on default port; hard error if port busy
+ *   interf web stop           # send SIGTERM to the running engine
+ *   interf web status         # print engine info via the connected URL
+ *
+ * Pure server. No reuse / register-with-existing logic. Writes
+ * `~/.interf/connection.json` on startup so subsequent CLI commands can
+ * connect without a pointer file.
+ */
 import chalk from "chalk";
-import { startLocalService, } from "../../packages/local-service/index.js";
-import { createNativeLocalServiceRunHandlers, } from "../../packages/local-service/native-run-handlers.js";
-import { loadSourceFolderConfig, saveSourceFolderConfig, sourceFolderConfigPath, } from "../../packages/project-model/source-config.js";
-import { seedLocalDefaultMethod } from "../../packages/method-package/local-methods.js";
-import { findNearestInterfInstanceConfig, hasInterfInstanceConfig, relativeSourceFolderPath, resolveInterfInstanceContext, } from "./control-path.js";
-import { listSourceFolderChoices, } from "../../packages/project-model/source-folders.js";
-export const webCommand = {
-    command: "web",
-    describe: "Start Interf Compiler UI and the local Interf service",
-    builder: (yargs) => yargs
-        .option("host", {
-        type: "string",
-        describe: "Host for the local Interf service",
-    })
-        .option("port", {
-        type: "number",
-        describe: "Port for the local Interf service",
-    })
-        .option("control-path", {
-        type: "string",
-        describe: "Folder where Interf stores local config, Methods, runs, and portable context",
-    })
-        .option("source-folder", {
-        type: "string",
-        describe: "Source Folder to prepare when initializing a new Interf Workspace",
-    }),
-    handler: async (argv) => {
-        await runWebCommand(argv);
-    },
-};
-function stringOption(value) {
-    return typeof value === "string" && value.trim().length > 0
-        ? value.trim()
-        : undefined;
-}
-function numberOption(value) {
-    if (typeof value !== "number" || !Number.isInteger(value))
+import { readFileSync } from "node:fs";
+import { LOCAL_SERVICE_DEFAULT_HOST, LOCAL_SERVICE_DEFAULT_PORT, buildLocalServiceUrl, } from "../../packages/local-service/routes.js";
+import { startLocalService } from "../../packages/local-service/server.js";
+import { createNativeLocalServiceRunHandlers } from "../../packages/local-service/native-run-handlers.js";
+import { CONNECT_OR_ERROR_HINT, clearConnection, readActiveConnection, } from "../../packages/local-service/connection-config.js";
+import { serviceRegistryPath } from "../../packages/local-service/instance-paths.js";
+function packageVersionFromManifest() {
+    try {
+        const url = new URL("../../../package.json", import.meta.url);
+        const raw = readFileSync(url, "utf8");
+        const parsed = JSON.parse(raw);
+        return parsed.version;
+    }
+    catch {
         return undefined;
-    return value;
-}
-export function resolveWebProjectPaths(argv = {}, cwd = process.cwd()) {
-    const currentPath = resolve(cwd);
-    const configuredControlPath = stringOption(argv["control-path"]);
-    const configuredSourceFolder = stringOption(argv["source-folder"]);
-    if (configuredControlPath) {
-        return {
-            controlPath: resolve(currentPath, configuredControlPath),
-            sourceFolderPath: configuredSourceFolder ? resolve(currentPath, configuredSourceFolder) : null,
-        };
     }
-    const existingControlPath = findNearestInterfInstanceConfig(currentPath);
-    if (existingControlPath) {
-        return {
-            controlPath: existingControlPath,
-            sourceFolderPath: configuredSourceFolder ? resolve(currentPath, configuredSourceFolder) : null,
-        };
+}
+function isPortInUseError(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    const code = error.code;
+    return code === "EADDRINUSE";
+}
+async function runWebForeground(args) {
+    const host = args.host ?? LOCAL_SERVICE_DEFAULT_HOST;
+    const port = args.port ?? LOCAL_SERVICE_DEFAULT_PORT;
+    let service;
+    try {
+        service = await startLocalService({
+            host,
+            port,
+            packageVersion: packageVersionFromManifest(),
+            handlers: createNativeLocalServiceRunHandlers(),
+        });
     }
-    if (configuredSourceFolder) {
-        const resolvedSourceFolder = resolve(currentPath, configuredSourceFolder);
-        const context = resolveInterfInstanceContext(resolvedSourceFolder);
-        return {
-            controlPath: context.controlPath,
-            sourceFolderPath: resolvedSourceFolder,
-        };
+    catch (error) {
+        if (isPortInUseError(error)) {
+            console.error(chalk.red(`Error: another Interf engine is already running at ${buildLocalServiceUrl({ host, port })}.`));
+            console.error(`Stop it first with \`interf web stop\`.`);
+            process.exit(1);
+        }
+        throw error;
     }
-    const context = resolveInterfInstanceContext(currentPath);
-    return {
-        controlPath: context.controlPath,
-        sourceFolderPath: context.defaultSourceFolderPath ?? currentPath,
-    };
-}
-export function ensureWebProjectInitialized(controlPath, options = {}) {
-    const inferSourceFolderPath = () => {
-        if (options.sourceFolderPath)
-            return options.sourceFolderPath;
-        const choices = listSourceFolderChoices(controlPath);
-        return choices.length === 1 ? resolve(controlPath, choices[0]?.value ?? "") : null;
-    };
-    if (existsSync(sourceFolderConfigPath(controlPath))) {
-        if (!hasInterfInstanceConfig(controlPath)) {
-            throw new Error(`Interf Workspace path is not usable: ${sourceFolderConfigPath(controlPath)}. Choose a different --control-path.`);
+    console.log();
+    console.log(`  Interf engine: ${chalk.bold(service.url)}`);
+    console.log(`  Compiler UI:   ${service.url}/`);
+    console.log(`  Health:        ${service.url}/health`);
+    console.log(chalk.dim("  Press Ctrl-C to stop."));
+    console.log();
+    const shutdown = async () => {
+        try {
+            await service.close();
         }
-        const existing = loadSourceFolderConfig(controlPath);
-        const sourceFolderPath = existing?.source_folder ? null : inferSourceFolderPath();
-        if (existing && sourceFolderPath) {
-            saveSourceFolderConfig(controlPath, {
-                source_folder: {
-                    path: relativeSourceFolderPath(controlPath, sourceFolderPath),
-                },
-                preparations: existing.preparations ?? [],
-            });
+        catch {
+            // best effort
         }
-        return;
-    }
-    seedLocalDefaultMethod({ sourcePath: controlPath });
-    const sourceFolderPath = inferSourceFolderPath();
-    saveSourceFolderConfig(controlPath, {
-        ...(sourceFolderPath
-            ? {
-                source_folder: {
-                    path: relativeSourceFolderPath(controlPath, sourceFolderPath),
-                },
-            }
-            : {}),
-        preparations: [],
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    await new Promise(() => {
+        /* block forever; signals trigger shutdown */
     });
 }
-export async function runWebCommand(argv = {}) {
-    const { controlPath, sourceFolderPath } = resolveWebProjectPaths(argv);
-    ensureWebProjectInitialized(controlPath, { sourceFolderPath });
-    const handlers = createNativeLocalServiceRunHandlers();
-    const service = await startLocalService({
-        rootPath: controlPath,
-        host: stringOption(argv.host),
-        port: numberOption(argv.port),
-        handlers,
+function findEnginePidByUrl(url) {
+    try {
+        const raw = readFileSync(serviceRegistryPath(), "utf8");
+        const parsed = JSON.parse(raw);
+        const entry = parsed.services?.find((s) => s.url === url);
+        return entry?.pid ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+async function runWebStop(args) {
+    const conn = readActiveConnection({
+        urlOverride: args.url,
+        authTokenOverride: args.token,
     });
-    console.log(chalk.green(`  Interf Compiler service: ${service.url}`));
-    console.log(chalk.dim(`  Compiler UI: ${service.url}/`));
-    console.log(chalk.dim(`  Health: ${service.url}/health`));
-    console.log(chalk.dim("  Press Ctrl-C to stop the local Interf service."));
-    await new Promise((resolve) => {
-        const shutdown = () => {
-            void service.close().finally(resolve);
-        };
-        process.once("SIGINT", shutdown);
-        process.once("SIGTERM", shutdown);
+    if (!conn) {
+        console.error("No active Interf connection to stop.");
+        process.exit(1);
+    }
+    const url = conn.url.replace(/\/+$/, "");
+    const pid = findEnginePidByUrl(url);
+    if (!pid) {
+        console.error(`Could not locate engine PID for ${url}.`);
+        process.exit(1);
+    }
+    try {
+        process.kill(pid, "SIGTERM");
+        console.log(chalk.green(`Sent SIGTERM to engine pid ${pid} (${url}).`));
+        clearConnection();
+    }
+    catch (error) {
+        console.error(`Failed to stop engine pid ${pid}: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+}
+async function runWebStatus(args) {
+    const conn = readActiveConnection({
+        urlOverride: args.url,
+        authTokenOverride: args.token,
     });
+    if (!conn) {
+        console.error(CONNECT_OR_ERROR_HINT);
+        process.exit(1);
+    }
+    const url = conn.url.replace(/\/+$/, "");
+    try {
+        const headers = new Headers();
+        if (conn.auth_token)
+            headers.set("authorization", `Bearer ${conn.auth_token}`);
+        const response = await fetch(`${url}/v1/instance`, { headers });
+        const raw = await response.text();
+        if (response.status !== 200) {
+            console.error(chalk.red(`Engine status request failed (HTTP ${response.status}).`));
+            if (raw)
+                console.error(raw);
+            process.exit(1);
+        }
+        console.log(raw);
+    }
+    catch (error) {
+        console.error(chalk.red(`Engine ${url} unreachable: ${error instanceof Error ? error.message : String(error)}`));
+        process.exit(1);
+    }
 }
+export const webCommand = {
+    command: "web [subcommand]",
+    describe: "Start / stop / inspect the Interf engine",
+    builder: (yargs) => yargs
+        .command("stop", "Stop the connected engine", (y) => y
+        .option("url", { type: "string", describe: "Override the active connection URL" })
+        .option("token", { type: "string", describe: "Override the active bearer token" }), runWebStop)
+        .command("status", "Show engine status via the connected URL", (y) => y
+        .option("url", { type: "string", describe: "Override the active connection URL" })
+        .option("token", { type: "string", describe: "Override the active bearer token" }), runWebStatus)
+        .command("$0", "Start the engine in the foreground (default)", (y) => y
+        .option("host", { type: "string", default: LOCAL_SERVICE_DEFAULT_HOST, describe: "Host to bind" })
+        .option("port", { type: "number", default: LOCAL_SERVICE_DEFAULT_PORT, describe: "Port to bind" }), runWebForeground)
+        .strict(),
+    handler: () => {
+        /* yargs subcommand handlers do the work */
+    },
+};

package/dist/cli/commands/wizard.d.ts

@@ -0,0 +1,9 @@
+import type { CommandModule } from "yargs";
+interface WizardArgs {
+    url?: string;
+    token?: string;
+}
+export declare const wizardCommand: CommandModule<unknown, WizardArgs>;
+/** Alias: `interf init` runs the same wizard. */
+export declare const initCommand: CommandModule<unknown, WizardArgs>;
+export {};