@nodeint/migent 0.0.0-stage → 0.1.0

package/dist/provider.js

@@ -0,0 +1,136 @@
+import { spawnSync } from "node:child_process";
+import { ModelCatalog, defaultAdapters } from "@nodeint/migent-adapters";
+export class ProviderCommandFailed extends Error {
+}
+export function adapterMap() {
+    return defaultAdapters();
+}
+export function asCatalog(adapter) {
+    const candidate = adapter;
+    if (typeof candidate.modelCatalogCommand !== "function" || typeof candidate.parseModelCatalog !== "function") {
+        throw new ProviderCommandFailed(`${adapter.command} does not list models.`);
+    }
+    return candidate;
+}
+export function requireAdapter(adapters, provider) {
+    const adapter = adapters[provider];
+    if (adapter === undefined) {
+        const supported = Object.keys(adapters).sort().join(", ");
+        throw new ProviderCommandFailed(`Unknown provider: ${provider}. Supported: ${supported}.`);
+    }
+    return adapter;
+}
+export function detected(adapters, which) {
+    const rows = Object.entries(adapters).map(([name, adapter]) => [name, which(adapter.command), adapter]);
+    rows.sort((left, right) => {
+        const leftMissing = left[1] === null ? 1 : 0;
+        const rightMissing = right[1] === null ? 1 : 0;
+        if (leftMissing !== rightMissing)
+            return leftMissing - rightMissing;
+        if (left[0] < right[0])
+            return -1;
+        if (left[0] > right[0])
+            return 1;
+        return 0;
+    });
+    return rows;
+}
+export async function loadCatalog(adapter, which, runCommand) {
+    if (which(adapter.command) === null) {
+        throw new ProviderCommandFailed(`${adapter.command} is not on PATH, so its models could not be listed.`);
+    }
+    const catalogAdapter = asCatalog(adapter);
+    let stdout;
+    try {
+        stdout = await runCommand(catalogAdapter.modelCatalogCommand());
+    }
+    catch (error) {
+        if (error instanceof ProviderCommandFailed)
+            throw error;
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new ProviderCommandFailed(`Could not list ${adapter.command} models: ${reason}`);
+    }
+    const catalog = catalogAdapter.parseModelCatalog(stdout);
+    if (catalog.ids.length === 0)
+        throw new ProviderCommandFailed(`${adapter.command} returned no models.`);
+    return catalog;
+}
+export function knownModel(model, catalog) {
+    const value = model.trim();
+    if (!catalog.ids.includes(value))
+        throw new ProviderCommandFailed(`Unknown model: ${value}.`);
+    return value;
+}
+export function parseOptions(pairs) {
+    const parsed = {};
+    for (const pair of pairs) {
+        if (!pair.includes("="))
+            throw new ProviderCommandFailed(`Option must be KEY=VALUE: ${pair}.`);
+        const index = pair.indexOf("=");
+        const name = pair.slice(0, index).trim();
+        const value = pair.slice(index + 1).trim();
+        if (name === "" || value === "")
+            throw new ProviderCommandFailed(`Option must be KEY=VALUE: ${pair}.`);
+        parsed[name] = value;
+    }
+    return parsed;
+}
+export async function loadOptionValues(adapter, name, model, catalog, which, runCommand) {
+    const found = catalog.valuesFor(model, name);
+    if (found !== null)
+        return found;
+    const catalogAdapter = asCatalog(adapter);
+    const argv = catalogAdapter.optionValuesCommand(name, model);
+    if (argv === null)
+        return null;
+    if (which(adapter.command) === null) {
+        throw new ProviderCommandFailed(`${adapter.command} is not on PATH, so its ${name} values could not be listed.`);
+    }
+    let text;
+    try {
+        text = await runCommand(argv);
+    }
+    catch (error) {
+        if (error instanceof ProviderCommandFailed)
+            text = error.message;
+        else {
+            const reason = error instanceof Error ? error.message : String(error);
+            throw new ProviderCommandFailed(`Could not list ${adapter.command} ${name} values for ${model}: ${reason}`);
+        }
+    }
+    return catalogAdapter.parseOptionValues(name, text, model);
+}
+export async function acceptedOptions(adapter, model, catalog, which, runCommand, options) {
+    if (Object.keys(options).length === 0)
+        return {};
+    adapter.validateOptions(options);
+    const stored = {};
+    for (const [name, value] of Object.entries(options)) {
+        const values = await loadOptionValues(adapter, name, model, catalog, which, runCommand);
+        if (values === null) {
+            stored[name] = value;
+            continue;
+        }
+        if (!values.includes(value)) {
+            if (values.length === 0)
+                throw new ProviderCommandFailed(`${model} does not accept ${name}.`);
+            throw new ProviderCommandFailed(`${name} must be one of: ${values.join(", ")}.`);
+        }
+        stored[name] = value;
+    }
+    return stored;
+}
+export function runProviderCommand(argv) {
+    const [command, ...args] = argv;
+    if (command === undefined)
+        throw new ProviderCommandFailed("Provider command is empty.");
+    const completed = spawnSync(command, args, { encoding: "utf8", timeout: 60_000 });
+    if (completed.error) {
+        throw new Error(completed.error.message);
+    }
+    if (completed.status !== 0) {
+        const detail = (completed.stderr || completed.stdout || "").trim();
+        throw new ProviderCommandFailed(detail || `${command} exited ${completed.status}.`);
+    }
+    return completed.stdout ?? "";
+}

package/dist/templates/migent/SKILL.md

