@nodeint/migent 0.0.0-stage → 0.1.2

package/dist/commands/execute.js

@@ -0,0 +1,39 @@
+import { AgentToolRunner, DEFAULT_MAX_DISPATCHES, executeNamedWorkflow, } from "@nodeint/migent-kernel";
+import { cliHooks } from "../hooks.js";
+import { requireCurrentSchema } from "../migrate.js";
+import { adapterMap } from "../provider.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 maxDispatches = options.maxDispatches === undefined ? DEFAULT_MAX_DISPATCHES : options.maxDispatches;
+    const runner = options.runner ?? cliHooks.runner ?? new AgentToolRunner(adapterMap());
+    const result = await executeNamedWorkflow(workspace, {
+        workflowId: creating ? (options.workflowId ?? null) : null,
+        task: creating ? (options.task ?? null) : null,
+        sessionId: creating ? null : (options.sessionId ?? null),
+        priorSessionId: options.priorSessionId ?? null,
+        maxAttempts: once ? null : maxAttempts,
+        maxDispatches: once ? null : maxDispatches,
+        once,
+        resetRevisions: options.action === "continue",
+    }, runner);
+    printResult(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")
+        return null;
+    const stripped = value.trim();
+    return stripped === "" ? null : stripped;
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,26 @@
+import type { ModelCatalog } from "@nodeint/migent-adapters";
+import { type AgentAdapter } from "@nodeint/migent-kernel";
+import { type RunCommand, type Which } from "../provider.js";
+export declare const PRESETS: readonly ["implement", "plan"];
+export interface ModelChoice {
+    provider: string;
+    model: string;
+    options: Record<string, string>;
+}
+export interface Prompter {
+    selectProvider(rows: ReadonlyArray<readonly [string, string | null, AgentAdapter]>, message: string): string | Promise<string>;
+    selectModel(provider: string, catalog: ModelCatalog, message: string): string | Promise<string>;
+    selectOption(name: string, values: readonly string[], allowDefault: boolean): string | Promise<string>;
+    confirm(message: string): boolean | Promise<boolean>;
+}
+export declare function runInit(workspace: string, options?: {
+    provider?: string | null;
+    model?: string | null;
+    options?: readonly string[];
+    preset?: string;
+    interactive?: boolean;
+    adapters?: Record<string, AgentAdapter> | null;
+    which?: Which | null;
+    prompter?: Prompter | null;
+    runCommand?: RunCommand | null;
+}): Promise<number>;

package/dist/commands/init.js

@@ -0,0 +1,311 @@
+import { mkdirSync, readdirSync, statSync, 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 { printAlreadyInitialized, printCreated, printError, printInitConflicts, } from "../display.js";
+import { cliHooks } from "../hooks.js";
+import { runDoctor } from "./doctor.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 interactive = options.interactive ?? false;
+    const chosen = options.adapters ?? adapterMap();
+    const resolve = options.which ?? cliHooks.which ?? whichSync;
+    const prompt = options.prompter ?? new ClackPrompter();
+    const execute = options.runCommand ?? runProviderCommand;
+    if (!PRESETS.includes(preset)) {
+        printError("preset must be implement or plan.");
+        return 2;
+    }
+    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;
+    }
+    if (provider === null && !interactive) {
+        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, {
+            provider,
+            model,
+            options: parseOptions(optionPairs),
+            preset,
+            interactive,
+            runCommand: execute,
+        });
+    }
+    catch (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 });
+}
+async function choices(adapters, which, prompt, args) {
+    let provider = args.provider;
+    let model = args.model;
+    let stored;
+    if (provider === null) {
+        const rows = detected(adapters, which);
+        provider = await prompt.selectProvider(rows, "Default provider");
+        const adapter = adapters[provider];
+        if (adapter === undefined)
+            throw new Error(`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);
+    }
+    else {
+        const adapter = requireAdapter(adapters, provider);
+        if (model === null)
+            throw new Error("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.");
+    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 }];
+}
+function classify(workspace, adapters, which) {
+    const root = path.join(workspace, ".migent");
+    const config = path.join(root, "config.yaml");
+    const workflows = path.join(root, "workflows");
+    const gitignore = path.join(root, ".gitignore");
+    const owned = [];
+    if (exists(config))
+        owned.push(".migent/config.yaml");
+    if (exists(workflows)) {
+        owned.push(".migent/workflows");
+        if (isDirectory(workflows)) {
+            for (const name of readdirSync(workflows).filter((item) => item.endsWith(".yaml")).sort()) {
+                if (isFile(path.join(workflows, name)))
+                    owned.push(`.migent/workflows/${name}`);
+            }
+        }
+    }
+    if (exists(gitignore))
+        owned.push(".migent/.gitignore");
+    if (owned.length === 0)
+        return { state: "create", conflicts: [] };
+    const yamlFiles = isDirectory(workflows)
+        ? readdirSync(workflows).filter((name) => name.endsWith(".yaml") && isFile(path.join(workflows, name)))
+        : [];
+    if (isFile(config) && yamlFiles.length > 0) {
+        const checks = diagnose(workspace, { adapters, which });
+        const byName = new Map(checks.map((check) => [check.name, check]));
+        if (byName.get("config")?.ok && byName.get("workflows")?.ok)
+            return { state: "ready", conflicts: [] };
+    }
+    return { state: "conflict", conflicts: owned };
+}
+function writeProject(workspace, preset, primary, reviewer) {
+    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");
+    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) {
+    const models = [["default", primary]];
+    let roles;
+    if (preset === "implement")
+        roles = [["developer", "default"]];
+    else if (reviewer === null)
+        roles = [["planner", "default"], ["reviewer", "default"]];
+    else {
+        models.push(["review", reviewer]);
+        roles = [["planner", "default"], ["reviewer", "review"]];
+    }
+    const lines = ["schema_version: 1", "models:"];
+    for (const [name, choice] of models) {
+        lines.push(`  ${name}:`, `    provider: ${yamlScalar(choice.provider)}`, `    model: ${yamlScalar(choice.model)}`);
+        const entries = Object.entries(choice.options);
+        if (entries.length > 0) {
+            lines.push("    options:");
+            for (const [optionName, value] of entries)
+                lines.push(`      ${optionName}: ${yamlScalar(value)}`);
+        }
+    }
+    lines.push("roles:");
+    for (const [role, modelName] of roles)
+        lines.push(`  ${role}:`, `    default_model: ${modelName}`);
+    return `${lines.join("\n")}\n`;
+}
+function renderWorkflow(preset) {
+    if (preset === "implement") {
+        return ("schema_version: 1\n" +
+            "id: implement\n" +
+            "stages:\n" +
+            "  - id: implement\n" +
+            "    role: developer\n" +
+            "    depends_on: []\n" +
+            "    instructions:\n" +
+            "      - Implement the requested change.\n" +
+            "      - Verify the result with relevant checks or tests.\n" +
+            "completion:\n" +
+            "  stage: implement\n");
+    }
+    return ("schema_version: 1\n" +
+        "id: plan\n" +
+        "stages:\n" +
+        "  - id: plan\n" +
+        "    role: planner\n" +
+        "    depends_on: []\n" +
+        "    max_revisions: 3\n" +
+        "    instructions:\n" +
+        "      - Analyze the task and write an implementation plan.\n" +
+        "    produces:\n" +
+        "      artifact: plan.md\n" +
+        "  - id: review-plan\n" +
+        "    role: reviewer\n" +
+        "    depends_on:\n" +
+        "      - plan\n" +
+        "    instructions:\n" +
+        "      - Review the plan for correctness, missing risks, and unnecessary scope.\n" +
+        "    decision:\n" +
+        "      values:\n" +
+        "        - approved\n" +
+        "        - revise\n" +
+        "      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");
+}
+async function promptOptions(adapter, model, catalog, which, runCommand, prompt) {
+    const stored = {};
+    for (const spec of providerOptions(adapter)) {
+        if (!spec.prompt)
+            continue;
+        const values = await loadOptionValues(adapter, spec.name, model, catalog, which, runCommand);
+        if (values === null || values.length === 0)
+            continue;
+        const picked = await prompt.selectOption(spec.name, values, spec.allowDefault ?? false);
+        if (picked)
+            stored[spec.name] = picked;
+    }
+    return stored;
+}
+function providerOptions(adapter) {
+    return asCatalog(adapter).providerOptions();
+}
+class ClackPrompter {
+    async selectProvider(rows, message) {
+        if (rows.length === 0)
+            throw new Error("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.");
+        return result;
+    }
+    async selectModel(_provider, catalog, message) {
+        if (catalog.ids.length === 0)
+            throw new Error("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)}.`);
+        return String(result);
+    }
+    async selectOption(name, values, allowDefault) {
+        if (values.length === 0)
+            return "";
+        const options = [
+            ...(allowDefault ? [{ value: "", label: "provider default" }] : []),
+            ...values.map((value) => ({ value, label: value })),
+        ];
+        const result = await clackSelect({
+            message: name,
+            options,
+            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)}.`);
+        }
+        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.");
+        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/service.d.ts

@@ -0,0 +1,11 @@
+import { serveForeground, serviceStatus, startDetached, stop } from "@nodeint/migent-registry";
+export declare const serviceApi: {
+    serveForeground: typeof serveForeground;
+    serviceStatus: typeof serviceStatus;
+    startDetached: typeof startDetached;
+    stop: typeof stop;
+};
+export declare function runServiceStart(port: number | null, foreground: boolean): Promise<number>;
+export declare function runServiceStop(): Promise<number>;
+export declare function runServiceStatus(asJson: boolean): Promise<number>;
+export declare function parsePort(raw: string): number;

package/dist/commands/service.js

@@ -0,0 +1,60 @@
+import { ConfigurationError } from "@nodeint/migent-kernel";
+import { ServiceError, ensureRegistryHome, registryHomePath, serveForeground, serviceStatus, startDetached, stop, } from "@nodeint/migent-registry";
+import { printError } from "../display.js";
+const DEFAULT_PORT = 47321;
+export const serviceApi = {
+    serveForeground,
+    serviceStatus,
+    startDetached,
+    stop,
+};
+export async function runServiceStart(port, foreground) {
+    const home = ensureRegistryHome();
+    const chosen = port ?? DEFAULT_PORT;
+    try {
+        if (foreground) {
+            await serviceApi.serveForeground(home, chosen);
+            return 0;
+        }
+        const endpoint = await serviceApi.startDetached(home, chosen);
+        process.stdout.write(`${endpoint.host}:${endpoint.port}\n`);
+        return 0;
+    }
+    catch (error) {
+        if (error instanceof ServiceError) {
+            printError(error.message);
+            return 1;
+        }
+        throw error;
+    }
+}
+export async function runServiceStop() {
+    const result = await serviceApi.stop(ensureRegistryHome());
+    if (result.outcome === "error") {
+        printError(result.message || "Registry service did not stop.");
+        return 1;
+    }
+    return 0;
+}
+export async function runServiceStatus(asJson) {
+    const report = await serviceApi.serviceStatus(registryHomePath());
+    if (asJson) {
+        process.stdout.write(`${JSON.stringify(report)}\n`);
+    }
+    else if (report.state === "running") {
+        process.stdout.write("running\n");
+        process.stdout.write(`${String(report.host)}:${String(report.port)} pid=${String(report.pid)}\n`);
+    }
+    else {
+        process.stdout.write("stopped\n");
+    }
+    return 0;
+}
+export function parsePort(raw) {
+    if (!/^[0-9]+$/.test(raw))
+        throw new ConfigurationError("--port must be an integer.");
+    const port = Number(raw);
+    if (port > 65535)
+        throw new ConfigurationError("--port must be an integer.");
+    return port;
+}

package/dist/commands/sessions.d.ts

@@ -0,0 +1,3 @@
+export declare function listSessions(workspace: string, options?: {
+    asJson?: boolean;
+}): number;

package/dist/commands/sessions.js

@@ -0,0 +1,20 @@
+import { listSessionRows } from "@nodeint/migent-kernel";
+import { printSessions } from "../display.js";
+export function listSessions(workspace, options = {}) {
+    const rows = listSessionRows(workspace);
+    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`);
+        return 0;
+    }
+    printSessions(rows);
+    return 0;
+}

