@interf/compiler 0.9.4 → 0.13.0

package/dist/cli/commands/web.js

@@ -1,386 +1,159 @@
-import { existsSync, mkdirSync, readFileSync, } from "node:fs";
-import { join, 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 { resolveLocalExecutor, } from "../../packages/agents/lib/executors.js";
-import { ActionProposalPlanSchema, startLocalService, } from "../../packages/local-service/index.js";
-import { loadSourceFolderConfig, saveSourceFolderConfig, sourceFolderConfigPath, } from "../../packages/project-model/source-config.js";
-import { runConfiguredCompiledCompile, } from "./compile-controller.js";
-import { draftReadinessChecks, } from "./check-draft.js";
-import { runReadinessChecksForExecutor, } from "../../packages/testing/readiness-check-run.js";
-import { runMethodAuthoringDraft, } from "../../packages/method-authoring/method-authoring.js";
-import { PACKAGE_ROOT } from "../../packages/method-package/lib/package-root.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";
-import { methodIdForSourcePreparationConfig } from "../../packages/methods/method-resolution.js";
-export const webCommand = {
-    command: "web",
-    describe: "Start Interf UI and the local Interf API",
-    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;
+    }
+}
+function isPortInUseError(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    const code = error.code;
+    return code === "EADDRINUSE";
 }
-function extractJsonObject(text) {
+async function runWebForeground(args) {
+    const host = args.host ?? LOCAL_SERVICE_DEFAULT_HOST;
+    const port = args.port ?? LOCAL_SERVICE_DEFAULT_PORT;
+    let service;
     try {
-        return JSON.parse(text);
+        service = await startLocalService({
+            host,
+            port,
+            packageVersion: packageVersionFromManifest(),
+            handlers: createNativeLocalServiceRunHandlers(),
+        });
     }
-    catch {
-        const match = text.match(/\{[\s\S]*\}/);
-        if (!match)
-            throw new Error("Planner did not write a JSON object.");
-        return JSON.parse(match[0]);
+    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;
     }
+    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();
+        }
+        catch {
+            // best effort
+        }
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    await new Promise(() => {
+        /* block forever; signals trigger shutdown */
+    });
 }
