@kylecheng3146/agent-ops 0.0.1

package/dist/packages/cli/src/bin.js

@@ -0,0 +1,290 @@
+#!/usr/bin/env node
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { execFileSync } from "node:child_process";
+import { commonHarnessAdapters } from "../../../runtime/src/install/harness.js";
+import { NpmRegistryClient } from "../../../runtime/src/registry/npm.js";
+import { TaskService } from "../../../runtime/src/task/service.js";
+import { FileTaskStore } from "../../../runtime/src/task/store.js";
+import { mergeConfigLayers } from "../../../runtime/src/config/merge.js";
+import { loadConfigFile } from "../../../runtime/src/config/load.js";
+import { AgentOpsError } from "../../../runtime/src/fs/paths.js";
+import { FileTrustStore, calculateTrustBinding } from "../../../runtime/src/security/trust.js";
+import { localStatePaths } from "../../../runtime/src/security/permissions.js";
+import { sha256 } from "../../../runtime/src/fs/hash.js";
+import { FileEvidenceStore } from "../../../runtime/src/verify/evidence.js";
+import { VerificationService } from "../../../runtime/src/verify/service.js";
+import { NodeVerificationProcessRunner } from "../../../runtime/src/verify/spawn.js";
+import { runCli } from "./cli.js";
+import { createCommandRegistry } from "./commands/index.js";
+import { explainConfigCommand } from "./commands/config.js";
+import { runDoctorCommand } from "./commands/doctor.js";
+import { formatInstallPlan, runInitCommand } from "./commands/init.js";
+import { formatUninstallPlan, runUninstallCommand } from "./commands/uninstall.js";
+import { runTaskCommand } from "./commands/task.js";
+import { runReviewCommand } from "./commands/review.js";
+import { runTrustCommand } from "./commands/trust.js";
+import { runVerifyCommand } from "./commands/verify.js";
+import { formatUpdatePlan, runUpdateCommand } from "./commands/update.js";
+import { errorEnvelope } from "./output.js";
+const CLI_VERSION = "0.1.0";
+const DEFAULT_CONFIG = {
+    schemaVersion: 1,
+    profiles: [],
+    verification: { commands: [] },
+    pathMappings: [],
+    securityExceptions: []
+};
+function defaultConfigLayer() {
+    return {
+        source: "default",
+        sourcePath: "built-in defaults",
+        config: DEFAULT_CONFIG
+    };
+}
+async function loadOptionalConfig(path) {
+    try {
+        return await loadConfigFile(path);
+    }
+    catch (error) {
+        if (error instanceof AgentOpsError &&
+            error.code === "CONFIG_READ_FAILED" &&
+            typeof error.cause === "object" &&
+            error.cause !== null &&
+            "code" in error.cause &&
+            error.cause.code === "ENOENT") {
+            return null;
+        }
+        throw error;
+    }
+}
+async function loadEffectiveConfig(root, scope) {
+    const home = process.env.AGENT_OPS_HOME ?? homedir();
+    const userPath = join(home, ".agent-ops", "config.json");
+    const projectPath = join(root, ".agent-ops", "config.json");
+    const layers = [defaultConfigLayer()];
+    if (scope === "user") {
+        const user = await loadOptionalConfig(userPath);
+        if (user !== null) {
+            layers.push({
+                source: "user",
+                sourcePath: user.sourcePath,
+                config: user.config
+            });
+        }
+        return mergeConfigLayers(layers);
+    }
+    if (projectPath !== userPath) {
+        const user = await loadOptionalConfig(userPath);
+        if (user !== null) {
+            layers.push({
+                source: "user",
+                sourcePath: user.sourcePath,
+                config: user.config
+            });
+        }
+    }
+    const project = await loadOptionalConfig(projectPath);
+    if (project !== null) {
+        layers.push({
+            source: "project",
+            sourcePath: project.sourcePath,
+            config: project.config
+        });
+    }
+    return mergeConfigLayers(layers);
+}
+async function repositoryTrust(root, config) {
+    const home = process.env.AGENT_OPS_HOME ?? homedir();
+    const state = localStatePaths(home);
+    const remote = (() => {
+        try {
+            return execFileSync("git", ["config", "--get", "remote.origin.url"], {
+                cwd: root,
+                encoding: "utf8"
+            }).trim();
+        }
+        catch {
+            return `local:${root}`;
+        }
+    })();
+    try {
+        const binding = await calculateTrustBinding({
+            repositoryPath: root,
+            remoteUrl: remote,
+            configHash: sha256(JSON.stringify(config)),
+            runtimeHash: sha256(CLI_VERSION)
+        });
+        return (await new FileTrustStore(state.trustStore, state.anchorDirectory).status(binding)).status;
+    }
+    catch {
+        return "UNTRUSTED";
+    }
+}
+async function confirmInit(plan) {
+    return await confirmPlan(formatInstallPlan(plan));
+}
+async function confirmPlan(text) {
+    process.stdout.write(text);
+    const prompt = createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    try {
+        const answer = await prompt.question("Apply this installation plan? [y/N]: ");
+        return ["y", "yes"].includes(answer.trim().toLowerCase());
+    }
+    finally {
+        prompt.close();
+    }
+}
+process.exitCode = await runCli(process.argv.slice(2), {
+    isTTY: process.stdin.isTTY === true && process.stdout.isTTY === true,
+    input: process.stdin,
+    output: process.stdout,
+    writeStdout: (value) => process.stdout.write(value),
+    writeStderr: (value) => process.stderr.write(value)
+}, {
+    version: CLI_VERSION,
+    registry: createCommandRegistry(Object.fromEntries([
+        "init",
+        "config",
+        "trust",
+        "doctor",
+        "update",
+        "uninstall",
+        "task",
+        "verify",
+        "review"
+    ].map((command) => [command, async (args) => {
+            const root = args.scope === "user"
+                ? process.env.AGENT_OPS_HOME ?? homedir()
+                : process.cwd();
+            const isTTY = !args.json &&
+                process.stdin.isTTY === true &&
+                process.stdout.isTTY === true;
+            if (args.command === "init") {
+                return await runInitCommand({
+                    args,
+                    root,
+                    adapters: commonHarnessAdapters(),
+                    isTTY,
+                    toolkitVersion: CLI_VERSION,
+                    confirm: async (plan) => await confirmInit(plan)
+                });
+            }
+            if (args.command === "doctor") {
+                return await runDoctorCommand({ root });
+            }
+            if (args.command === "uninstall") {
+                return await runUninstallCommand({
+                    args,
+                    root,
+                    isTTY,
+                    confirm: async (plan) => await confirmPlan(formatUninstallPlan(plan))
+                });
+            }
+            if (args.command === "update") {
+                return await runUpdateCommand({
+                    args,
+                    root,
+                    adapters: commonHarnessAdapters(),
+                    registry: new NpmRegistryClient(),
+                    isTTY,
+                    confirm: async (plan) => await confirmPlan(formatUpdatePlan(plan)),
+                    ...(args.targetVersion === undefined
+                        ? {}
+                        : { targetVersion: args.targetVersion })
+                });
+            }
+            const taskService = new TaskService(new FileTaskStore(join(root, ".agent-ops", "tasks", "state.json"), root));
+            if (args.command === "task") {
+                const sessionId = process.env.AGENT_OPS_SESSION_ID;
+                return await runTaskCommand({
+                    args,
+                    service: taskService,
+                    ...(sessionId === undefined ? {} : { sessionId })
+                });
+            }
+            if (args.command === "review") {
+                return await runReviewCommand({
+                    args,
+                    authorized: args.yes
+                });
+            }
+            if (args.command === "config") {
+                return explainConfigCommand(await loadEffectiveConfig(root, args.scope === "user" ? "user" : "project"));
+            }
+            if (args.command === "verify") {
+                const merged = await loadEffectiveConfig(root, args.scope === "user" ? "user" : "project");
+                const config = merged.config;
+                const trustStatus = await repositoryTrust(root, config);
+                return await runVerifyCommand({
+                    args,
+                    taskService,
+                    service: new VerificationService({
+                        root,
+                        scope: args.scope === "user" ? "user" : "project",
+                        config,
+                        gitRunner: {
+                            run: async (gitArgs) => {
+                                try {
+                                    return {
+                                        exitCode: 0,
+                                        stdout: execFileSync("git", [...gitArgs], {
+                                            cwd: root,
+                                            encoding: "buffer",
+                                            stdio: ["ignore", "pipe", "ignore"]
+                                        })
+                                    };
+                                }
+                                catch (error) {
+                                    const failure = error;
+                                    return {
+                                        exitCode: failure.status ?? 1,
+                                        stdout: failure.stdout ?? new Uint8Array()
+                                    };
+                                }
+                            }
+                        },
+                        processRunner: new NodeVerificationProcessRunner(),
+                        taskService,
+                        evidenceStore: new FileEvidenceStore(root, root),
+                        trusted: trustStatus === "TRUSTED"
+                    })
+                });
+            }
+            if (args.command === "trust") {
+                const config = (await loadEffectiveConfig(root, args.scope === "user" ? "user" : "project")).config;
+                const state = localStatePaths(process.env.AGENT_OPS_HOME ?? homedir());
+                const remote = (() => {
+                    try {
+                        return execFileSync("git", ["config", "--get", "remote.origin.url"], {
+                            cwd: root,
+                            encoding: "utf8"
+                        }).trim();
+                    }
+                    catch {
+                        return `local:${root}`;
+                    }
+                })();
+                const binding = await calculateTrustBinding({
+                    repositoryPath: root,
+                    remoteUrl: remote,
+                    configHash: sha256(JSON.stringify(config)),
+                    runtimeHash: sha256(CLI_VERSION)
+                });
+                return await runTrustCommand({
+                    action: args.action,
+                    yes: args.yes,
+                    isTTY,
+                    calculateBinding: async () => binding,
+                    presentBinding: async () => undefined,
+                    confirmGrant: async () => await confirmPlan(JSON.stringify(binding, null, 2)),
+                    store: new FileTrustStore(state.trustStore, state.anchorDirectory)
+                });
+            }
+            return errorEnvelope("CLI_COMMAND_UNAVAILABLE", `Command is not implemented yet: ${args.command}`);
+        }])))
+});