package/dist/commands/skill.d.ts

@@ -0,0 +1,4 @@
+export declare function installSkill(workspace: string): number;
+export declare function updateSkill(workspace: string, options?: {
+    force?: boolean;
+}): number;

package/dist/commands/skill.js

@@ -0,0 +1,98 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { printError } from "../display.js";
+const SKILL_RELATIVE = path.join(".agents", "skills", "migent");
+const STATE_FILENAME = ".migent-template.json";
+const TEMPLATE_VERSION = 1;
+export function installSkill(workspace) {
+    const skillDirectory = path.join(workspace, SKILL_RELATIVE);
+    if (existsSync(skillDirectory)) {
+        printError(`${displayPath(skillDirectory, workspace)} already exists; use \`migent skill update\`.`);
+        return 1;
+    }
+    const content = templateContent();
+    mkdirSync(skillDirectory, { recursive: true });
+    writeManagedSkill(skillDirectory, content);
+    process.stdout.write(`Installed ${displayPath(skillDirectory, workspace)}\n`);
+    return 0;
+}
+export function updateSkill(workspace, options = {}) {
+    const skillDirectory = path.join(workspace, SKILL_RELATIVE);
+    const skillPath = path.join(skillDirectory, "SKILL.md");
+    const statePath = path.join(skillDirectory, STATE_FILENAME);
+    if (!isDirectory(skillDirectory) || !isFile(skillPath)) {
+        printError("Migent skill is not installed; run `migent skill install`.");
+        return 1;
+    }
+    const state = readState(statePath);
+    if (state === null) {
+        printError("Existing Migent skill is not managed by Migent; move it aside and run `migent skill install`.");
+        return 1;
+    }
+    const current = readFileSync(skillPath, "utf8");
+    const installedDigest = state.content_sha256;
+    const currentDigest = digest(current);
+    if (installedDigest !== currentDigest && !options.force) {
+        printError("Migent skill has local changes; rerun with `migent skill update --force` to replace them.");
+        return 1;
+    }
+    const content = templateContent();
+    if (current === content && installedDigest === currentDigest && state.template_version === TEMPLATE_VERSION) {
+        process.stdout.write(`Already up to date: ${displayPath(skillDirectory, workspace)}\n`);
+        return 0;
+    }
+    writeManagedSkill(skillDirectory, content);
+    process.stdout.write(`Updated ${displayPath(skillDirectory, workspace)}\n`);
+    return 0;
+}
+function templateContent() {
+    const nextToModule = fileURLToPath(new URL("../templates/migent/SKILL.md", import.meta.url));
+    return readFileSync(nextToModule, "utf8");
+}
+function writeManagedSkill(skillDirectory, content) {
+    writeFileSync(path.join(skillDirectory, "SKILL.md"), content, "utf8");
+    const state = {
+        schema_version: 1,
+        template_version: TEMPLATE_VERSION,
+        content_sha256: digest(content),
+    };
+    writeFileSync(path.join(skillDirectory, STATE_FILENAME), `${JSON.stringify(state, null, 2)}\n`, "utf8");
+}
+function readState(filePath) {
+    try {
+        const payload = JSON.parse(readFileSync(filePath, "utf8"));
+        if (!isRecord(payload) || payload.schema_version !== 1)
+            return null;
+        return payload;
+    }
+    catch {
+        return null;
+    }
+}
+function digest(content) {
+    return createHash("sha256").update(content, "utf8").digest("hex");
+}
+function displayPath(filePath, workspace) {
+    return path.relative(workspace, filePath).split(path.sep).join("/");
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+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/watch.d.ts

@@ -0,0 +1,7 @@
+export declare function watchSession(workspace: string, sessionId: string, options?: {
+    once?: boolean;
+    executionId?: string | null;
+    untilTerminal?: boolean;
+    jsonLines?: boolean;
+    cursor?: number | null;
+}): Promise<number>;