@nodeint/migent 0.1.4 → 0.1.6

package/dist/commands/execute.js

@@ -1,39 +1,124 @@
-import { AgentToolRunner, DEFAULT_MAX_DISPATCHES, executeNamedWorkflow, } from "@nodeint/migent-kernel";
+import { readdirSync, readFileSync, realpathSync } from "node:fs";
+import path from "node:path";
+import { AgentToolRunner, DEFAULT_MAX_DISPATCHES, executeNamedWorkflow, formatDuration, log, } from "@nodeint/migent-kernel";
+import { printResumeCommand } from "../display.js";
 import { cliHooks } from "../hooks.js";
 import { requireCurrentSchema } from "../migrate.js";
 import { adapterMap } from "../provider.js";
+import { text } from "../text.js";
 export async function executeWorkflow(workspace, options) {
     requireCurrentSchema(workspace);
     const once = options.action === "stage";
-    const creating = options.action === "start" || (once && text(options.sessionId) === null);
-    const maxAttempts = options.maxAttempts === undefined ? 3 : options.maxAttempts;
+    const startPrepared = options.startPrepared === true;
+    const sessionId = text(options.sessionId);
+    const creating = !startPrepared && (options.action === "start" || (once && sessionId === null));
     const maxDispatches = options.maxDispatches === undefined ? DEFAULT_MAX_DISPATCHES : options.maxDispatches;
     const runner = options.runner ?? cliHooks.runner ?? new AgentToolRunner(adapterMap());
+    runner.itemProgress = options.itemProgress === true;
     const result = await executeNamedWorkflow(workspace, {
-        workflowId: creating ? (options.workflowId ?? null) : null,
+        workflowId: creating || startPrepared ? (options.workflowId ?? null) : null,
         task: creating ? (options.task ?? null) : null,
-        sessionId: creating ? null : (options.sessionId ?? null),
+        sessionId: creating ? null : sessionId,
         priorSessionId: options.priorSessionId ?? null,
-        maxAttempts: once ? null : maxAttempts,
+        startPrepared,
         maxDispatches: once ? null : maxDispatches,
+        continueFailed: options.continueFailed === true,
+        stageId: options.stageId ?? null,
         once,
         resetRevisions: options.action === "continue",
+        refreshWorkflow: options.refreshWorkflow === true,
+        reply: options.reply ?? null,
     }, runner);
-    printResult(result);
+    printResult(workspace, result);
+    printResumeHint(result);
     return result.code;
 }