package/dist/packages/cli/src/cli.js

@@ -0,0 +1,80 @@
+import { CliArgumentError, parseArgs } from "./args.js";
+import { errorEnvelope, okEnvelope, writeEnvelope } from "./output.js";
+import { completeInitChoices } from "./wizard.js";
+export const HELP_TEXT = `Usage: agent-ops <command> [options]
+
+Commands:
+  init       Plan or install agent-ops
+  config explain
+             Inspect effective configuration provenance
+  trust <status|grant|revoke>
+             Manage explicit repository trust
+  doctor     Diagnose an installation
+  update     Update managed artifacts
+  uninstall  Remove managed artifacts
+  task <create|status|attach|complete|archive|export>
+             Manage independent task acceptance state
+  verify     Run configured verification
+  review     Run an independent review
+
+Options:
+  --scope <project|user>
+  --harness <both|claude|codex>
+  --profile <core|advisory|guardrails>  Repeatable
+  --task <id>
+  --target-version <version>          Update target version (offline-capable)
+  --title <text>
+  --criterion <json>                    Repeatable
+  --evidence <criterion-id=reference>   Repeatable
+  --session <id>
+  --dry-run
+  --json
+  --yes
+  --help
+  --version
+`;
+function wantsJson(argv) {
+    return argv.includes("--json");
+}
+function writeAndReturn(io, envelope, json, exitCode) {
+    writeEnvelope(io, envelope, json);
+    return exitCode;
+}
+export async function runCli(argv, io, services) {
+    const json = wantsJson(argv);
+    let args;
+    try {
+        args = parseArgs(argv);
+    }
+    catch (error) {
+        if (error instanceof CliArgumentError) {
+            return writeAndReturn(io, errorEnvelope(error.code, error.message), json, 2);
+        }
+        return writeAndReturn(io, errorEnvelope("CLI_INTERNAL_ERROR", "Unable to parse command arguments."), json, 1);
+    }
+    if (args.command === "help") {
+        return writeAndReturn(io, okEnvelope("CLI_HELP", { text: HELP_TEXT }), args.json, 0);
+    }
+    if (args.command === "version") {
+        return writeAndReturn(io, okEnvelope("CLI_VERSION", { version: services.version }), args.json, 0);
+    }
+    try {
+        if (args.command === "init") {
+            args = await completeInitChoices(args, args.json ? { ...io, isTTY: false } : io);
+        }
+        const execute = args.command === "help" || args.command === "version"
+            ? services.execute
+            : services.registry?.get(args.command) ?? services.execute;
+        if (execute === undefined) {
+            return writeAndReturn(io, errorEnvelope("CLI_COMMAND_UNAVAILABLE", `Command is not implemented yet: ${args.command}`), args.json, 1);
+        }
+        const result = await execute(args);
+        return writeAndReturn(io, result, args.json, result.status === "ok" ? 0 : 1);
+    }
+    catch (error) {
+        if (error instanceof CliArgumentError) {
+            return writeAndReturn(io, errorEnvelope(error.code, error.message), args.json, 2);
+        }
+        return writeAndReturn(io, errorEnvelope("CLI_INTERNAL_ERROR", "Command execution failed."), args.json, 1);
+    }
+}

