@kylecheng3146/agent-ops 0.1.2 → 0.1.4

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

@@ -0,0 +1,102 @@
+import { execFileSync } from "node:child_process";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { loadConfigFile } from "../../../runtime/src/config/load.js";
+import { mergeConfigLayers } from "../../../runtime/src/config/merge.js";
+import { sha256 } from "../../../runtime/src/fs/hash.js";
+import { AgentOpsError } from "../../../runtime/src/fs/paths.js";
+import { localStatePaths } from "../../../runtime/src/security/permissions.js";
+import { calculateTrustBinding, FileTrustStore } from "../../../runtime/src/security/trust.js";
+export 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;
+    }
+}
+export 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);
+}
+export function repositoryRemoteUrl(root) {
+    try {
+        return execFileSync("git", ["config", "--get", "remote.origin.url"], {
+            cwd: root,
+            encoding: "utf8"
+        }).trim();
+    }
+    catch {
+        return `local:${root}`;
+    }
+}
+export async function repositoryTrust(root, config, cliVersion) {
+    const home = process.env.AGENT_OPS_HOME ?? homedir();
+    const state = localStatePaths(home);
+    try {
+        const binding = await calculateTrustBinding({
+            repositoryPath: root,
+            remoteUrl: repositoryRemoteUrl(root),
+            configHash: sha256(JSON.stringify(config)),
+            runtimeHash: sha256(cliVersion)
+        });
+        return (await new FileTrustStore(state.trustStore, state.anchorDirectory).status(binding)).status;
+    }
+    catch {
+        return "UNTRUSTED";
+    }
+}

package/dist/packages/cli/src/hook-entry.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+// Entry point registered in Claude settings as:
+//   node <this file> <harness> <event> --managed-by=agent-ops
+import { CLI_VERSION } from "./version.js";
+import { runHookProcess } from "./hook-process.js";
+process.exitCode = await runHookProcess(process.argv.slice(2), {
+    stdin: process.stdin,
+    writeStdout: (value) => process.stdout.write(value),
+    writeStderr: (value) => process.stderr.write(value)
+}, CLI_VERSION);

package/dist/packages/cli/src/hook-process.js

@@ -0,0 +1,54 @@
+import { runHookCommand, HOOK_EVENTS } from "./commands/hook.js";
+import { loadEffectiveConfig, repositoryTrust } from "./context.js";
+const HARNESSES = new Set(["codex", "claude"]);
+const MAX_HOOK_INPUT_BYTES = 1024 * 1024;
+async function readStdin(stream) {
+    const chunks = [];
+    let total = 0;
+    for await (const chunk of stream) {
+        const buffer = Buffer.isBuffer(chunk)
+            ? chunk
+            : Buffer.from(String(chunk), "utf8");
+        total += buffer.byteLength;
+        if (total > MAX_HOOK_INPUT_BYTES) {
+            return "";
+        }
+        chunks.push(buffer);
+    }
+    return Buffer.concat(chunks, total).toString("utf8");
+}
+/**
+ * Runs one hook invocation. Always resolves to exit code 0: a hook that
+ * cannot answer must never block the harness it advises.
+ */
+export async function runHookProcess(argv, io, cliVersion) {
+    const [harness, event] = argv;
+    if (harness === undefined ||
+        !HARNESSES.has(harness) ||
+        event === undefined ||
+        !HOOK_EVENTS.includes(event)) {
+        io.writeStderr("Usage: agent-ops hook <codex|claude> <SessionStart|PreToolUse|Stop>\n");
+        return 0;
+    }
+    try {
+        const root = process.cwd();
+        const config = (await loadEffectiveConfig(root, "project")).config;
+        const output = await runHookCommand({
+            harness: harness,
+            event: event,
+            stdin: await readStdin(io.stdin),
+            config,
+            trusted: (await repositoryTrust(root, config, cliVersion)) === "TRUSTED"
+        });
+        if (output.stdout.length > 0) {
+            io.writeStdout(output.stdout);
+        }
+        if (output.stderr.length > 0) {
+            io.writeStderr(output.stderr);
+        }
+    }
+    catch {
+        // ponytail: fail-open by design; hook failures stay invisible to the harness.
+    }
+    return 0;
+}

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