-function printResult(result) {
-    process.stdout.write(`${JSON.stringify({
-        session_id: result.sessionId,
-        session_status: result.status,
-        stop_reason: result.stopReason,
-        outputs: result.outputs,
-        stages: result.stages,
-    })}\n`);
-}
-function text(value) {
-    if (typeof value !== "string")
+function printResumeHint(result) {
+    if (result.sessionId === "" || result.status === "completed" || result.stopReason === "completed")
+        return;
+    if (result.stopReason === "configuration")
+        return;
+    printResumeCommand(result.sessionId);
+}
+const INSPECT_EXIT_CODES = new Set([1, 3, 6, 8]);
+function printResult(workspace, result) {
+    if (result.status === "completed" || result.stopReason === "completed") {
+        const duration = sessionDurationLabel(workspace, result.sessionId);
+        log(duration === null ? "completed" : `completed · ${duration}`);
+        for (const filePath of artifactPaths(workspace, result.sessionId, result.outputs)) {
+            log(`artifact: ${filePath}`);
+        }
+        return;
+    }
+    if (INSPECT_EXIT_CODES.has(result.code) && result.latestExecutionId) {
+        log(`response: executions/${result.latestExecutionId}/response.md`);
+    }
+    if (result.code === 7 && result.latestExecutionId) {
+        log(`verify: executions/${result.latestExecutionId}/turns/01/verify.md`);
+    }
+}
+function artifactPaths(workspace, sessionId, outputs) {
+    if (sessionId === "")
+        return [];
+    const sessionDir = path.resolve(workspace, ".migent", "sessions", sessionId);
+    const paths = [];
+    for (const [name, value] of Object.entries(outputs)) {
+        const record = isRecord(value) ? value : {};
+        const relative = typeof record.path === "string" && record.path !== "" ? record.path : path.join("outputs", name);
+        paths.push(absoluteFromRoot(path.resolve(sessionDir, relative)));
+    }
+    return paths;
+}
+function absoluteFromRoot(target) {
+    try {
+        return realpathSync(target);
+    }
+    catch {
+        return path.resolve(target);
+    }
+}
+function sessionDurationLabel(workspace, sessionId) {
+    if (sessionId === "")
+        return null;
+    const executions = path.join(workspace, ".migent", "sessions", sessionId, "executions");
+    let names;
+    try {
+        names = readdirSync(executions);
+    }
+    catch {
         return null;
-    const stripped = value.trim();
-    return stripped === "" ? null : stripped;
+    }
+    let total = 0;
+    let counted = false;
+    for (const name of names) {
+        const elapsed = executionElapsedMs(path.join(executions, name, "execution.json"));
+        if (elapsed === null)
+            continue;
+        total += elapsed;
+        counted = true;
+    }
+    return counted ? formatDuration(total) : null;
+}
+function executionElapsedMs(filePath) {
+    try {
+        const metadata = JSON.parse(readFileSync(filePath, "utf8"));
+        if (!isRecord(metadata))
+            return null;
+        const started = parsedTime(metadata.created_at);
+        if (started === null)
+            return null;
+        return (parsedTime(metadata.completed_at) ?? Date.now()) - started;
+    }
+    catch {
+        return null;
+    }
+}
+function parsedTime(value) {
+    if (typeof value !== "string" || value === "")
+        return null;
+    const parsed = Date.parse(value);
+    return Number.isNaN(parsed) ? null : parsed;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
 }

package/dist/commands/init.d.ts

@@ -18,6 +18,7 @@ export declare function runInit(workspace: string, options?: {
     model?: string | null;
     options?: readonly string[];
     preset?: string;
+    presetExplicit?: boolean;
     skill?: boolean;
     interactive?: boolean;
     adapters?: Record<string, AgentAdapter> | null;

package/dist/commands/init.js

@@ -1,7 +1,9 @@
-import { mkdirSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { mkdirSync, readdirSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { confirm as clackConfirm, isCancel, select as clackSelect } from "@clack/prompts";
-import { diagnose, whichSync, yamlScalar } from "@nodeint/migent-kernel";
+import { ConfigurationError, diagnose, whichSync, yamlScalar, } from "@nodeint/migent-kernel";
+import { PromptCancelled } from "../errors.js";
+import { exists, isDirectory, isFile } from "../fs-utils.js";
 import { printAlreadyInitialized, printCreated, printError, printInitConflicts, } from "../display.js";
 import { cliHooks } from "../hooks.js";
 import { runDoctor } from "./doctor.js";
@@ -22,11 +24,23 @@ export async function runInit(workspace, options = {}) {
         printError("preset must be implement or plan.");
         return 2;
     }
+    const optionPairs = options.options ?? [];
+    const classified = classify(workspace, chosen, resolve);
+    if (classified.state === "ready") {
+        if (provider !== null || model !== null || optionPairs.length > 0) {
+            printError("Already initialized; ignoring --provider/--model/--option.");
+        }
+        if (options.presetExplicit === true)
+            printError("Already initialized; ignoring --preset.");
+        printAlreadyInitialized();
+        if (skill)
+            return installSkill(workspace);
+        return 0;
+    }
     if ((provider === null) !== (model === null)) {
         printError("Pass both --provider and --model, or omit both.");
         return 2;
     }
-    const optionPairs = options.options ?? [];
     if (optionPairs.length > 0 && provider === null) {
         printError("Pass --provider and --model with --option.");
         return 2;
@@ -35,13 +49,6 @@ export async function runInit(workspace, options = {}) {
         printError("Pass --provider and --model when init is not interactive.");
         return 2;
     }
-    const classified = classify(workspace, chosen, resolve);
-    if (classified.state === "ready") {
-        printAlreadyInitialized();
-        if (skill)
-            return installSkill(workspace);
-        return 0;
-    }
     if (classified.state === "conflict") {
         printInitConflicts(classified.conflicts);
         return 1;
@@ -56,6 +63,8 @@ export async function runInit(workspace, options = {}) {
         });
     }
     catch (error) {
+        if (error instanceof PromptCancelled)
+            throw error;
         printError(error instanceof Error ? error.message : String(error));
         return 2;
     }
@@ -65,6 +74,8 @@ export async function runInit(workspace, options = {}) {
             install = await prompt.confirm("Install the Migent skill in .agents/skills/migent?");
         }
         catch (error) {
+            if (error instanceof PromptCancelled)
+                throw error;
             printError(error instanceof Error ? error.message : String(error));
             return 2;
         }
@@ -72,8 +83,24 @@ export async function runInit(workspace, options = {}) {
     if (install && installSkill(workspace) !== 0)
         return 1;
     const paths = writeProject(workspace, preset, primary);
-    printCreated(paths, `migent start ${preset} --task "..."`);
-    return runDoctor(workspace, { which: resolve });
+    printCreated(paths, `migent session run --workflow ${preset} --task "..."`);
+    if (interactive) {
+        const doctorCode = await runDoctor(workspace, { which: resolve });
+        if (doctorCode !== 0)
+            writeDoctorProblems(workspace, chosen, resolve);
+    }
+    else {
+        writeDoctorProblems(workspace, chosen, resolve);
+    }
+    return 0;
+}
+function writeDoctorProblems(workspace, adapters, which) {
+    const problems = diagnose(workspace, { adapters, which }).flatMap((check) => check.problems);
+    if (problems.length === 0)
+        return;
+    process.stderr.write("Doctor reported problems:\n");
+    for (const problem of problems)
+        process.stderr.write(`${problem}\n`);
 }
 async function choices(adapters, which, prompt, args) {
     let provider = args.provider;
@@ -84,7 +111,7 @@ async function choices(adapters, which, prompt, args) {
         provider = await prompt.selectProvider(rows, "Default provider");
         const adapter = adapters[provider];
         if (adapter === undefined)
-            throw new Error(`Unknown provider: ${provider}.`);
+            throw new ConfigurationError(`Unknown provider: ${provider}.`);
         const catalog = await loadCatalog(adapter, which, args.runCommand);
         model = await prompt.selectModel(provider, catalog, "Model");
         stored = await promptOptions(adapter, model, catalog, which, args.runCommand, prompt);
@@ -92,13 +119,13 @@ async function choices(adapters, which, prompt, args) {
     else {
         const adapter = requireAdapter(adapters, provider);
         if (model === null)
-            throw new Error("Model is required.");
+            throw new ConfigurationError("Model is required.");
         const catalog = await loadCatalog(adapter, which, args.runCommand);
         model = knownModel(model, catalog);
         stored = await acceptedOptions(adapter, model, catalog, which, args.runCommand, args.options);
     }
     if (model.trim() === "")
-        throw new Error("Model is required.");
+        throw new ConfigurationError("Model is required.");
     const primary = { provider, model: model.trim(), options: stored };
     return primary;
 }
@@ -151,7 +178,7 @@ function renderConfig(preset, primary) {
         roles = [["developer", "default"]];
     else
         roles = [["planner", "default"], ["reviewer", "default"]];
-    const lines = ["schema_version: 1", "models:"];
+    const lines = ["schema_version: 2", "models:"];
     for (const [name, choice] of models) {
         lines.push(`  ${name}:`, `    provider: ${yamlScalar(choice.provider)}`, `    model: ${yamlScalar(choice.model)}`);
         const entries = Object.entries(choice.options);
@@ -168,7 +195,7 @@ function renderConfig(preset, primary) {
 }
 function renderWorkflow(preset) {
     if (preset === "implement") {
-        return ("schema_version: 1\n" +
+        return ("schema_version: 2\n" +
             "id: implement\n" +
             "stages:\n" +
             "  - id: implement\n" +
@@ -176,11 +203,9 @@ function renderWorkflow(preset) {
             "    depends_on: []\n" +
             "    instructions:\n" +
             "      - Implement the requested change.\n" +
-            "      - Verify the result with relevant checks or tests.\n" +
-            "completion:\n" +
-            "  stage: implement\n");
+            "      - Verify the result with relevant checks or tests.\n");
     }
-    return ("schema_version: 1\n" +
+    return ("schema_version: 2\n" +
         "id: plan\n" +
         "stages:\n" +
         "  - id: plan\n" +
@@ -189,6 +214,7 @@ function renderWorkflow(preset) {
         "    max_revisions: 3\n" +
         "    instructions:\n" +
         "      - Analyze the task and write an implementation plan.\n" +
+        "      - When revising, edit the existing plan.md in place. Do not replace the whole file.\n" +
         "    produces:\n" +
         "      artifact: plan.md\n" +
         "  - id: review-plan\n" +
@@ -197,6 +223,7 @@ function renderWorkflow(preset) {
         "      - plan\n" +
         "    instructions:\n" +
         "      - Review the plan for correctness, missing risks, and unnecessary scope.\n" +
+        "      - Report every gap of the same kind in one response.\n" +
         "    decision:\n" +
         "      values:\n" +
         "        - approved\n" +
@@ -204,13 +231,10 @@ function renderWorkflow(preset) {
         "      routes:\n" +
         "        approved: complete\n" +
         "        revise: plan\n" +
-        "completion:\n" +
-        "  stage: review-plan\n" +
-        "  decision: approved\n" +
-        "  outputs:\n" +
-        "    - name: plan\n" +
-        "      from_stage: plan\n" +
-        "      artifact: plan.md\n");
+        "outputs:\n" +
+        "  - name: plan\n" +
+        "    from_stage: plan\n" +
+        "    artifact: plan.md\n");
 }
 async function promptOptions(adapter, model, catalog, which, runCommand, prompt) {
     const stored = {};
@@ -232,28 +256,32 @@ function providerOptions(adapter) {
 class ClackPrompter {
     async selectProvider(rows, message) {
         if (rows.length === 0)
-            throw new Error("No providers are available.");
+            throw new ConfigurationError("No providers are available.");
         const names = new Set(rows.map(([name]) => name));
         const result = await clackSelect({
             message,
             options: rows.map(([name, found]) => ({ value: name, label: `${name}  ${found ?? "not found"}` })),
             initialValue: rows[0]?.[0],
         });
-        if (isCancel(result) || typeof result !== "string" || !names.has(result))
-            throw new Error("Provider is required.");
+        if (isCancel(result))
+            throw new PromptCancelled();
+        if (typeof result !== "string" || !names.has(result))
+            throw new ConfigurationError("Provider is required.");
         return result;
     }
     async selectModel(_provider, catalog, message) {
         if (catalog.ids.length === 0)
-            throw new Error("Model is required.");
+            throw new ConfigurationError("Model is required.");
         const initial = catalog.defaultId && catalog.ids.includes(catalog.defaultId) ? catalog.defaultId : catalog.ids[0];
         const result = await clackSelect({
             message,
             options: catalog.ids.map((id) => ({ value: id, label: id })),
             initialValue: initial,
         });
-        if (isCancel(result) || !catalog.ids.includes(String(result)))
-            throw new Error(`Unknown model: ${String(result)}.`);
+        if (isCancel(result))
+            throw new PromptCancelled();
+        if (!catalog.ids.includes(String(result)))
+            throw new ConfigurationError(`Unknown model: ${String(result)}.`);
         return String(result);
     }
     async selectOption(name, values, allowDefault) {
@@ -269,40 +297,19 @@ class ClackPrompter {
             initialValue: allowDefault ? "" : values[0],
         });
         const allowed = new Set(allowDefault ? ["", ...values] : values);
-        if (isCancel(result) || !allowed.has(String(result ?? ""))) {
-            throw new Error(`Unknown ${name} value: ${String(result)}.`);
+        if (isCancel(result))
+            throw new PromptCancelled();
+        if (!allowed.has(String(result ?? ""))) {
+            throw new ConfigurationError(`Unknown ${name} value: ${String(result)}.`);
         }
         return result == null ? "" : String(result);
     }
     async confirm(message) {
         const result = await clackConfirm({ message, initialValue: true });
-        if (isCancel(result) || typeof result !== "boolean")
-            throw new Error("Answer yes or no.");
+        if (isCancel(result))
+            throw new PromptCancelled();
+        if (typeof result !== "boolean")
+            throw new ConfigurationError("Answer yes or no.");
         return result;
     }
 }
-function exists(filePath) {
-    try {
-        statSync(filePath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function isFile(filePath) {
-    try {
-        return statSync(filePath).isFile();
-    }
-    catch {
-        return false;
-    }
-}
-function isDirectory(filePath) {
-    try {
-        return statSync(filePath).isDirectory();
-    }
-    catch {
-        return false;
-    }
-}

package/dist/commands/prepare.d.ts

@@ -0,0 +1 @@
+export declare function prepareWorkflowSession(workspace: string, sessionId: string, workflowId: string, priorSessionId: string | null): number;

package/dist/commands/prepare.js

@@ -0,0 +1,14 @@
+import { createPreparedSession, log, relativeTaskPath } from "@nodeint/migent-kernel";
+import { requireCurrentSchema } from "../migrate.js";
+export function prepareWorkflowSession(workspace, sessionId, workflowId, priorSessionId) {
+    requireCurrentSchema(workspace);
+    const id = createPreparedSession(workspace, sessionId, workflowId, priorSessionId);
+    const payload = {
+        session_id: id,
+        status: "prepared",
+        task_path: relativeTaskPath(id),
+    };
+    process.stdout.write(`${JSON.stringify(payload)}\n`);
+    log(`session_id: ${id}`);
+    return 0;
+}

package/dist/commands/repair.d.ts

@@ -0,0 +1 @@
+export declare function repairWorkflowSession(workspace: string, sessionId: string, acceptTask: boolean): number;

package/dist/commands/repair.js

@@ -0,0 +1,22 @@
+import { isSessionLockLost, repairSession, SessionLockHeldError } from "@nodeint/migent-kernel";
+import { printError } from "../display.js";
+import { requireCurrentSchema } from "../migrate.js";
+export function repairWorkflowSession(workspace, sessionId, acceptTask) {
+    requireCurrentSchema(workspace);
+    try {
+        const status = repairSession(workspace, sessionId, { acceptTask });
+        const payload = {
+            session_id: sessionId,
+            status: typeof status.status === "string" ? status.status : null,
+        };
+        process.stdout.write(`${JSON.stringify(payload)}\n`);
+        return 0;
+    }
+    catch (error) {
+        if (error instanceof SessionLockHeldError || isSessionLockLost(error)) {
+            printError(error.message);
+            return 2;
+        }
+        throw error;
+    }
+}

package/dist/commands/service.js

@@ -34,6 +34,7 @@ export async function runServiceStop() {
         printError(result.message || "Registry service did not stop.");
         return 1;
     }
+    process.stderr.write(result.outcome === "absent" ? "Not running.\n" : "Stopped.\n");
     return 0;
 }
 export async function runServiceStatus(asJson) {
@@ -48,13 +49,13 @@ export async function runServiceStatus(asJson) {
     else {
         process.stdout.write("stopped\n");
     }
-    return 0;
+    return report.state === "running" ? 0 : 1;
 }
 export function parsePort(raw) {
     if (!/^[0-9]+$/.test(raw))
-        throw new ConfigurationError("--port must be an integer.");
+        throw new ConfigurationError("--port must be an integer from 1 to 65535.");
     const port = Number(raw);
-    if (port > 65535)
-        throw new ConfigurationError("--port must be an integer.");
+    if (port < 1 || port > 65535)
+        throw new ConfigurationError("--port must be an integer from 1 to 65535.");
     return port;
 }

package/dist/commands/sessions.d.ts

@@ -1,3 +1,26 @@
-export declare function listSessions(workspace: string, options?: {
+export interface SessionListOptions {
     asJson?: boolean;
+    workflow?: string | null;
+    status?: string | null;
+    limit?: number | null;
+    latest?: boolean;
+}
+export declare function listSessions(workspace: string, options?: SessionListOptions): number;
+export declare function runSessionMetrics(workspace: string, session: string | undefined, options: {
+    asJson: boolean;
+    workflow: string | null;
+    status: string | null;
+    limit: string | null;
 }): number;
+export declare function runSessions(workspace: string, session: string | undefined, options: {
+    asJson: boolean;
+    follow: boolean;
+    execution: string | null;
+    until: boolean;
+    cursor: string | undefined;
+    exitWhenDone: boolean;
+    workflow: string | null;
+    status: string | null;
+    limit: string | null;
+    latest: boolean;
+}): Promise<number>;