package/dist/packages/cli/src/commands/config.js

@@ -0,0 +1,8 @@
+import { explainConfig } from "../../../../runtime/src/config/explain.js";
+import { okEnvelope } from "../output.js";
+export function explainConfigCommand(merged) {
+    return okEnvelope("CONFIG_EXPLAIN", {
+        ...explainConfig(merged),
+        message: "Effective configuration provenance calculated."
+    });
+}

package/dist/packages/cli/src/commands/doctor.js

@@ -0,0 +1,32 @@
+import { doctorInstallation } from "../../../../runtime/src/install/doctor.js";
+function formatDoctorReport(report) {
+    return `${[
+        "Installation doctor",
+        ...report.checks.map(({ id, status, message }) => `- ${status} ${id}: ${message}`)
+    ].join("\n")}\n`;
+}
+export async function runDoctorCommand(options) {
+    const report = await doctorInstallation(options);
+    const hasFailure = report.checks.some(({ status }) => status === "FAIL");
+    const hasUnknown = report.checks.some(({ status }) => status === "UNKNOWN");
+    const code = hasFailure
+        ? "DOCTOR_FAILED"
+        : hasUnknown
+            ? "DOCTOR_UNKNOWN"
+            : "DOCTOR_OK";
+    const message = hasFailure
+        ? "Installation diagnostics found failures."
+        : hasUnknown
+            ? "Installation diagnostics contain unknown checks."
+            : "Installation diagnostics passed.";
+    return {
+        code,
+        status: hasFailure || hasUnknown ? "error" : "ok",
+        data: {
+            report,
+            message,
+            text: formatDoctorReport(report)
+        },
+        errors: hasFailure || hasUnknown ? [{ code, message }] : []
+    };
+}

