@nodeint/migent 0.1.3 → 0.1.5

package/dist/commands/init.js

@@ -1,16 +1,20 @@
-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";
+import { installSkill } from "./skill.js";
 import { acceptedOptions, adapterMap, asCatalog, detected, knownModel, loadCatalog, loadOptionValues, parseOptions, requireAdapter, runProviderCommand, } from "../provider.js";
 export const PRESETS = ["implement", "plan"];
 export async function runInit(workspace, options = {}) {
     const provider = options.provider ?? null;
     const model = options.model ?? null;
     const preset = options.preset ?? "implement";
+    const skill = options.skill === true;
     const interactive = options.interactive ?? false;
     const chosen = options.adapters ?? adapterMap();
     const resolve = options.which ?? cliHooks.which ?? whichSync;
@@ -20,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;
@@ -33,34 +49,58 @@ 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();
-        return 0;
-    }
     if (classified.state === "conflict") {
         printInitConflicts(classified.conflicts);
         return 1;
     }
     let primary;
-    let reviewer;
     try {
-        [primary, reviewer] = await choices(chosen, resolve, prompt, {
+        primary = await choices(chosen, resolve, prompt, {
             provider,
             model,
             options: parseOptions(optionPairs),
-            preset,
-            interactive,
             runCommand: execute,
         });
     }
     catch (error) {
+        if (error instanceof PromptCancelled)
+            throw error;
         printError(error instanceof Error ? error.message : String(error));
         return 2;
     }
-    const paths = writeProject(workspace, preset, primary, reviewer);
-    printCreated(paths, `migent start ${preset} --task "..."`);
-    return runDoctor(workspace, { which: resolve });
+    let install = skill;
+    if (!install && interactive) {
+        try {
+            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;
+        }
+    }
+    if (install && installSkill(workspace) !== 0)
+        return 1;
+    const paths = writeProject(workspace, preset, primary);
+    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;
@@ -71,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);
@@ -79,27 +119,15 @@ 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 };
-    if (args.preset !== "plan" || !args.interactive)
-        return [primary, null];
-    if (await prompt.confirm("Use the default model for both planner and reviewer?"))
-        return [primary, null];
-    const rows = detected(adapters, which);
-    const reviewerProvider = await prompt.selectProvider(rows, "Reviewer provider");
-    const reviewerAdapter = adapters[reviewerProvider];
-    if (reviewerAdapter === undefined)
-        throw new Error(`Unknown provider: ${reviewerProvider}.`);
-    const reviewerCatalog = await loadCatalog(reviewerAdapter, which, args.runCommand);
-    const reviewerModel = (await prompt.selectModel(reviewerProvider, reviewerCatalog, "Reviewer model")).trim();
-    const reviewerOptions = await promptOptions(reviewerAdapter, reviewerModel, reviewerCatalog, which, args.runCommand, prompt);
-    return [primary, { provider: reviewerProvider, model: reviewerModel, options: reviewerOptions }];
+    return primary;
 }
 function classify(workspace, adapters, which) {
     const root = path.join(workspace, ".migent");
@@ -133,28 +161,24 @@ function classify(workspace, adapters, which) {
     }
     return { state: "conflict", conflicts: owned };
 }
