@kimbho/kimbho-cli 0.1.0 → 0.1.1

package/README.md

@@ -28,12 +28,26 @@ npm install -g ./kimbho-kimbho-cli-0.1.0.tgz
 ## Usage
 
 ```bash
+kimbho
+kimbho shell
 kimbho --help
 kimbho init
 kimbho plan "build a coding agent"
 kimbho /models openrouter --search claude --limit 10
 ```
 
+Bare `kimbho` opens the interactive shell. Within that shell, plain-English input is treated as `run <goal>`, and slash commands like `/plan`, `/run`, `/models`, and `/brains` are supported.
+
+Useful shell commands:
+
+```bash
+/status
+/model
+/plan build a coding agent
+/run scaffold a SaaS starter
+/quit
+```
+
 ## Notes
 
 - The published CLI bundles the internal Kimbho packages so installation does not depend on the monorepo layout.

package/dist/index.cjs

@@ -1149,7 +1149,7 @@ var require_command = __commonJS({
     var childProcess = require("node:child_process");
     var path4 = require("node:path");
     var fs = require("node:fs");
-    var process10 = require("node:process");
+    var process11 = require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
     var { Help: Help2, stripColor } = require_help();
@@ -1196,13 +1196,13 @@ var require_command = __commonJS({
         this._showSuggestionAfterError = true;
         this._savedState = null;
         this._outputConfiguration = {
-          writeOut: (str) => process10.stdout.write(str),
-          writeErr: (str) => process10.stderr.write(str),
+          writeOut: (str) => process11.stdout.write(str),
+          writeErr: (str) => process11.stderr.write(str),
           outputError: (str, write) => write(str),
-          getOutHelpWidth: () => process10.stdout.isTTY ? process10.stdout.columns : void 0,
-          getErrHelpWidth: () => process10.stderr.isTTY ? process10.stderr.columns : void 0,
-          getOutHasColors: () => useColor() ?? (process10.stdout.isTTY && process10.stdout.hasColors?.()),
-          getErrHasColors: () => useColor() ?? (process10.stderr.isTTY && process10.stderr.hasColors?.()),
+          getOutHelpWidth: () => process11.stdout.isTTY ? process11.stdout.columns : void 0,
+          getErrHelpWidth: () => process11.stderr.isTTY ? process11.stderr.columns : void 0,
+          getOutHasColors: () => useColor() ?? (process11.stdout.isTTY && process11.stdout.hasColors?.()),
+          getErrHasColors: () => useColor() ?? (process11.stderr.isTTY && process11.stderr.hasColors?.()),
           stripColor: (str) => stripColor(str)
         };
         this._hidden = false;
@@ -1585,7 +1585,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._exitCallback) {
           this._exitCallback(new CommanderError2(exitCode, code, message));
         }
-        process10.exit(exitCode);
+        process11.exit(exitCode);
       }
       /**
        * Register callback `fn` for the command.
@@ -1983,16 +1983,16 @@ Expecting one of '${allowedValues.join("', '")}'`);
         }
         parseOptions = parseOptions || {};
         if (argv === void 0 && parseOptions.from === void 0) {
-          if (process10.versions?.electron) {
+          if (process11.versions?.electron) {
             parseOptions.from = "electron";
           }
-          const execArgv = process10.execArgv ?? [];
+          const execArgv = process11.execArgv ?? [];
           if (execArgv.includes("-e") || execArgv.includes("--eval") || execArgv.includes("-p") || execArgv.includes("--print")) {
             parseOptions.from = "eval";
           }
         }
         if (argv === void 0) {
-          argv = process10.argv;
+          argv = process11.argv;
         }
         this.rawArgs = argv.slice();
         let userArgs;
@@ -2003,7 +2003,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
             userArgs = argv.slice(2);
             break;
           case "electron":
-            if (process10.defaultApp) {
+            if (process11.defaultApp) {
               this._scriptPath = argv[1];
               userArgs = argv.slice(2);
             } else {
@@ -2190,11 +2190,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         }
         launchWithNode = sourceExt.includes(path4.extname(executableFile));
         let proc;
-        if (process10.platform !== "win32") {
+        if (process11.platform !== "win32") {
           if (launchWithNode) {
             args.unshift(executableFile);
-            args = incrementNodeInspectorPort(process10.execArgv).concat(args);
-            proc = childProcess.spawn(process10.argv[0], args, { stdio: "inherit" });
+            args = incrementNodeInspectorPort(process11.execArgv).concat(args);
+            proc = childProcess.spawn(process11.argv[0], args, { stdio: "inherit" });
           } else {
             proc = childProcess.spawn(executableFile, args, { stdio: "inherit" });
           }
@@ -2205,13 +2205,13 @@ Expecting one of '${allowedValues.join("', '")}'`);
             subcommand._name
           );
           args.unshift(executableFile);
-          args = incrementNodeInspectorPort(process10.execArgv).concat(args);
-          proc = childProcess.spawn(process10.execPath, args, { stdio: "inherit" });
+          args = incrementNodeInspectorPort(process11.execArgv).concat(args);
+          proc = childProcess.spawn(process11.execPath, args, { stdio: "inherit" });
         }
         if (!proc.killed) {
           const signals = ["SIGUSR1", "SIGUSR2", "SIGTERM", "SIGINT", "SIGHUP"];
           signals.forEach((signal) => {
-            process10.on(signal, () => {
+            process11.on(signal, () => {
               if (proc.killed === false && proc.exitCode === null) {
                 proc.kill(signal);
               }
@@ -2222,7 +2222,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         proc.on("close", (code) => {
           code = code ?? 1;
           if (!exitCallback) {
-            process10.exit(code);
+            process11.exit(code);
           } else {
             exitCallback(
               new CommanderError2(
@@ -2244,7 +2244,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
             throw new Error(`'${executableFile}' not executable`);
           }
           if (!exitCallback) {
-            process10.exit(1);
+            process11.exit(1);
           } else {
             const wrappedError = new CommanderError2(
               1,
@@ -2739,13 +2739,13 @@ Expecting one of '${allowedValues.join("', '")}'`);
        */
       _parseOptionsEnv() {
         this.options.forEach((option) => {
-          if (option.envVar && option.envVar in process10.env) {
+          if (option.envVar && option.envVar in process11.env) {
             const optionKey = option.attributeName();
             if (this.getOptionValue(optionKey) === void 0 || ["default", "config", "env"].includes(
               this.getOptionValueSource(optionKey)
             )) {
               if (option.required || option.optional) {
-                this.emit(`optionEnv:${option.name()}`, process10.env[option.envVar]);
+                this.emit(`optionEnv:${option.name()}`, process11.env[option.envVar]);
               } else {
                 this.emit(`optionEnv:${option.name()}`);
               }
@@ -3200,7 +3200,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        */
       help(contextOptions) {
         this.outputHelp(contextOptions);
-        let exitCode = Number(process10.exitCode ?? 0);
+        let exitCode = Number(process11.exitCode ?? 0);
         if (exitCode === 0 && contextOptions && typeof contextOptions !== "function" && contextOptions.error) {
           exitCode = 1;
         }
@@ -3290,9 +3290,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
       });
     }
     function useColor() {
-      if (process10.env.NO_COLOR || process10.env.FORCE_COLOR === "0" || process10.env.FORCE_COLOR === "false")
+      if (process11.env.NO_COLOR || process11.env.FORCE_COLOR === "0" || process11.env.FORCE_COLOR === "false")
         return false;
-      if (process10.env.FORCE_COLOR || process10.env.CLICOLOR_FORCE !== void 0)
+      if (process11.env.FORCE_COLOR || process11.env.CLICOLOR_FORCE !== void 0)
         return true;
       return void 0;
     }
@@ -3340,6 +3340,55 @@ var {
   Help
 } = import_index.default;
 
+// package.json
+var package_default = {
+  name: "@kimbho/kimbho-cli",
+  version: "0.1.1",
+  description: "Kimbho CLI is a terminal-native coding agent for planning, execution, and verification.",
+  type: "module",
+  engines: {
+    node: ">=20.0.0"
+  },
+  preferGlobal: true,
+  bin: {
+    kimbho: "dist/index.cjs"
+  },
+  main: "dist/index.cjs",
+  exports: {
+    ".": {
+      default: "./dist/index.cjs"
+    }
+  },
+  files: [
+    "dist",
+    "README.md"
+  ],
+  publishConfig: {
+    access: "public"
+  },
+  scripts: {
+    build: "npm run clean && npm run build:bundle && npm run chmod:bin",
+    "build:bundle": "esbuild src/index.ts --bundle --platform=node --format=cjs --sourcemap --outfile=dist/index.cjs --banner:js='#!/usr/bin/env node'",
+    "chmod:bin": `node -e "require('node:fs').chmodSync('dist/index.cjs', 0o755)"`,
+    clean: `node -e "require('node:fs').rmSync('dist', { recursive: true, force: true })"`,
+    prepack: "npm run build"
+  },
+  dependencies: {
+    commander: "^13.1.0"
+  },
+  devDependencies: {
+    "@kimbho/agent-runtime": "file:../agent-runtime",
+    "@kimbho/brains": "file:../brains",
+    "@kimbho/core": "file:../core",
+    "@kimbho/planner": "file:../planner",
+    "@kimbho/tools": "file:../tools"
+  }
+};
+
+// src/metadata.ts
+var KIMBHO_VERSION = package_default.version;
+var KIMBHO_DESCRIPTION = "Kimbho CLI: a terminal-native coding agent for planning and execution.";
+
 // ../agent-runtime/dist/agents/catalog.js
 var AGENT_CATALOG = {
   "session-orchestrator": {
@@ -9948,36 +9997,392 @@ function createReviewCommand() {
   );
 }
 
-// src/index.ts
-var program2 = new Command();
-program2.name("kimbho").description("Kimbho CLI: a terminal-native coding agent for planning and execution.").version("0.1.0");
-program2.addCommand(createInitCommand());
-program2.addCommand(createPlanCommand());
-program2.addCommand(createDoctorCommand());
-program2.addCommand(createAgentsCommand());
-program2.addCommand(createProvidersCommand());
-program2.addCommand(createModelsCommand());
-program2.addCommand(createBrainsCommand());
-program2.addCommand(createRunCommand());
-program2.addCommand(createResumeCommand());
-program2.addCommand(createFixCommand());
-program2.addCommand(createReviewCommand());
-var normalizedArgv = process.argv.map(
-  (value, index) => index === 2 && value.startsWith("/") ? value.slice(1) : value
-);
-var modelsSubcommands = /* @__PURE__ */ new Set([
+// src/program.ts
+var MODELS_SUBCOMMANDS = /* @__PURE__ */ new Set([
   "help",
   "list",
   "sync",
   "use"
 ]);
-if (normalizedArgv[2] === "models") {
-  const candidate = normalizedArgv[3];
-  if (!candidate || candidate.startsWith("-") || !modelsSubcommands.has(candidate)) {
-    normalizedArgv.splice(3, 0, "list");
+function normalizeCliTokens(tokens) {
+  const normalized = [...tokens];
+  if (normalized[0]?.startsWith("/")) {
+    normalized[0] = normalized[0].slice(1);
+  }
+  if (normalized[0] === "models") {
+    const candidate = normalized[1];
+    if (!candidate || candidate.startsWith("-") || !MODELS_SUBCOMMANDS.has(candidate)) {
+      normalized.splice(1, 0, "list");
+    }
+  }
+  return normalized;
+}
+function createProgram(onOpenShell) {
+  const program2 = new Command();
+  program2.name("kimbho").description(KIMBHO_DESCRIPTION).version(KIMBHO_VERSION);
+  program2.addCommand(createInitCommand());
+  program2.addCommand(createPlanCommand());
+  program2.addCommand(createDoctorCommand());
+  program2.addCommand(createAgentsCommand());
+  program2.addCommand(createProvidersCommand());
+  program2.addCommand(createModelsCommand());
+  program2.addCommand(createBrainsCommand());
+  program2.addCommand(createRunCommand());
+  program2.addCommand(createResumeCommand());
+  program2.addCommand(createFixCommand());
+  program2.addCommand(createReviewCommand());
+  if (onOpenShell) {
+    program2.command("shell").description("Open the interactive Kimbho shell.").action(async () => {
+      await onOpenShell();
+    });
+  }
+  return program2;
+}
+
+// src/shell.ts
+var import_promises6 = require("node:readline/promises");
+var import_node_process9 = __toESM(require("node:process"), 1);
+var AMBER = "\x1B[38;5;214m";
+var BOLD = "\x1B[1m";
+var DIM = "\x1B[2m";
+var RESET = "\x1B[0m";
+var TOP_LEVEL_COMMANDS = /* @__PURE__ */ new Set([
+  "agents",
+  "brains",
+  "doctor",
+  "fix",
+  "help",
+  "init",
+  "model",
+  "models",
+  "new",
+  "plan",
+  "providers",
+  "quit",
+  "resume",
+  "review",
+  "run",
+  "scaffold",
+  "shell",
+  "status"
+]);
+function color(code, value) {
+  return `${code}${value}${RESET}`;
+}
+function renderBanner() {
+  return [
+    " _  ___ __  __ ____  ____  _   _  ___ ",
+    "| |/ (_)  \\/  | __ )|  _ \\| | | |/ _ \\",
+    "| ' /| | |\\/| |  _ \\| | | | |_| | | | |",
+    "| . \\| | |  | | |_) | |_| |  _  | |_| |",
+    "|_|\\_\\_|_|  |_|____/|____/|_| |_|\\___/ "
+  ].map((line) => color(AMBER, line)).join("\n");
+}
+async function getShellSessionState(cwd) {
+  const config = await loadConfig(cwd);
+  if (!config) {
+    return {
+      providerLabel: "unconfigured",
+      providerId: "-",
+      coderModel: "not set",
+      plannerModel: "not set",
+      approvalMode: "manual",
+      sandboxMode: "workspace-write",
+      stackPreset: "next-prisma-postgres",
+      configured: false
+    };
+  }
+  const coderSettings = config.brains.coder;
+  const provider = findProviderById(config, coderSettings.providerId);
+  return {
+    providerLabel: provider?.label ?? provider?.id ?? "unknown",
+    providerId: provider?.id ?? coderSettings.providerId,
+    coderModel: resolveBrainModel(config, "coder") ?? "not set",
+    plannerModel: resolveBrainModel(config, "planner") ?? "not set",
+    approvalMode: config.approvalMode,
+    sandboxMode: config.sandboxMode,
+    stackPreset: config.stackPresets[0] ?? "none",
+    configured: true
+  };
+}
+function renderCardLine(label, value) {
+  return `${label}: ${value}`;
+}
+function shortenMiddle(value, maxLength) {
+  if (value.length <= maxLength) {
+    return value;
+  }
+  const visible = maxLength - 3;
+  const left = Math.ceil(visible / 2);
+  const right = Math.floor(visible / 2);
+  return `${value.slice(0, left)}...${value.slice(value.length - right)}`;
+}
+function renderBox(lines) {
+  const width = lines.reduce((max, line) => Math.max(max, line.length), 0);
+  const top = `+${"-".repeat(width + 2)}+`;
+  return [
+    top,
+    ...lines.map((line) => `| ${line.padEnd(width, " ")} |`),
+    top
+  ].join("\n");
+}
+function renderHelp() {
+  return [
+    `${color(DIM, "Commands")}`,
+    "/status           Show the active model, provider, and workspace state.",
+    "/plan <goal>      Create a structured implementation plan.",
+    "/run <goal>       Start a Kimbho execution session for a goal.",
+    "/new <goal>       Alias for /run <goal>.",
+    "/scaffold <goal>  Alias for /run <goal> with scaffolding intent.",
+    "/resume           Show the latest saved session.",
+    "/agents           Inspect agent roles and the active session.",
+    "/providers        Manage model providers.",
+    "/model            Show the active planner/coder model selection.",
+    "/models           Discover and select provider models.",
+    "/brains           Inspect or assign planner/coder/reviewer brains.",
+    "/doctor           Check local environment and config.",
+    "/clear            Redraw the shell.",
+    "/quit, /exit      Leave the shell.",
+    "",
+    `${color(DIM, "Tip")}`,
+    "Type a natural-language goal directly and Kimbho will treat it as /run <goal>."
+  ].join("\n");
+}
+function renderStartupCard(cwd, state) {
+  const cardLines = [
+    `${color(BOLD, "Kimbho CLI")} (v${KIMBHO_VERSION})`,
+    renderCardLine("coder", state.coderModel),
+    renderCardLine("planner", state.plannerModel),
+    renderCardLine("provider", `${state.providerLabel} [${state.providerId}]`),
+    renderCardLine("directory", shortenMiddle(cwd, 78)),
+    renderCardLine("approval", state.approvalMode),
+    renderCardLine("sandbox", state.sandboxMode),
+    renderCardLine("preset", state.stackPreset),
+    renderCardLine("shortcuts", "/help  /status  /plan  /run  /models  /brains  /quit")
+  ];
+  if (!state.configured) {
+    cardLines.push("setup: run /init to create .kimbho/config.json");
+  }
+  return renderBox(cardLines);
+}
+function formatPrompt(state) {
+  const coderModel = state.coderModel === "not set" ? "unconfigured" : shortenMiddle(state.coderModel, 18);
+  return `${color(AMBER, "kimbho")} ${color(DIM, `[${coderModel}]`)} > `;
+}
+function printHeader(cwd, state) {
+  console.log(renderBanner());
+  console.log(color(DIM, "Terminal-native coding agent"));
+  console.log(renderStartupCard(cwd, state));
+  console.log("");
+  console.log(color(DIM, "Tip: describe the app or repo change you want, and Kimbho will route it into /run."));
+  console.log(renderHelp());
+  console.log("");
+}
+function tokenizeInput(input) {
+  const tokens = [];
+  let current = "";
+  let quote = null;
+  let escaping = false;
+  for (const character of input) {
+    if (escaping) {
+      current += character;
+      escaping = false;
+      continue;
+    }
+    if (character === "\\") {
+      escaping = true;
+      continue;
+    }
+    if (quote) {
+      if (character === quote) {
+        quote = null;
+      } else {
+        current += character;
+      }
+      continue;
+    }
+    if (character === "'" || character === '"') {
+      quote = character;
+      continue;
+    }
+    if (/\s/.test(character)) {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += character;
+  }
+  if (quote) {
+    throw new Error(`Unterminated ${quote === '"' ? "double" : "single"} quote.`);
+  }
+  if (escaping) {
+    current += "\\";
   }
+  if (current) {
+    tokens.push(current);
+  }
+  return tokens;
+}
+function toCommandTokens(input) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    return [];
+  }
+  const normalizedInput = trimmed.startsWith("kimbho ") ? trimmed.slice("kimbho ".length).trim() : trimmed;
+  const tokens = tokenizeInput(normalizedInput);
+  if (tokens.length === 0) {
+    return [];
+  }
+  const firstToken = tokens[0];
+  if (!firstToken) {
+    return [];
+  }
+  const head = firstToken.startsWith("/") ? firstToken.slice(1) : firstToken;
+  if (head === "new") {
+    return [
+      "run",
+      normalizedInput.replace(/^\/?new\s+/, "")
+    ];
+  }
+  if (head === "scaffold") {
+    const goal = normalizedInput.replace(/^\/?scaffold\s+/, "");
+    return [
+      "run",
+      `scaffold ${goal}`.trim()
+    ];
+  }
+  if (head === "model") {
+    return [
+      "brains",
+      "list"
+    ];
+  }
+  if (!firstToken.startsWith("/") && !TOP_LEVEL_COMMANDS.has(head) && !head.startsWith("-")) {
+    return [
+      "run",
+      normalizedInput
+    ];
+  }
+  tokens[0] = head;
+  return tokens;
+}
+async function runInteractiveShell(options) {
+  const readline = (0, import_promises6.createInterface)({
+    input: import_node_process9.default.stdin,
+    output: import_node_process9.default.stdout,
+    terminal: Boolean(import_node_process9.default.stdin.isTTY && import_node_process9.default.stdout.isTTY)
+  });
+  let closed = false;
+  readline.on("SIGINT", () => {
+    closed = true;
+    readline.close();
+  });
+  let state = await getShellSessionState(options.cwd);
+  printHeader(options.cwd, state);
+  while (!closed) {
+    let line;
+    try {
+      state = await getShellSessionState(options.cwd);
+      line = await readline.question(formatPrompt(state));
+    } catch {
+      break;
+    }
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+    if (trimmed === "/exit" || trimmed === "exit" || trimmed === "quit" || trimmed === "/quit") {
+      closed = true;
+      break;
+    }
+    if (trimmed === "/help" || trimmed === "help" || trimmed === "?") {
+      console.log(renderHelp());
+      console.log("");
+      continue;
+    }
+    if (trimmed === "/status" || trimmed === "status") {
+      state = await getShellSessionState(options.cwd);
+      console.log(renderStartupCard(options.cwd, state));
+      console.log("");
+      continue;
+    }
+    if (trimmed === "/clear" || trimmed === "clear") {
+      if (import_node_process9.default.stdout.isTTY) {
+        import_node_process9.default.stdout.write("\x1Bc");
+      }
+      state = await getShellSessionState(options.cwd);
+      printHeader(options.cwd, state);
+      continue;
+    }
+    try {
+      const tokens = toCommandTokens(trimmed);
+      if (tokens.length === 0) {
+        continue;
+      }
+      await options.execute(tokens);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(message);
+    } finally {
+      import_node_process9.default.exitCode = 0;
+    }
+    if (!closed) {
+      console.log("");
+    }
+  }
+  readline.close();
+  import_node_process9.default.exitCode = 0;
+  console.log(color(DIM, "Leaving Kimbho."));
+}
+
+// src/index.ts
+async function dispatchCliTokens(tokens) {
+  const program2 = createProgram();
+  program2.exitOverride();
+  try {
+    await program2.parseAsync([
+      "node",
+      "kimbho",
+      ...normalizeCliTokens(tokens)
+    ]);
+  } catch (error) {
+    if (error instanceof CommanderError) {
+      return;
+    }
+    throw error;
+  }
+}
+async function openShell() {
+  await runInteractiveShell({
+    cwd: process.cwd(),
+    execute: dispatchCliTokens
+  });
+}
+async function main() {
+  const tokens = normalizeCliTokens(process.argv.slice(2));
+  if (tokens.length === 0) {
+    if (process.stdin.isTTY && process.stdout.isTTY) {
+      await openShell();
+      return;
+    }
+    const helpProgram = createProgram(openShell);
+    await helpProgram.parseAsync([
+      "node",
+      "kimbho",
+      "--help"
+    ]);
+    return;
+  }
+  const program2 = createProgram(openShell);
+  await program2.parseAsync([
+    "node",
+    "kimbho",
+    ...tokens
+  ]);
 }
-program2.parseAsync(normalizedArgv).catch((error) => {
+main().catch((error) => {
   const message = error instanceof Error ? error.message : String(error);
   console.error(message);
   process.exitCode = 1;