package/dist/packages/cli/src/commands/index.js

@@ -0,0 +1,16 @@
+export function createCommandRegistry(handlers) {
+    const entries = new Map();
+    for (const [command, handler] of Object.entries(handlers)) {
+        if (handler !== undefined) {
+            entries.set(command, handler);
+        }
+    }
+    return {
+        get(command) {
+            return entries.get(command);
+        },
+        commands() {
+            return [...entries.keys()];
+        }
+    };
+}

package/dist/packages/cli/src/commands/init.js

@@ -0,0 +1,65 @@
+import { AgentOpsError } from "../../../../runtime/src/fs/paths.js";
+import { createInstallPlan } from "../../../../runtime/src/install/plan.js";
+import { applyInstallPlan } from "../../../../runtime/src/install/apply.js";
+import { okEnvelope } from "../output.js";
+import { formatOperationPlan } from "../plan-output.js";
+export function formatInstallPlan(plan) {
+    return formatOperationPlan({
+        title: "Installation plan",
+        metadata: [
+            `Scope: ${plan.scope}`,
+            `Harness: ${plan.harness}`,
+            `Profiles: ${plan.profiles.join(", ")}`
+        ],
+        operations: plan.operations
+    });
+}
+function initError(code, message, plan) {
+    return {
+        code,
+        status: "error",
+        data: { applied: false, plan, message },
+        errors: [{ code, message }]
+    };
+}
+export async function runInitCommand(options) {
+    const { args } = options;
+    if (args.command !== "init" ||
+        args.scope === undefined ||
+        args.harness === undefined ||
+        args.profiles.length === 0) {
+        throw new AgentOpsError("INIT_CHOICES_REQUIRED", "Init requires complete scope, harness, and profile choices.");
+    }
+    const plan = await createInstallPlan({
+        root: options.root,
+        scope: args.scope,
+        harness: args.harness,
+        profiles: args.profiles,
+        adapters: options.adapters,
+        ...(options.toolkitVersion === undefined
+            ? {}
+            : { toolkitVersion: options.toolkitVersion })
+    });
+    if (args.dryRun) {
+        return okEnvelope("INIT_PLAN_READY", {
+            applied: false,
+            plan,
+            message: "Installation plan calculated; no files were written.",
+            text: formatInstallPlan(plan)
+        });
+    }
+    if (!args.yes && !options.isTTY) {
+        return initError("INIT_CONFIRMATION_REQUIRED", "Non-interactive init requires --yes after all choices are explicit.", plan);
+    }
+    if (!args.yes &&
+        options.isTTY &&
+        !(await options.confirm(plan))) {
+        return initError("INIT_CANCELLED", "Installation was cancelled; no files were written.", plan);
+    }
+    await applyInstallPlan(options.root, plan);
+    return okEnvelope("INIT_APPLIED", {
+        applied: true,
+        plan,
+        message: "Loop Engineering Toolkit installation applied."
+    });
+}