-function readActionSkill() {
-    const skillDir = join(PACKAGE_ROOT, "agent-skills", "interf-actions");
-    const skillPath = join(skillDir, "SKILL.md");
-    const cliReferencePath = join(skillDir, "references", "cli.md");
+function findEnginePidByUrl(url) {
     try {
-        const skill = readFileSync(skillPath, "utf8");
-        const cliReference = readFileSync(cliReferencePath, "utf8");
-        return [
-            skill,
-            "## Bundled reference: references/cli.md",
-            cliReference,
-        ].join("\n\n");
+        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 [
-            "# Interf Actions",
-            "Use `interf --help`, `interf list`, `interf status`, and command-specific help as the source of truth.",
-            "In Interf proposal mode, do not run CLI commands. Write the requested JSON proposal only.",
-        ].join("\n\n");
+        return null;
     }
 }
-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,
-        };
+async function runWebStop(args) {
+    const conn = readActiveConnection({
+        urlOverride: args.url,
+        authTokenOverride: args.token,
+    });
+    if (!conn) {
+        console.error("No active Interf connection to stop.");
+        process.exit(1);
     }
-    const existingControlPath = findNearestInterfInstanceConfig(currentPath);
-    if (existingControlPath) {
-        return {
-            controlPath: existingControlPath,
-            sourceFolderPath: configuredSourceFolder ? resolve(currentPath, configuredSourceFolder) : null,
-        };
+    const url = conn.url.replace(/\/+$/, "");
+    const pid = findEnginePidByUrl(url);
+    if (!pid) {
+        console.error(`Could not locate engine PID for ${url}.`);
+        process.exit(1);
     }
-    if (configuredSourceFolder) {
-        const resolvedSourceFolder = resolve(currentPath, configuredSourceFolder);
-        const context = resolveInterfInstanceContext(resolvedSourceFolder);
-        return {
-            controlPath: context.controlPath,
-            sourceFolderPath: resolvedSourceFolder,
-        };
+    try {
+        process.kill(pid, "SIGTERM");
+        console.log(chalk.green(`Sent SIGTERM to engine pid ${pid} (${url}).`));
+        clearConnection();
     }
-    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.`);
-        }
-        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 ?? [],
-            });
-        }
-        return;
+    catch (error) {
+        console.error(`Failed to stop engine pid ${pid}: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
     }
-    seedLocalDefaultMethod({ sourcePath: controlPath });
-    const sourceFolderPath = inferSourceFolderPath();
-    saveSourceFolderConfig(controlPath, {
-        ...(sourceFolderPath
-            ? {
-                source_folder: {
-                    path: relativeSourceFolderPath(controlPath, sourceFolderPath),
-                },
-            }
-            : {}),
-        preparations: [],
-    });
 }
-function buildActionPlannerPrompt(request, context, outputPath) {
-    const actionSkill = readActionSkill();
-    const preparations = context.preparations.map((preparation) => ({
-        name: preparation.name,
-        path: preparation.path,
-        about: preparation.about ?? null,
-        method: methodIdForSourcePreparationConfig(preparation),
-        checks: preparation.checks?.length ?? 0,
-    }));
-    const recentProposals = context.recentProposals.map((proposal) => ({
-        status: proposal.status,
-        action_type: proposal.action_type,
-        title: proposal.title,
-        preparation: proposal.preparation ?? null,
-        request: proposal.request,
-        command_preview: proposal.command_preview ?? null,
-    }));
-    const sourceFolders = context.sourceFolders.map((folder) => ({
-        path: folder.value,
-        label: folder.label,
-        hint: folder.hint,
-    }));
-    return `You are the local Interf action planner.
-
-User request:
-${request.message}
-
-Selected Preparation hint: ${request.preparation ?? "(none)"}
-
-Structured request values:
-${JSON.stringify(request.values ?? {}, null, 2)}
-
-Available Preparations:
-${JSON.stringify(preparations, null, 2)}
-
-Visible Source Folders:
-${JSON.stringify(sourceFolders, null, 2)}
-
-Action health:
-${JSON.stringify(context.preparationHealth, null, 2)}
-
-Recent proposals, newest first. A short follow-up like "target source only" may be correcting the latest pending proposal:
-${JSON.stringify(recentProposals, null, 2)}
-
-Interf action skill source:
-${actionSkill}
-
-Use the Interf action skill source as the authority for CLI semantics and Interf proposal mode. Preserve user intent over defaults.
-Use Action health to avoid proposing work that cannot run yet. If can_check_readiness is false, prefer the recommended next actions; do not propose a generic readiness check unless the user explicitly asks for a source-files-only baseline.
-If the user is asking a question or making casual conversation, return "clarification" with a helpful assistant_message. Do not invent a CLI command for non-action chat.
-If a field does not apply, omit it instead of writing null or an empty string.
-Do not run any CLI command. Do not edit files except the output JSON file.
-
-Write only this JSON object to:
-${outputPath}
-
-JSON schema:
-{
-  "action_type": "preparation-setup" | "compile" | "test" | "readiness-check-draft" | "method-authoring" | "clarification",
-  "preparation": "Preparation id if applicable",
-  "method": "Method id if applicable",
-  "values": {},
-  "title": "short approval card title",
-  "summary": "one sentence describing what will run",
-  "assistant_message": "concise explanation for the user",
-  "command_preview": "interf command the user is approving"
-}
-`;
-}
-export async function runWebCommand(argv = {}) {
-    const { controlPath, sourceFolderPath } = resolveWebProjectPaths(argv);
-    ensureWebProjectInitialized(controlPath, { sourceFolderPath });
-    const handlers = {
-        async planActionProposal(request, context) {
-            const resolved = resolveLocalExecutor({ preflight: true });
-            if (!resolved.executor) {
-                return ActionProposalPlanSchema.parse({
-                    action_type: "clarification",
-                    preparation: request.preparation,
-                    assistant_message: resolved.error ?? "No local agent detected for action planning.",
-                });
-            }
-            const planRoot = join(context.sourcePath, "interf", ".service", "action-plans", Date.now().toString(36));
-            mkdirSync(planRoot, { recursive: true });
-            const outputPath = join(planRoot, "proposal.json");
-            const prompt = buildActionPlannerPrompt(request, context, outputPath);
-            const exitCode = await resolved.executor.execute(context.sourcePath, prompt, {
-                eventLogPath: join(planRoot, "planner.events.ndjson"),
-                statusLogPath: join(planRoot, "planner.status.log"),
-                completionCheck: () => existsSync(outputPath),
-            });
-            if (exitCode !== 0 && !existsSync(outputPath)) {
-                return ActionProposalPlanSchema.parse({
-                    action_type: "clarification",
-                    preparation: request.preparation,
-                    assistant_message: `${resolved.executor.displayName} could not create a safe Interf proposal.`,
-                });
-            }
-            try {
-                return ActionProposalPlanSchema.parse(extractJsonObject(readFileSync(outputPath, "utf8")));
-            }
-            catch {
-                return ActionProposalPlanSchema.parse({
-                    action_type: "clarification",
-                    preparation: request.preparation,
-                    assistant_message: "I can help with this Interf Workspace. Ask a question about Interf, or ask me to create a Preparation, prepare, check readiness, improve, or draft a Method and I will prepare an approval proposal.",
-                });
-            }
-        },
-        async createCompileRun(request, context) {
-            const resolved = resolveLocalExecutor({ preflight: true });
-            if (!resolved.executor) {
-                throw new Error(resolved.error ?? "No local agent detected.");
-            }
-            const ok = await runConfiguredCompiledCompile({
-                executor: resolved.executor,
-                testExecutor: resolved.executor,
-                compiledPath: context.compiledPath,
-                sourcePath: context.sourcePath,
-                compiledConfig: context.preparationConfig,
-                maxAttemptsOverride: request.max_attempts ?? null,
-                maxLoopsOverride: request.max_loops ?? null,
-                preserveStageShells: request.preserve_stage_shells,
-                runId: context.runId,
-                events: context.events,
-            });
-            return { ok };
-        },
-        async createTestRun(request, context) {
-            const resolved = resolveLocalExecutor({ preflight: true });
-            if (!resolved.executor) {
-                throw new Error(resolved.error ?? "No local agent detected.");
-            }
-            const result = await runReadinessChecksForExecutor({
-                sourcePath: context.sourcePath,
-                preparationConfig: context.preparationConfig,
-                portableContextPath: context.compiledPath,
-                mode: request.mode,
-                executor: resolved.executor,
-            });
-            const missingSourceFiles = (request.mode === "raw" || request.mode === "both") && !result.rawOutcome;
-            const missingPortableContext = (request.mode === "compiled" || request.mode === "both") && !result.compiledOutcome;
-            if (missingSourceFiles || missingPortableContext) {
-                return {
-                    ok: false,
-                    comparison: result.comparison,
-                    error: missingPortableContext
-                        ? "Portable Context is not ready for readiness checks."
-                        : "Source files are not ready for readiness checks.",
-                };
-            }
-            return {
-                ok: true,
-                comparison: result.comparison,
-            };
-        },
-        async createReadinessCheckDraft(request, context) {
-            const resolved = resolveLocalExecutor({ preflight: true });
-            if (!resolved.executor) {
-                throw new Error(resolved.error ?? "No local agent detected.");
-            }
-            context.emit({
-                type: "log.appended",
-                step_id: "agent-draft",
-                message: `Using ${resolved.executor.displayName} for readiness-check drafting.`,
-            });
-            const drafted = await draftReadinessChecks({
-                preparationName: request.preparation,
-                sourceFolderPath: request.source_folder_path,
-                about: request.about,
-                executor: resolved.executor,
-                targetCount: request.target_count,
-                onStatus: (line) => context.emit({
-                    type: "log.appended",
-                    step_id: "agent-draft",
-                    message: line,
-                }),
-            });
-            if (!drafted.checks) {
-                throw new Error(drafted.error ?? "Could not draft readiness checks from this Source Folder.");
-            }
-            return {
-                checks: drafted.checks,
-            };
-        },
-        async createMethodAuthoringRun(request, context) {
-            const resolved = resolveLocalExecutor({ preflight: true });
-            if (!resolved.executor) {
-                throw new Error(resolved.error ?? "No local agent detected.");
-            }
-            context.emit({
-                type: "log.appended",
-                step_id: "draft-package",
-                message: `Using ${resolved.executor.displayName} for Method authoring.`,
-            });
-            const result = await runMethodAuthoringDraft({
-                sourcePath: context.sourcePath,
-                sourceFolderPath: request.source_folder_path,
-                baseMethodId: request.reference_method_id ?? request.base_method_id,
-                methodId: request.method_id,
-                label: request.label,
-                hint: request.hint,
-                taskPrompt: request.task_prompt,
-                checks: request.checks,
-                executor: resolved.executor,
-                onStatus: (line) => context.emit({
-                    type: "log.appended",
-                    step_id: "draft-package",
-                    message: line,
-                }),
-            });
-            return {
-                status: result.status,
-                changed: result.changed,
-                summary: result.summary,
-                validation: result.validation,
-                method_path: result.methodPath,
-                shell_path: result.shellPath,
-            };
-        },
-    };
-    const service = await startLocalService({
-        rootPath: controlPath,
-        host: stringOption(argv.host),
-        port: numberOption(argv.port),
-        handlers,
-    });
-    console.log(chalk.green(`  Interf: ${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);
+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 {};