-function writeProject(workspace, preset, primary, reviewer) {
+function writeProject(workspace, preset, primary) {
     const root = path.join(workspace, ".migent");
     const workflows = path.join(root, "workflows");
     mkdirSync(workflows, { recursive: true });
-    writeFileSync(path.join(root, "config.yaml"), renderConfig(preset, primary, reviewer), "utf8");
+    writeFileSync(path.join(root, "config.yaml"), renderConfig(preset, primary), "utf8");
     const workflowName = `${preset}.yaml`;
     writeFileSync(path.join(workflows, workflowName), renderWorkflow(preset), "utf8");
     writeFileSync(path.join(root, ".gitignore"), "sessions/\n", "utf8");
     return [".migent/config.yaml", `.migent/workflows/${workflowName}`, ".migent/.gitignore"];
 }
-function renderConfig(preset, primary, reviewer) {
+function renderConfig(preset, primary) {
     const models = [["default", primary]];
     let roles;
     if (preset === "implement")
         roles = [["developer", "default"]];
-    else if (reviewer === null)
+    else
         roles = [["planner", "default"], ["reviewer", "default"]];
-    else {
-        models.push(["review", reviewer]);
-        roles = [["planner", "default"], ["reviewer", "review"]];
-    }
-    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);
@@ -171,7 +195,7 @@ function renderConfig(preset, primary, reviewer) {
 }
 function renderWorkflow(preset) {
     if (preset === "implement") {
-        return ("schema_version: 1\n" +
+        return ("schema_version: 2\n" +
             "id: implement\n" +
             "stages:\n" +
             "  - id: implement\n" +
@@ -179,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" +
@@ -192,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" +
@@ -200,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" +
@@ -207,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 = {};
@@ -235,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) {
@@ -272,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>;

package/dist/commands/sessions.js

@@ -1,20 +1,172 @@
-import { listSessionRows } from "@nodeint/migent-kernel";
-import { printSessions } from "../display.js";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { listSessionMetrics, listSessionRows, sessionMetrics, ConfigurationError } from "@nodeint/migent-kernel";
+import { printError, printSessions } from "../display.js";
+import { adapterMap } from "../provider.js";
+import { SESSION_COLUMN, sessionFields } from "../session-row.js";
+import { optionalText } from "../text.js";
+import { followSession } from "./watch.js";
+const SESSION_STATUSES = new Set(["active", "prepared", "completed", "blocked", "cancelled", "corrupt"]);
 export function listSessions(workspace, options = {}) {
-    const rows = listSessionRows(workspace);
+    const rows = selectSessionRows(listSessionRows(workspace), options);
+    if (options.latest) {
+        const row = rows[0];
+        if (options.asJson) {
+            process.stdout.write(`${JSON.stringify(row === undefined ? null : sessionJson(row))}\n`);
+            return 0;
+        }
+        printSessions(row === undefined ? [] : [row]);
+        return 0;
+    }
     if (options.asJson) {
-        const payload = rows.map((row) => ({
-            session: row[1] ?? "",
-            workflow: row[2] ?? "",
-            status: row[3] ?? "",
-            execution: row[4] ?? "",
-            decision: row[5] ?? "",
-            outputs: row[6] ?? "",
-            task: row[7] ?? "",
-        }));
-        process.stdout.write(`${JSON.stringify(payload)}\n`);
+        process.stdout.write(`${JSON.stringify(rows.map((row) => sessionJson(row)))}\n`);
         return 0;
     }
     printSessions(rows);
     return 0;
 }
+export function runSessionMetrics(workspace, session, options) {
+    if (!options.asJson) {
+        printError("session metrics requires --json.");
+        return 2;
+    }
+    const selection = parseListSelection({ ...options, latest: false });
+    const sessionId = optionalText(session);
+    if (sessionId !== null && hasListFilter(selection)) {
+        printError("List filters cannot be combined with a session.");
+        return 2;
+    }
+    const adapters = adapterMap();
+    if (sessionId === null) {
+        const rows = listSessionMetrics(workspace, adapters, {
+            workflow: selection.workflow ?? null,
+            status: selection.status ?? null,
+            limit: selection.limit ?? null,
+        });
+        for (const row of rows)
+            process.stdout.write(`${JSON.stringify(row)}\n`);
+        return 0;
+    }
+    const eventsPath = path.join(workspace, ".migent", "sessions", sessionId, "events.jsonl");
+    if (!existsSync(eventsPath)) {
+        printError(`No events found for session: ${sessionId}`);
+        return 2;
+    }
+    process.stdout.write(`${JSON.stringify(sessionMetrics(workspace, sessionId, adapters))}\n`);
+    return 0;
+}
+export async function runSessions(workspace, session, options) {
+    const selection = parseListSelection(options);
+    const sessionId = optionalText(session);
+    if (sessionId !== null && hasListFilter(selection)) {
+        printError("List filters cannot be combined with a session.");
+        return 2;
+    }
+    if (sessionId === null)
+        return listOnly(workspace, options, selection);
+    if (options.until && !options.follow) {
+        printError("--until requires --follow.");
+        return 2;
+    }
+    if (options.cursor !== undefined && !options.follow) {
+        printError("--cursor requires --follow.");
+        return 2;
+    }
+    if (options.exitWhenDone && !options.follow) {
+        printError("--exit-when-done requires --follow.");
+        return 2;
+    }
+    if (options.until && options.execution === null) {
+        printError("--until requires --execution.");
+        return 2;
+    }
+    const cursor = parseCursor(options.cursor);
+    return followSession(workspace, sessionId, {
+        once: !options.follow,
+        executionId: options.execution,
+        untilTerminal: options.until,
+        jsonLines: options.asJson,
+        cursor,
+        exitWhenDone: options.exitWhenDone,
+    });
+}
+function listOnly(workspace, options, selection) {
+    if (options.follow) {
+        printError("--follow requires a session.");
+        return 2;
+    }
+    if (options.until) {
+        printError("--until requires --follow.");
+        return 2;
+    }
+    if (options.cursor !== undefined) {
+        printError("--cursor requires --follow.");
+        return 2;
+    }
+    if (options.exitWhenDone) {
+        printError("--exit-when-done requires --follow.");
+        return 2;
+    }
+    if (options.execution !== null) {
+        printError("--execution requires a session.");
+        return 2;
+    }
+    return listSessions(workspace, { ...selection, asJson: options.asJson });
+}
+function selectSessionRows(rows, options) {
+    let selected = [...rows];
+    if (options.workflow != null) {
+        selected = selected.filter((row) => row[SESSION_COLUMN.workflow] === options.workflow);
+    }
+    if (options.status != null) {
+        selected = selected.filter((row) => row[SESSION_COLUMN.status] === options.status);
+    }
+    const limit = options.latest ? 1 : (options.limit ?? null);
+    if (limit !== null)
+        return selected.slice(0, limit);
+    return selected;
+}
+function sessionJson(row) {
+    const fields = sessionFields(row);
+    return {
+        session: fields.session,
+        workflow: fields.workflow,
+        status: fields.status,
+        execution: fields.execution,
+        decision: fields.decision,
+        outputs: fields.outputs,
+    };
+}
+function hasListFilter(selection) {
+    return selection.latest === true || selection.workflow != null || selection.status != null || selection.limit != null;
+}
+function parseListSelection(options) {
+    const workflow = optionalText(options.workflow);
+    if (options.workflow !== null && workflow === null)
+        throw new ConfigurationError("--workflow is empty.");
+    const status = optionalText(options.status);
+    if (options.status !== null && status === null)
+        throw new ConfigurationError("--status is empty.");
+    if (status !== null && !SESSION_STATUSES.has(status)) {
+        throw new ConfigurationError("--status must be active, prepared, completed, blocked, cancelled, or corrupt.");
+    }
+    let limit = null;
+    if (options.limit !== null) {
+        if (!/^[0-9]+$/.test(options.limit))
+            throw new ConfigurationError("--limit must be an integer >= 1.");
+        limit = Number(options.limit);
+        if (limit < 1)
+            throw new ConfigurationError("--limit must be an integer >= 1.");
+    }
+    if (options.latest && limit !== null)
+        throw new ConfigurationError("--latest cannot be combined with --limit.");
+    return { workflow, status, limit, latest: options.latest };
+}
+function parseCursor(raw) {
+    if (raw === undefined)
+        return null;
+    const cursor = Number(raw);
+    if (!Number.isInteger(cursor) || cursor < 0)
+        throw new ConfigurationError("--cursor must be >= 0.");
+    return cursor;
+}