@dadado/agent-kit-cli 4.3.0 → 4.4.1

package/dist/index.js

@@ -2167,6 +2167,27 @@ async function runScanner(rootDir) {
 
 // src/utils/prompts.ts
 import { cancel, confirm, isCancel, multiselect, select, text } from "@clack/prompts";
+var WORKSPACE_SKIN_MODE_DEFAULTS = {
+  default: "autopilot",
+  modes: {
+    "continue-plan": "autopilot",
+    "run-plan": "night-shift",
+    "cli-run-plan": "ghost-runner"
+  }
+};
+function workspaceSkinConfigFromChoice(choice) {
+  if (choice.kind === "skip") return null;
+  if (choice.kind === "mode-defaults")
+    return { ...WORKSPACE_SKIN_MODE_DEFAULTS, modes: { ...WORKSPACE_SKIN_MODE_DEFAULTS.modes } };
+  return {
+    default: choice.id,
+    modes: {
+      "continue-plan": choice.id,
+      "run-plan": choice.id,
+      "cli-run-plan": choice.id
+    }
+  };
+}
 function ensureNotCancelled(value) {
   if (isCancel(value)) {
     cancel("Operation cancelled.");
@@ -2238,6 +2259,27 @@ async function askProjectManagement(existing = []) {
     })
   );
 }
+async function askWorkspaceSkin() {
+  const value = ensureNotCancelled(
+    await select({
+      message: "Workspace skin for chat/CLI chrome? (optional)",
+      initialValue: "mode-defaults",
+      options: [
+        {
+          label: "Keep mode defaults (Autopilot/Night Shift/Ghost Runner per mode)",
+          value: "mode-defaults"
+        },
+        { label: "Autopilot", value: "autopilot" },
+        { label: "Night Shift", value: "night-shift" },
+        { label: "Ghost Runner", value: "ghost-runner" },
+        { label: "Skip for now", value: "skip" }
+      ]
+    })
+  );
+  if (value === "skip") return { kind: "skip" };
+  if (value === "mode-defaults") return { kind: "mode-defaults" };
+  return { kind: "skin", id: value };
+}
 async function runExistingProjectWizard(scan) {
   const ide = await askIdeAndPlan(scan.ide);
   const workflow = await askGitWorkflow(scan.git.workflow);
@@ -2248,6 +2290,7 @@ async function runExistingProjectWizard(scan) {
       initialValue: true
     })
   );
+  const workspaceSkinChoice = await askWorkspaceSkin();
   return {
     rootDir: scan.rootDir,
     stack: scan.stack,
@@ -2265,7 +2308,8 @@ async function runExistingProjectWizard(scan) {
       "clean-code",
       "docs-repo",
       "ide-guide"
-    ]
+    ],
+    workspaceSkinChoice
   };
 }
 async function runGreenfieldWizard(scan) {
@@ -2324,6 +2368,7 @@ async function runGreenfieldWizard(scan) {
       initialValue: true
     })
   );
+  const workspaceSkinChoice = await askWorkspaceSkin();
   return {
     rootDir: scan.rootDir,
     stack: {
@@ -2349,11 +2394,20 @@ async function runGreenfieldWizard(scan) {
       "clean-code",
       "docs-repo",
       "ide-guide"
-    ]
+    ],
+    workspaceSkinChoice
   };
 }
 
 // src/commands/init.ts