@@ -0,0 +1,62 @@
+---
+name: migent
+description: Set up Migent in a project, or configure, run, inspect, and resume its workflows. Use when the user asks about Migent configuration, workflows, sessions, stages, or published outputs.
+---
+
+# Migent
+
+Use Migent as the control plane for the project's multi-stage agent workflows.
+
+## Working rules
+
+- For an existing project, work from the root containing
+  `.migent/config.yaml`. To set up a new project, run `migent init` from
+  its root and follow the CLI's provider and model prompts or flags.
+- Read `.migent/config.yaml` and the relevant file under
+  `.migent/workflows/` before changing or running a workflow.
+- Run `migent doctor` after editing configuration or workflows.
+  `migent config model` and `migent config role` run it after a write.
+- Treat `.migent/sessions/` as generated, resumable state. Do not edit its
+  files directly.
+- Preserve the user's task wording when passing `--task`.
+- Before continuing a stopped session, inspect the command's `stop_reason` and
+  latest execution. Fix the cause before retrying.
+
+## Choose the command
+
+- Start a workflow: `migent start <workflow> --task "<task>"`. `<workflow>`
+  is the workflow id, or a path to a workflow file. An omitted `id` uses the
+  file name. If its
+  `requires` block names a prerequisite workflow and decision, find a matching
+  completed session and add `--prior <session-id>`.
+- Resume an active session: `migent continue <session-id>`.
+- Advance exactly one eligible stage: `migent stage <session-id>`.
+- List recorded sessions: `migent sessions` or `migent sessions --json`.
+- Inspect a snapshot: `migent watch <session-id> --once --json`.
+- Follow new events: `migent watch <session-id>`.
+- Run a configured role outside a workflow only when the user asks for ad hoc
+  role execution: `migent agent start --role <role> --prompt "<prompt>"`.
+- Read `.migent/config.yaml`: `migent config show`.
+- Change a model entry: `migent config model <name> --provider <provider> --model <model-id>`.
+  This updates every role and stage that uses the name.
+- Point one role at a model without changing a shared entry:
+  `migent config role <role> --provider <provider> --model <model-id>`.
+  `migent config role <role> --model-name <name>` points it at a name that
+  already exists. Add `--json` to read the result.
+
+Workflow commands emit progress on stderr and one result object on stdout.
+Report the session ID, session status, stop reason, decisions, and published
+outputs that matter to the user. A stopped active session is resumable; do not
+describe it as completed.
+
+`retry_exhausted` means the stage has used its total failed-attempt allowance;
+`--attempts` on `continue` sets a new total, not extra retries.
+`revisions_exhausted` leaves the session active. `continue` resets revision
+counts for the existing session, allowing another batch up to `max_revisions`.
+`dispatch_limit` applies to the current command; continue the same session if
+further stages are appropriate. Do not start a replacement session to reset
+these limits.
+
+Published output paths are relative to
+`.migent/sessions/<session-id>/`. Prefer the paths reported by Migent over
+guessing artifact locations.

package/dist/workspace.d.ts

@@ -0,0 +1,8 @@
+export declare function setInvocationCwd(cwd?: string): void;
+export declare function invocationCwdPath(): string;
+export declare function findWorkspace(start: string): string;
+export declare function resolvePrompt(args: {
+    prompt?: string | null;
+    promptFile?: string | null;
+    promptStdin: boolean;
+}): string;

package/dist/workspace.js

@@ -0,0 +1,50 @@
+import { readFileSync, statSync } from "node:fs";
+import path from "node:path";
+import { ConfigurationError } from "@nodeint/migent-kernel";
+let invocationCwd = null;
+export function setInvocationCwd(cwd) {
+    invocationCwd = cwd === undefined ? null : path.resolve(cwd);
+}
+export function invocationCwdPath() {
+    return invocationCwd ?? process.cwd();
+}
+export function findWorkspace(start) {
+    let current = path.resolve(start);
+    for (;;) {
+        if (isFile(path.join(current, ".migent", "config.yaml")))
+            return current;
+        const parent = path.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    throw new ConfigurationError("Could not find .migent/config.yaml in this directory or its parents.");
+}
+export function resolvePrompt(args) {
+    if (args.promptStdin) {
+        const text = readFileSync(0, "utf8");
+        if (text === "")
+            throw new Error("Prompt from stdin is empty.");
+        return text;
+    }
+    if (args.promptFile == null) {
+        if (args.prompt == null)
+            throw new Error("Pass one of --prompt, --file, or --stdin.");
+        return args.prompt;
+    }
+    try {
+        return readFileSync(args.promptFile, "utf8");
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new Error(`Unable to read prompt file: ${args.promptFile} (${reason})`);
+    }
+}
+function isFile(filePath) {
+    try {
+        return statSync(filePath).isFile();
+    }
+    catch {
+        return false;
+    }
+}

package/package.json

@@ -1,6 +1,62 @@
 {
   "name": "@nodeint/migent",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "Compose AI coding agents into repeatable engineering workflows.",
+  "keywords": [
+    "ai",
+    "agents",
+    "workflow",
+    "cli",
+    "claude",
+    "codex",
+    "grok",
+    "migent"
+  ],
+  "license": "MIT",
+  "homepage": "https://github.com/nodeint/migent/tree/main/packages/cli#readme",
+  "bugs": {
+    "url": "https://github.com/nodeint/migent/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nodeint/migent.git",
+    "directory": "packages/cli"
+  },
+  "type": "module",
+  "bin": {
+    "migent": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "os": [
+    "darwin",
+    "linux"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.8.1",
+    "@nodeint/migent-adapters": "0.1.0",
+    "@nodeint/migent-kernel": "0.1.0",
+    "@nodeint/migent-registry": "0.1.0",
+    "commander": "^14.0.2",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^26.6.4"
+  },
+  "scripts": {
+    "build": "tsc -b && rm -rf dist/templates && cp -R src/templates dist/templates"
+  }
 }