package/dist/packages/cli/src/commands/review.js

@@ -0,0 +1,71 @@
+import { buildReviewPacket } from "../../../../runtime/src/review/packet.js";
+import { runIndependentReview } from "../../../../runtime/src/review/runner.js";
+import { resolveReviewRole } from "../../../../runtime/src/review/roles.js";
+import { okEnvelope } from "../output.js";
+function harness(value) {
+    return value === "claude" ? "claude" : "codex";
+}
+export async function runReviewCommand(options) {
+    const ids = options.args.criteria ?? [];
+    const criteria = ids.map((id) => ({
+        id,
+        description: id
+    }));
+    const evidenceRequirements = (options.args.evidence ?? []).map((value) => {
+        const separator = value.indexOf("=");
+        return {
+            criterionId: separator < 0 ? value : value.slice(0, separator),
+            requirement: separator < 0 ? value : value.slice(separator + 1)
+        };
+    });
+    const selectedHarness = harness(options.args.harness);
+    const role = resolveReviewRole(options.role ?? "independent-review", options.roles ?? []);
+    const result = await runIndependentReview({
+        invocation: {
+            harness: role?.harness ?? selectedHarness,
+            model: role?.model ?? options.model ?? "configured",
+            effort: role?.effort ?? options.effort ?? "configured",
+            packet: buildReviewPacket({
+                request: "Review the requested implementation.",
+                criteria,
+                artifactRefs: [],
+                evidenceRequirements
+            })
+        },
+        authorized: options.authorized,
+        execute: options.execute ?? (async () => ({
+            status: "NOT_RUN",
+            reason: "missing-cli"
+        }))
+    });
+    const message = result.status === "PASS"
+        ? "Independent review passed."
+        : result.status === "FAIL"
+            ? "Independent review failed."
+            : "Independent review was not run.";
+    const data = {
+        message,
+        result,
+        text: [
+            message,
+            `Status: ${result.status}`,
+            `Harness: ${result.harness}; model: ${result.model}; effort: ${result.effort}.`,
+            ...(result.reason === undefined ? [] : [`Reason: ${result.reason}.`]),
+            ...(result.results === undefined
+                ? []
+                : result.results.map((item) => `${item.criterionId}: ${item.status} [${item.evidence.join(", ")}]`)),
+            result.prompt,
+            ""
+        ].join("\n")
+    };
+    if (result.status === "PASS") {
+        return okEnvelope("REVIEW_RESULT", data);
+    }
+    const code = result.status === "FAIL" ? "REVIEW_FAILED" : "REVIEW_NOT_RUN";
+    return {
+        code,
+        status: "error",
+        data,
+        errors: [{ code, message }]
+    };
+}