@@ -0,0 +1,373 @@
+// figlet "agent-ops" -f Standard, trimmed of trailing blank lines/columns.
+export const BANNER = [
+    "                         _",
+    "   __ _  __ _  ___ _ __ | |_       ___  _ __  ___ ",
+    "  / _\` |/ _\` |/ _ \\ '_ \\| __|____ / _ \\| '_ \\/ __|",
+    " | (_| | (_| |  __/ | | | ||_____| (_) | |_) \\__ \\",
+    "  \\__,_|\\__, |\\___|_| |_|\\__|     \\___/| .__/|___/",
+    "        |___/                          |_|"
+].join("\n");
+const TAGLINE = "loop engineering toolkit";
+const MIN_BANNER_COLUMNS = 54;
+const RAIL = "\u2502";
+const DIAMOND = "\u25c6";
+const DOT_ON = "\u25cf";
+const DOT_OFF = "\u25cb";
+function envColorPreference() {
+    if (process.env.NO_COLOR !== undefined) {
+        return "off";
+    }
+    if (process.env.FORCE_COLOR !== undefined) {
+        return "on";
+    }
+    return undefined;
+}
+function useColor(output) {
+    const preference = envColorPreference();
+    return preference === undefined ? output.isTTY : preference === "on";
+}
+function paint(output, code, text) {
+    return useColor(output) ? `\u001b[${code}m${text}\u001b[0m` : text;
+}
+const dim = (output, text) => paint(output, "2", text);
+const bold = (output, text) => paint(output, "1", text);
+const green = (output, text) => paint(output, "32", text);
+const cyan = (output, text) => paint(output, "36", text);
+/**
+ * Decorative only: skipped for --json output, non-interactive runs, and
+ * terminals too narrow to render the wordmark without wrapping.
+ */
+export function writeBanner(output) {
+    if (!output.isTTY || (output.columns ?? 0) < MIN_BANNER_COLUMNS) {
+        return;
+    }
+    output.write(`${cyan(output, BANNER)}\n${dim(output, TAGLINE)}\n\n`);
+}
+function eraseLines(write, count) {
+    for (let index = 0; index < count; index += 1) {
+        write("\u001b[1A\u001b[2K");
+    }
+}
+function renderChoice(outputLike, question, value) {
+    const yes = value
+        ? bold(outputLike, green(outputLike, `${DOT_ON} Yes`))
+        : dim(outputLike, `${DOT_OFF} Yes`);
+    const no = !value
+        ? bold(outputLike, green(outputLike, `${DOT_ON} No`))
+        : dim(outputLike, `${DOT_OFF} No`);
+    return [
+        `${bold(outputLike, DIAMOND)}  ${question}`,
+        `${dim(outputLike, RAIL)}  ${yes} / ${no}`
+    ].join("\n");
+}
+async function typedFallback(question, io, defaultValue) {
+    const { createInterface } = await import("node:readline/promises");
+    const readline = createInterface({ input: io.input, output: io.output });
+    try {
+        const suffix = defaultValue ? "Y/n" : "y/N";
+        const answer = (await readline.question(`${question} [${suffix}]: `)).trim().toLowerCase();
+        if (answer === "") {
+            return defaultValue;
+        }
+        return answer === "y" || answer === "yes";
+    }
+    finally {
+        readline.close();
+    }
+}
+async function typedChoice(question, choices, io, defaultIndex) {
+    const { createInterface } = await import("node:readline/promises");
+    const readline = createInterface({ input: io.input, output: io.output });
+    try {
+        const options = choices
+            .map((choice, index) => `${index + 1}: ${choice.label}`)
+            .join(", ");
+        const answer = (await readline.question(`${question} [${options}]: `)).trim();
+        if (answer === "") {
+            return choices[defaultIndex].value;
+        }
+        const index = Number.parseInt(answer, 10) - 1;
+        if (Number.isInteger(index) && choices[index] !== undefined) {
+            return choices[index].value;
+        }
+        const match = choices.find((choice) => choice.label.toLowerCase() === answer.toLowerCase());
+        return match?.value ?? choices[defaultIndex].value;
+    }
+    finally {
+        readline.close();
+    }
+}
+function renderChoices(outputLike, question, choices, selected, vertical = false, selectAll = false, selectAllLabel = "Select all", selectAllDescription, focusedIndex = 0) {
+    const renderChoice = (choice, active, focused) => {
+        const label = `${active ? DOT_ON : DOT_OFF} ${choice.label}`;
+        const cursor = focused ? "❯ " : "  ";
+        const renderedLabel = active
+            ? bold(outputLike, green(outputLike, label))
+            : dim(outputLike, label);
+        const lines = [
+            vertical
+                ? `${dim(outputLike, RAIL)}  ${cursor}${renderedLabel}`
+                : `${cursor}${renderedLabel}`
+        ];
+        if (vertical && choice.description !== undefined) {
+            lines.push(`${dim(outputLike, RAIL)}    ${dim(outputLike, choice.description)}`);
+        }
+        return lines;
+    };
+    const allActive = selectAll && selected.size === choices.length;
+    const renderedChoices = [
+        ...(selectAll
+            ? renderChoice({
+                label: selectAllLabel,
+                value: undefined,
+                description: selectAllDescription
+            }, allActive, selectAll && focusedIndex === 0)
+            : []),
+        ...choices.flatMap((choice, index) => {
+            const active = selected.has(index);
+            const focused = (selectAll ? index + 1 : index) === focusedIndex;
+            return renderChoice(choice, active, focused);
+        })
+    ];
+    const rendered = vertical
+        ? renderedChoices
+        : [`${dim(outputLike, RAIL)}  ${renderedChoices.join(" / ")}`];
+    return [
+        `${bold(outputLike, DIAMOND)}  ${question}`,
+        ...rendered
+    ].join("\n");
+}
+function assertChoices(choices) {
+    if (choices.length === 0) {
+        throw new Error("At least one selector choice is required.");
+    }
+}
+/** Single-value selector for interactive wizard choices. */
+export async function selectOption(question, choices, io, defaultIndex = 0) {
+    assertChoices(choices);
+    const initialIndex = Math.min(Math.max(defaultIndex, 0), choices.length - 1);
+    if (typeof io.input.setRawMode !== "function" ||
+        io.input.isTTY !== true) {
+        return await typedChoice(question, choices, io, initialIndex);
+    }
+    const outputLike = {
+        isTTY: true,
+        columns: io.output.columns,
+        write: (value) => io.output.write(value)
+    };
+    const { emitKeypressEvents } = await import("node:readline");
+    emitKeypressEvents(io.input);
+    io.input.setRawMode(true);
+    io.input.resume();
+    let index = initialIndex;
+    let rendered = renderChoices(outputLike, question, choices, new Set([index]), false, false, "Select all", undefined, index);
+    io.output.write(`${rendered}\n`);
+    return await new Promise((resolve) => {
+        const cleanup = () => {
+            io.input.setRawMode?.(false);
+            io.input.pause();
+            io.input.removeListener("keypress", onKeypress);
+        };
+        const redraw = () => {
+            eraseLines((value) => io.output.write(value), rendered.split("\n").length);
+            rendered = renderChoices(outputLike, question, choices, new Set([index]), false, false, "Select all", undefined, index);
+            io.output.write(`${rendered}\n`);
+        };
+        const move = (delta) => {
+            index = (index + delta + choices.length) % choices.length;
+            redraw();
+        };
+        const onKeypress = (_chunk, key) => {
+            if (key?.ctrl === true && key.name === "c") {
+                cleanup();
+                process.exit(130);
+            }
+            if (key?.name === "up" ||
+                key?.name === "left" ||
+                key?.name === "h") {
+                move(-1);
+                return;
+            }
+            if (key?.name === "down" ||
+                key?.name === "right" ||
+                key?.name === "tab" ||
+                key?.name === "l") {
+                move(1);
+                return;
+            }
+            if (key?.name === "home") {
+                index = 0;
+                redraw();
+                return;
+            }
+            if (key?.name === "end") {
+                index = choices.length - 1;
+                redraw();
+                return;
+            }
+            if (key?.name === "return" || key?.name === "space") {
+                cleanup();
+                resolve(choices[index].value);
+            }
+        };
+        io.input.on("keypress", onKeypress);
+    });
+}
+/** Multi-value selector. Space toggles a choice; Enter confirms. */
+export async function selectOptions(question, choices, io, defaultValues = [], options = {}) {
+    assertChoices(choices);
+    const defaultIndexes = new Set(choices.flatMap((choice, index) => defaultValues.includes(choice.value) ? [index] : []));
+    if (defaultIndexes.size === 0 && options.selectAll !== true) {
+        defaultIndexes.add(0);
+    }
+    if (typeof io.input.setRawMode !== "function" ||
+        io.input.isTTY !== true) {
+        const value = await typedChoice(question, choices, io, 0);
+        return [value];
+    }
+    const selectAll = options.selectAll === true;
+    const choiceCount = choices.length + (selectAll ? 1 : 0);
+    const outputLike = {
+        isTTY: true,
+        columns: io.output.columns,
+        write: (value) => io.output.write(value)
+    };
+    const { emitKeypressEvents } = await import("node:readline");
+    emitKeypressEvents(io.input);
+    io.input.setRawMode(true);
+    io.input.resume();
+    let index = 0;
+    const selected = new Set(defaultIndexes);
+    let selectionHintShown = false;
+    let rendered = renderChoices(outputLike, question, choices, selected, true, selectAll, options.selectAllLabel, options.selectAllDescription, index);
+    io.output.write(`${rendered}\n`);
+    return await new Promise((resolve) => {
+        const cleanup = () => {
+            io.input.setRawMode?.(false);
+            io.input.pause();
+            io.input.removeListener("keypress", onKeypress);
+        };
+        const redraw = () => {
+            eraseLines((value) => io.output.write(value), rendered.split("\n").length);
+            selectionHintShown = false;
+            rendered = renderChoices(outputLike, question, choices, selected, true, selectAll, options.selectAllLabel, options.selectAllDescription, index);
+            io.output.write(`${rendered}\n`);
+        };
+        const move = (delta) => {
+            index = (index + delta + choiceCount) % choiceCount;
+            redraw();
+        };
+        const onKeypress = (_chunk, key) => {
+            if (key?.ctrl === true && key.name === "c") {
+                cleanup();
+                process.exit(130);
+            }
+            if (key?.name === "up" || key?.name === "left") {
+                move(-1);
+                return;
+            }
+            if (key?.name === "down" ||
+                key?.name === "right" ||
+                key?.name === "tab") {
+                move(1);
+                return;
+            }
+            if (key?.name === "space") {
+                if (selectAll && index === 0) {
+                    if (selected.size === choices.length) {
+                        selected.clear();
+                        selected.add(0);
+                    }
+                    else {
+                        choices.forEach((_choice, choiceIndex) => {
+                            selected.add(choiceIndex);
+                        });
+                    }
+                }
+                else {
+                    const choiceIndex = selectAll ? index - 1 : index;
+                    if (selected.has(choiceIndex)) {
+                        if (selected.size > 1) {
+                            selected.delete(choiceIndex);
+                        }
+                    }
+                    else {
+                        selected.add(choiceIndex);
+                    }
+                }
+                redraw();
+                return;
+            }
+            if (key?.name === "return") {
+                if (selected.size === 0) {
+                    if (!selectionHintShown) {
+                        rendered = `${rendered}\n${dim(outputLike, `${RAIL}  Choose at least one option with Space.`)}`;
+                        selectionHintShown = true;
+                        io.output.write(`${rendered}\n`);
+                    }
+                    return;
+                }
+                cleanup();
+                resolve(choices
+                    .filter((_choice, choiceIndex) => selected.has(choiceIndex))
+                    .map((choice) => choice.value));
+            }
+        };
+        io.input.on("keypress", onKeypress);
+    });
+}
+/**
+ * Arrow-key Yes/No selector. Falls back to a typed y/N prompt when stdin
+ * cannot enter raw mode (piped input, or a stub stream in tests), so the
+ * same call works under both a real terminal and test harnesses.
+ */
+export async function selectYesNo(question, io, defaultValue = false) {
+    if (typeof io.input.setRawMode !== "function" ||
+        io.input.isTTY !== true) {
+        return await typedFallback(question, io, defaultValue);
+    }
+    const outputLike = {
+        isTTY: true,
+        columns: io.output.columns,
+        write: (value) => io.output.write(value)
+    };
+    const { emitKeypressEvents } = await import("node:readline");
+    emitKeypressEvents(io.input);
+    io.input.setRawMode(true);
+    io.input.resume();
+    let value = defaultValue;
+    let rendered = renderChoice(outputLike, question, value);
+    io.output.write(`${rendered}\n`);
+    return await new Promise((resolve) => {
+        const cleanup = () => {
+            io.input.setRawMode?.(false);
+            io.input.pause();
+            io.input.removeListener("keypress", onKeypress);
+        };
+        const redraw = () => {
+            eraseLines((value_) => io.output.write(value_), rendered.split("\n").length);
+            rendered = renderChoice(outputLike, question, value);
+            io.output.write(`${rendered}\n`);
+        };
+        const onKeypress = (_chunk, key) => {
+            if (key?.ctrl === true && key.name === "c") {
+                cleanup();
+                process.exit(130);
+            }
+            if (key?.name === "left" ||
+                key?.name === "right" ||
+                key?.name === "tab" ||
+                key?.name === "h" ||
+                key?.name === "l") {
+                value = !value;
+                redraw();
+                return;
+            }
+            if (key?.name === "return" || key?.name === "space") {
+                cleanup();
+                resolve(value);
+            }
+        };
+        io.input.on("keypress", onKeypress);
+    });
+}

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

