@kylecheng3146/agent-ops 0.1.3 → 0.1.4

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

@@ -1,17 +1,12 @@
 import { CliArgumentError, parseArgs } from "./args.js";
 import { errorEnvelope, okEnvelope, writeEnvelope } from "./output.js";
 import { completeInitChoices } from "./wizard.js";
-const WELCOME_BANNER = [
-    "+--------------------------------------------------+",
-    "|          LOOP ENGINEERING TOOLKIT               |",
-    "|       Safe setup for Codex + Claude Code         |",
-    "+--------------------------------------------------+"
-].join("\n");
+import { BANNER } from "./ui.js";
 export function renderWelcome(color) {
     const cyan = color ? "\u001b[36m" : "";
     const bold = color ? "\u001b[1m" : "";
     const reset = color ? "\u001b[0m" : "";
-    return `${cyan}${bold}${WELCOME_BANNER}${reset}\n\n`;
+    return `${cyan}${bold}${BANNER}${reset}\n\n`;
 }
 export const HELP_TEXT = `Usage: agent-ops <command> [options]
 

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

@@ -4,16 +4,34 @@ import { applyInstallPlan } from "../../../../runtime/src/install/apply.js";
 import { okEnvelope } from "../output.js";
 import { formatOperationPlan } from "../plan-output.js";
 export function formatInstallPlan(plan) {
+    const hooks = plan.manifest.hooks ?? [];
     return formatOperationPlan({
         title: "Installation plan",
         metadata: [
             `Scope: ${plan.scope}`,
             `Harness: ${plan.harness}`,
-            `Profiles: ${plan.profiles.join(", ")}`
+            `Profiles: ${plan.profiles.join(", ")}`,
+            ...(hooks.length === 0
+                ? ["Hooks: none selected"]
+                : [
+                    "Hooks:",
+                    ...hooks.map((hook) => `  - ${hook.harness}: ${hook.path} (${hook.events.join(", ")})`)
+                ])
         ],
         operations: plan.operations
     });
 }
+function appliedMessage(plan) {
+    const hooks = plan.manifest.hooks ?? [];
+    if (hooks.length === 0) {
+        return "Loop Engineering Toolkit installation applied.\nHooks: none selected.";
+    }
+    return [
+        "Loop Engineering Toolkit installation applied.",
+        "Hooks configured:",
+        ...hooks.map((hook) => `- ${hook.harness}: ${hook.path} (${hook.events.join(", ")})`)
+    ].join("\n");
+}
 function initError(code, message, plan) {
     return {
         code,
@@ -63,6 +81,6 @@ export async function runInitCommand(options) {
     return okEnvelope("INIT_APPLIED", {
         applied: true,
         plan,
-        message: "Loop Engineering Toolkit installation applied."
+        message: appliedMessage(plan)
     });
 }

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

@@ -1,5 +1,5 @@
 // figlet "agent-ops" -f Standard, trimmed of trailing blank lines/columns.
-const BANNER = [
+export const BANNER = [
     "                         _",
     "   __ _  __ _  ___ _ __ | |_       ___  _ __  ___ ",
     "  / _\` |/ _\` |/ _ \\ '_ \\| __|____ / _ \\| '_ \\/ __|",
@@ -75,6 +75,247 @@ async function typedFallback(question, io, defaultValue) {
         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

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

@@ -1,3 +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.3";
+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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kylecheng3146/agent-ops",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Evidence-driven development loops for Codex and Claude Code",
   "type": "module",
   "license": "MIT",
@@ -19,7 +19,8 @@
     "docs/zh-TW/spec/",
     "README.md",
     "LICENSE",
-    "SECURITY.md"
+    "SECURITY.md",
+    "postinstall.cjs"
   ],
   "publishConfig": {
     "access": "public"
@@ -30,7 +31,8 @@
     "test:compile": "node scripts/clean.mjs .tmp && tsc -p tsconfig.test.json",
     "test": "npm run test:compile && node scripts/run-tests.mjs .tmp/test-dist/tests",
     "build": "node scripts/clean.mjs dist && tsc -p tsconfig.build.json",
-    "package:check": "node scripts/package-check.mjs"
+    "package:check": "node scripts/package-check.mjs",
+    "postinstall": "node postinstall.cjs"
   },
   "devDependencies": {
     "@types/node": "26.1.1",

package/postinstall.cjs

@@ -0,0 +1,102 @@
+"use strict";
+
+const { closeSync, existsSync, openSync, readFileSync } = require("node:fs");
+const { join, resolve } = require("node:path");
+const { spawnSync } = require("node:child_process");
+const { isatty } = require("node:tty");
+
+const PACKAGE_NAME = "@kylecheng3146/agent-ops";
+const packageRoot = __dirname;
+const installRoot = resolve(process.env.INIT_CWD ?? process.cwd());
+
+function isDirectDependency() {
+  try {
+    const packageJson = JSON.parse(
+      readFileSync(join(installRoot, "package.json"), "utf8")
+    );
+    return [
+      packageJson.dependencies,
+      packageJson.devDependencies,
+      packageJson.optionalDependencies,
+      packageJson.peerDependencies
+    ].some(
+      (dependencies) =>
+        dependencies !== null &&
+        typeof dependencies === "object" &&
+        dependencies[PACKAGE_NAME] !== undefined
+    );
+  } catch {
+    return false;
+  }
+}
+
+function openTerminal() {
+  if (process.stdin.isTTY === true && process.stdout.isTTY === true) {
+    return { stdio: "inherit", close() {} };
+  }
+
+  const inputPath = process.platform === "win32" ? "CONIN$" : "/dev/tty";
+  const outputPath = process.platform === "win32" ? "CONOUT$" : "/dev/tty";
+  let inputFd;
+  let outputFd;
+  try {
+    inputFd = openSync(inputPath, "r");
+    outputFd = process.platform === "win32" ? openSync(outputPath, "a") : inputFd;
+    if (!isatty(inputFd) || !isatty(outputFd)) {
+      throw new Error("Interactive terminal is unavailable.");
+    }
+    return {
+      stdio: [inputFd, outputFd, outputFd],
+      close() {
+        if (outputFd !== inputFd) {
+          closeSync(outputFd);
+        }
+        closeSync(inputFd);
+      }
+    };
+  } catch {
+    if (outputFd !== undefined && outputFd !== inputFd) {
+      closeSync(outputFd);
+    }
+    if (inputFd !== undefined) {
+      closeSync(inputFd);
+    }
+    return null;
+  }
+}
+
+if (
+  installRoot === resolve(packageRoot) ||
+  process.env.CI !== undefined ||
+  !isDirectDependency()
+) {
+  process.exit(0);
+}
+
+const terminal = openTerminal();
+if (terminal === null) {
+  process.exit(0);
+}
+
+const cliPath = join(packageRoot, "dist", "packages", "cli", "src", "bin.js");
+if (!existsSync(cliPath)) {
+  process.stderr.write(
+    "agent-ops init was skipped because the installed CLI is unavailable.\n"
+  );
+  terminal.close();
+  process.exit(0);
+}
+
+const result = spawnSync(process.execPath, [cliPath], {
+  cwd: installRoot,
+  env: process.env,
+  stdio: terminal.stdio
+});
+terminal.close();
+
+if (result.error !== undefined || result.status !== 0) {
+  process.stderr.write(
+    "agent-ops init was not applied; package installation completed. " +
+      "Run `agent-ops` to retry.\n"
+  );
+}