+async function mergeWorkspaceSkinConfig(rootDir, workspaceSkin) {
+  const contextDir = path23.join(rootDir, ".cursor", "context");
+  const configPath = path23.join(contextDir, "config.json");
+  await ensureDir(contextDir);
+  const existing = await readJson(configPath) ?? {};
+  await writeJson(configPath, { ...existing, workspaceSkin });
+  return configPath;
+}
 var initCommand = defineCommand5({
   meta: {
     name: "init",
@@ -2374,9 +2428,15 @@ var initCommand = defineCommand5({
       scan.isGreenfield ? "Empty repo detected (greenfield)." : "Existing project detected."
     );
     const profile = scan.isGreenfield ? await runGreenfieldWizard(scan) : await runExistingProjectWizard(scan);
+    const { workspaceSkinChoice, ...profileToSave } = profile;
     const configPath = path23.join(scan.rootDir, ".cursor", "agent-kit.config.json");
-    await writeJson(configPath, profile);
+    await writeJson(configPath, profileToSave);
     logger.success(`Profile saved in ${configPath}`);
+    const skinConfig = workspaceSkinChoice !== void 0 ? workspaceSkinConfigFromChoice(workspaceSkinChoice) : null;
+    if (skinConfig) {
+      const contextConfigPath = await mergeWorkspaceSkinConfig(scan.rootDir, skinConfig);
+      logger.success(`Workspace skin saved in ${contextConfigPath}`);
+    }
     await generateFromProfile(profile);
     try {
       const registry = await resolveRegistryRoot({ cwd: scan.rootDir });
@@ -2521,7 +2581,7 @@ var installCommand = defineCommand6({
 });
 
 // src/commands/run-plan.ts
-import path28 from "path";
+import path29 from "path";
 import { defineCommand as defineCommand7 } from "citty";
 
 // src/plan-loop/backends.ts
@@ -2607,7 +2667,7 @@ function listBackendIds() {
 
 // src/plan-loop/run-loop.ts
 import { mkdir as mkdir4, readFile as readFile10, rm, unlink } from "fs/promises";
-import path27 from "path";
+import path28 from "path";
 
 // src/plan-loop/external-review.ts
 import { spawn as spawn3 } from "child_process";
@@ -2771,6 +2831,101 @@ function formatSentinelLine(sentinel) {
   return "";
 }
 
+// src/plan-loop/skin-banners.ts
+import path27 from "path";
+import {
+  blue,
+  cyan as cyan2,
+  gray,
+  green as green2,
+  lightGray,
+  lightGreen,
+  magenta,
+  red as red2,
+  white,
+  yellow as yellow2
+} from "kolorist";
+var CLI_RUN_PLAN_MODE = "cli-run-plan";
+var DEFAULT_CLI_SKIN_ID = "ghost-runner";
+var COLORS = {
+  white,
+  gray,
+  green: green2,
+  cyan: cyan2,
+  magenta,
+  yellow: yellow2,
+  red: red2,
+  blue,
+  "light-green": lightGreen,
+  lightgreen: lightGreen,
+  "light-gray": lightGray,
+  lightgray: lightGray
+};
+function resolveColor(name, fallback) {
+  if (!name) return fallback;
+  return COLORS[name.toLowerCase()] ?? fallback;
+}
+async function resolveCliSkinId(root) {
+  try {
+    const cfg = await readJson(
+      path27.join(root, ".cursor", "context", "config.json")
+    );
+    const id = cfg?.workspaceSkin?.modes?.[CLI_RUN_PLAN_MODE];
+    if (typeof id === "string" && id.trim()) return id.trim();
+  } catch {
+  }
+  return DEFAULT_CLI_SKIN_ID;
+}
+async function loadSkinPack(root, skinId) {
+  try {
+    const skinPath = path27.join(root, "registry", "skins", "core", skinId, "skin.json");
+    const pack = await readJson(skinPath);
+    if (!pack || typeof pack.id !== "string") return null;
+    return pack;
+  } catch {
+    return null;
+  }
+}
+async function loadCliRunPlanSkin(root) {
+  const id = await resolveCliSkinId(root);
+  return loadSkinPack(root, id);
+}
+function createSkinBannerPrinter(skin) {
+  if (!skin?.cliBanners) return null;
+  const banners = skin.cliBanners;
+  if (!banners.tickStart && !banners.tickEnd && !banners.phaseComplete) return null;
+  const primary = resolveColor(skin.ansiPalette?.primary, white);
+  const secondary = resolveColor(skin.ansiPalette?.secondary, gray);
+  const accent = resolveColor(skin.ansiPalette?.accent, green2);
+  return {
+    tickStart(detail) {
+      if (banners.tickStart) {
+        console.log(`${accent(banners.tickStart)} ${primary(detail)}`);
+      } else {
+        console.log(primary(detail));
+      }
+    },
+    tickEnd(detail) {
+      if (!banners.tickEnd) return;
+      const line = detail ? `${banners.tickEnd} ${detail}` : banners.tickEnd;
+      console.log(secondary(line));
+    },
+    phaseComplete(detail) {
+      if (!banners.phaseComplete) return;
+      const line = detail ? `${banners.phaseComplete} ${detail}` : banners.phaseComplete;
+      console.log(accent(line));
+    },
+    sleep(seconds) {
+      console.log(secondary(`sleep ${seconds}s`));
+    },
+    stop(reason) {
+      if (banners.tickEnd) {
+        console.log(secondary(`${banners.tickEnd} ${reason}`));
+      }
+    }
+  };
+}
+
 // src/plan-loop/run-loop.ts
 var TICK_PROMPT = '/run-plan - single tick from the headless runner (agent-kit run-plan). Read .cursor/HANDOFF.md and the active plan in .cursor/plans/. Mark the next to-do as in_progress in the frontmatter, execute ONLY that to-do, mark completed and update HANDOFF. If there is a commitable diff: run /git-staging without asking for confirmation. NEVER /git-prod. Do NOT re-arm an internal Loop skill - the external runner starts the next agent. End the response with exactly one line: "LOOP_TICK_RESULT: continue" if implementable to-dos remain, or "LOOP_TICK_RESULT: stop - <reason>" (plan exhausted, external blocker, or human decision needed).';
 function stamp() {
@@ -2782,9 +2937,9 @@ function sleep(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
 async function runPlanLoop(opts) {
-  const plansDir = path27.join(opts.root, ".cursor", "plans");
-  const stopFile = path27.join(opts.root, ".cursor", "loop.stop");
-  const logDir = path27.join(opts.root, ".cursor", "loop-logs");
+  const plansDir = path28.join(opts.root, ".cursor", "plans");
+  const stopFile = path28.join(opts.root, ".cursor", "loop.stop");
+  const logDir = path28.join(opts.root, ".cursor", "loop-logs");
   const planPath = await findActivePlanFile(plansDir);
   if (!planPath) {
     logger.error("No active plan in .cursor/plans/");
@@ -2803,9 +2958,14 @@ async function runPlanLoop(opts) {
   };
   process.on("SIGINT", onSigInt);
   try {
-    console.log(`Active plan: ${path27.basename(planPath)}`);
+    const skin = await loadCliRunPlanSkin(opts.root);
+    const banners = createSkinBannerPrinter(skin);
+    console.log(`Active plan: ${path28.basename(planPath)}`);
     console.log(`Pending to-dos: ${await pending()} | max ticks: ${opts.maxTicks}`);
     console.log(`Backend: ${opts.backend.id}`);
+    if (skin) {
+      console.log(`CLI skin: ${skin.displayName ?? skin.id}`);
+    }
     if (opts.dryRun) {
       console.log("--dry-run: no agent will be started. Tick prompt:");
       console.log(TICK_PROMPT);
@@ -2822,11 +2982,15 @@ async function runPlanLoop(opts) {
     while (true) {
       tick += 1;
       if (tick > opts.maxTicks) {
-        console.log(`Budget of ${opts.maxTicks} ticks reached - stopping. Run again to continue.`);
+        const msg = `Budget of ${opts.maxTicks} ticks reached - stopping. Run again to continue.`;
+        if (banners) banners.stop(msg);
+        else console.log(msg);
         break;
       }
       if (await fileExists(stopFile)) {
-        console.log(`Stop file found (${stopFile}) - stopping.`);
+        const msg = `Stop file found (${stopFile}) - stopping.`;
+        if (banners) banners.stop(msg);
+        else console.log(msg);
         try {
           await rm(stopFile, { force: true });
         } catch {
@@ -2839,10 +3003,12 @@ async function runPlanLoop(opts) {
         planExhausted = true;
         break;
       }
-      const logPath = path27.join(logDir, `tick-${stamp()}.log`);
-      const relLog = path27.relative(opts.root, logPath);
+      const logPath = path28.join(logDir, `tick-${stamp()}.log`);
+      const relLog = path28.relative(opts.root, logPath);
       console.log("");
-      console.log(`=== tick ${tick}/${opts.maxTicks} - pending: ${before} - log: ${relLog} ===`);
+      const tickLine = `=== tick ${tick}/${opts.maxTicks} - pending: ${before} - log: ${relLog} ===`;
+      if (banners) banners.tickStart(tickLine);
+      else console.log(tickLine);
       let agentExit = 0;
       try {
         const result = await opts.backend.run({
@@ -2859,21 +3025,28 @@ async function runPlanLoop(opts) {
       try {
         const logText = await readFile10(logPath, "utf8");
         if (logText.includes("Too many MCP tools")) {
-          console.log(
-            "Too many MCP tools for the headless model - disable servers (cursor-agent mcp disable <id>) and run again."
-          );
+          const msg = "Too many MCP tools for the headless model - disable servers (cursor-agent mcp disable <id>) and run again.";
+          if (banners) banners.stop(msg);
+          else console.log(msg);
           break;
         }
       } catch {
       }
       if (agentExit !== 0) {
-        console.log(
-          `${opts.backend.id} exited with code ${agentExit} - stopping. See log: ${logPath}`
-        );
+        const msg = `${opts.backend.id} exited with code ${agentExit} - stopping. See log: ${logPath}`;
+        if (banners) {
+          banners.tickEnd(`exit ${agentExit}`);
+          banners.stop(msg);
+        } else {
+          console.log(msg);
+        }
         break;
       }
       const sentinel = await parseSentinelFromLogFile(logPath);
       const after = await pending();
+      if (banners) {
+        banners.tickEnd(`pending: ${after}`);
+      }
       if (sentinel.kind === "continue") {
       } else if (sentinel.kind === "stop") {
         console.log(`Agent requested stop: ${formatSentinelLine(sentinel)}`);
@@ -2887,9 +3060,9 @@ async function runPlanLoop(opts) {
           `warn: tick without sentinel, but progress (${before} -> ${after}) - continuing.`
         );
       } else {
-        console.log(
-          `Tick without sentinel and no progress (${before} -> ${after}) - stopping for safety.`
-        );
+        const msg = `Tick without sentinel and no progress (${before} -> ${after}) - stopping for safety.`;
+        if (banners) banners.stop(msg);
+        else console.log(msg);
         break;
       }
       if (after === 0) {
@@ -2898,13 +3071,16 @@ async function runPlanLoop(opts) {
         break;
       }
       if (opts.sleepSeconds > 0) {
+        if (banners) banners.sleep(opts.sleepSeconds);
         await sleep(opts.sleepSeconds * 1e3);
       }
     }
     const pendingNow = await pending();
     console.log("");
+    const finishDetail = `after ${tick} tick(s); pending: ${pendingNow}`;
+    if (banners) banners.phaseComplete(finishDetail);
     console.log(
-      `Loop finished after ${tick} tick(s). Pending now: ${pendingNow}. Logs in ${path27.relative(opts.root, logDir)}/`
+      `Loop finished after ${tick} tick(s). Pending now: ${pendingNow}. Logs in ${path28.relative(opts.root, logDir)}/`
     );
     if (planExhausted || shouldArmExternalPlanReview({ pending: pendingNow, stopReason })) {
       await armExternalPlanReview(opts.root);
@@ -2975,7 +3151,7 @@ var runPlanCommand = defineCommand7({
       return;
     }
     const code = await runPlanLoop({
-      root: path28.resolve(args.cwd),
+      root: path29.resolve(args.cwd),
       maxTicks,
       sleepSeconds,
       model: args.model ? String(args.model) : void 0,
@@ -3009,7 +3185,7 @@ var scanCommand = defineCommand8({
 });
 
 // src/commands/status.ts
-import path29 from "path";
+import path30 from "path";
 import { defineCommand as defineCommand9 } from "citty";
 var statusCommand = defineCommand9({
   meta: {
@@ -3029,7 +3205,7 @@ var statusCommand = defineCommand9({
   },
   async run({ args }) {
     const manifest = await loadAgentKitManifest(args.cwd);
-    const profilePath = path29.join(args.cwd, ".cursor", "agent-kit.config.json");
+    const profilePath = path30.join(args.cwd, ".cursor", "agent-kit.config.json");
     const profile = await readJson(profilePath);
     if (args.json) {
       console.log(
@@ -3119,7 +3295,7 @@ var updateCommand = defineCommand10({
 var main = defineCommand11({
   meta: {
     name: "agent-kit",
-    description: "Developer bootstrapper for AI-assisted IDEs"
+    description: "HITL framework for AI-assisted IDEs"
   },
   subCommands: {
     init: initCommand,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dadado/agent-kit-cli",
-  "version": "4.3.0",
-  "description": "Agent Kit CLI — bootstraps AI-assisted IDEs with project-aware rules, skills, and context management",
+  "version": "4.4.1",
+  "description": "Agent Kit CLI: HITL framework install and tooling for AI-assisted IDEs (rules, skills, plan/handoff, context).",
   "type": "module",
   "bin": {
     "agent-kit": "./dist/index.js"