@@ -0,0 +1,3 @@
+// Single source of the published CLI version. Release preparation updates
+// this constant; bin.ts and the hook entry both read it from here.
+export const CLI_VERSION = "0.1.4";

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

@@ -1,7 +1,35 @@
 import { CliArgumentError } from "./args.js";
+import { selectOption, selectOptions } from "./ui.js";
 const SCOPES = new Set(["project", "user"]);
 const HARNESSES = new Set(["both", "claude", "codex"]);
 const PROFILES = new Set(["advisory", "core", "guardrails"]);
+const SCOPE_CHOICES = [
+    { label: "project", value: "project" },
+    { label: "user", value: "user" }
+];
+const HARNESS_CHOICES = [
+    { label: "both", value: "both" },
+    { label: "claude", value: "claude" },
+    { label: "codex", value: "codex" }
+];
+const PROFILE_CHOICES = [
+    {
+        label: "core",
+        value: "core",
+        description: "Base rules, task tracking, verification, and review guidance."
+    },
+    {
+        label: "advisory",
+        value: "advisory",
+        description: "Adds informational SessionStart summaries and local logs; never blocks."
+    },
+    {
+        label: "guardrails",
+        value: "guardrails",
+        description: "Blocks high-confidence unsafe commands and enables optional Stop verification."
+    }
+];
+const WIZARD_SUBTITLE = "Safe setup for Codex + Claude Code with profile-driven rules, verification, and hooks.";
 async function createPromptSession(io) {
     if (!io.isTTY) {
         throw new CliArgumentError("CLI_INTERACTIVE_REQUIRED", "Missing init choices require an interactive terminal.");
@@ -53,6 +81,28 @@ export async function completeInitChoices(args, io) {
     if (!io.isTTY) {
         throw new CliArgumentError("CLI_INTERACTIVE_REQUIRED", "Non-interactive init requires --scope, --harness, and at least one --profile.");
     }
+    if (io.input !== undefined && io.output !== undefined) {
+        const selectorIo = {
+            input: io.input,
+            output: io.output
+        };
+        selectorIo.output.write(`${WIZARD_SUBTITLE}\n\n`);
+        const scope = args.scope ?? await selectOption("Scope", SCOPE_CHOICES, selectorIo);
+        const harness = args.harness ?? await selectOption("Harness", HARNESS_CHOICES, selectorIo);
+        const profiles = args.profiles.length > 0
+            ? args.profiles
+            : await selectOptions("Profiles (multi-select: ↑↓ move, Space toggle, Enter confirm)", PROFILE_CHOICES, selectorIo, [], {
+                selectAll: true,
+                selectAllLabel: "Select all",
+                selectAllDescription: "Enable core, advisory, and guardrails together."
+            });
+        return {
+            ...args,
+            scope,
+            harness,
+            profiles
+        };
+    }
     const session = await createPromptSession(io);
     try {
         const scope = args.scope ??

package/dist/runtime/src/adapters/claude/config.js

@@ -83,6 +83,25 @@ function hookRecord(settings) {
     }
     return settings.hooks;
 }
+/**
+ * Removes every agent-ops owned handler and leaves foreign hooks untouched.
+ */
+export function stripClaudeManagedHooks(existing) {
+    if (!isRecord(existing)) {
+        throw new AgentOpsError("CLAUDE_SETTINGS_INVALID", "Claude settings must be a JSON object.");
+    }
+    const existingHooks = hookRecord(existing);
+    const hooks = {};
+    for (const [eventName, groups] of Object.entries(existingHooks)) {
+        const preserved = groups
+            .map(withoutOwnedHandlers)
+            .filter((group) => group !== null);
+        if (preserved.length > 0) {
+            hooks[eventName] = preserved;
+        }
+    }
+    return { ...existing, hooks };
+}
 export function mergeClaudeSettings(existing, managed) {
     if (!isRecord(existing)) {
         throw new AgentOpsError("CLAUDE_SETTINGS_INVALID", "Claude settings must be a JSON object.");

package/dist/runtime/src/adapters/codex/config.js

@@ -67,6 +67,22 @@ function hookRecord(value) {
     }
     return value.hooks;
 }
+/**
+ * Removes every agent-ops owned handler and leaves foreign hooks untouched.
+ */
+export function stripCodexManagedHooks(existing) {
+    const existingHooks = hookRecord(existing);
+    const hooks = {};
+    for (const [eventName, groups] of Object.entries(existingHooks)) {
+        const preserved = groups
+            .map(withoutOwnedHandlers)
+            .filter((group) => group !== null);
+        if (preserved.length > 0) {
+            hooks[eventName] = preserved;
+        }
+    }
+    return { ...existing, hooks };
+}
 export function mergeCodexHookConfig(existing, managed) {
     if (!isRecord(existing)) {
         throw new AgentOpsError("CODEX_HOOK_CONFIG_INVALID", "Codex hook configuration must be a JSON object.");

package/dist/runtime/src/install/harness.js

@@ -57,7 +57,7 @@ export function commonHarnessAdapters() {
         };
     });
 }
-function requestedHarnessIds(harness) {
+export function requestedHarnessIds(harness) {
     return harness === "both" ? ["codex", "claude"] : [harness];
 }
 function selectAdapter(id, adapters) {