@kimbho/kimbho-cli 0.1.31 → 0.1.32

package/dist/index.cjs

@@ -12718,7 +12718,7 @@ function createCompletionRuntimeCommand(program2) {
 // package.json
 var package_default = {
   name: "@kimbho/kimbho-cli",
-  version: "0.1.31",
+  version: "0.1.32",
   description: "Kimbho CLI is a terminal-native coding agent for planning, execution, and verification.",
   type: "module",
   engines: {
@@ -42456,7 +42456,13 @@ var CHAT_PREFIXES = [
   "explain ",
   "summarize ",
   "review ",
-  "analyze "
+  "analyze ",
+  "tell me ",
+  "describe ",
+  "detail ",
+  "details ",
+  "walk me through ",
+  "help me understand "
 ];
 var PLAN_PREFIXES = [
   "plan ",
@@ -42468,6 +42474,18 @@ var PLAN_PREFIXES = [
 function looksLikeExecutionRequest(input) {
   return /\b(build|create|make|scaffold|implement|fix|refactor|setup|set up|generate|add|change|update|edit|rewrite|restyle|redesign|improve|enhance)\b/.test(input);
 }
+function looksLikeInformationalRequest(input) {
+  if (/\b(tell me|describe|walk me through|help me understand)\b/.test(input)) {
+    return true;
+  }
+  if (/\b(details?|overview|summary|walkthrough|explanation)\b/.test(input) && /\b(project|repo|repository|codebase|workspace|app)\b/.test(input)) {
+    return true;
+  }
+  return /\b(current|this|the)\s+(project|repo|repository|codebase|workspace|app)\b/.test(input) && /\b(details?|overview|summary|about)\b/.test(input);
+}
+function looksLikeWorkspaceInfoPrompt(input) {
+  return looksLikeInformationalRequest(input.toLowerCase()) && /\b(project|repo|repository|codebase|workspace|app)\b/.test(input.toLowerCase());
+}
 function stripConversationalLead(input) {
   let normalized = input.trim().toLowerCase();
   normalized = normalized.replace(/^(hi|hello|hey|yo|sup)\b[!,. ]*/u, "").trim();
@@ -42495,6 +42513,9 @@ function inferPromptIntent(input) {
   if (looksLikeExecutionRequest(taskCandidate)) {
     return "run";
   }
+  if (looksLikeInformationalRequest(taskCandidate)) {
+    return "chat";
+  }
   if (normalized.endsWith("?")) {
     return "chat";
   }
@@ -50290,6 +50311,138 @@ function renderPendingRunProposal(proposal, options = {}) {
   }
   return lines;
 }
+function buildWorkspaceAnalysisPlan(request, prompt) {
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    goal: request.goal,
+    generatedAt,
+    summary: "Read-only multi-agent analysis of the current repository to answer the operator's question with concrete workspace evidence.",
+    repoStrategy: {
+      mode: "existing-repo",
+      reasoning: "This is an analysis-only request about the current workspace, so the agent team should inspect the repo and synthesize findings without editing source files."
+    },
+    assumptions: [
+      "The user wants a grounded explanation of the current repository, not code changes.",
+      "The analysis should stay read-only and avoid modifying product files."
+    ],
+    openQuestions: [],
+    milestones: [
+      {
+        id: "m1-repo-survey",
+        title: "Repository Survey",
+        objective: "Inspect the current workspace structure, entrypoints, tooling, and conventions.",
+        tasks: [
+          {
+            id: "t1-repo-analysis",
+            title: "Analyze the current workspace and conventions",
+            description: "Map the repository shape, commands, entrypoints, and constraints before answering the user's question.",
+            type: "analysis",
+            status: "pending",
+            agentRole: "repo-analyst",
+            dependsOn: [],
+            acceptanceCriteria: [
+              "Repository shape and commands are captured.",
+              "Likely entrypoints and major packages are identified."
+            ],
+            outputs: [
+              "Repo analysis summary"
+            ],
+            filesLikelyTouched: [
+              ".",
+              ".kimbho/"
+            ],
+            riskLevel: "low",
+            sandboxModeOverride: "read-only"
+          },
+          {
+            id: "t2-architecture",
+            title: "Synthesize the architecture and package boundaries",
+            description: "Turn the repository findings into a clear explanation of the system structure and responsibilities.",
+            type: "documentation",
+            status: "pending",
+            agentRole: "planner",
+            dependsOn: [
+              "t1-repo-analysis"
+            ],
+            acceptanceCriteria: [
+              "Architecture summary is grounded in repo analysis findings.",
+              "The main packages and responsibilities are explicit."
+            ],
+            outputs: [
+              "Architecture brief"
+            ],
+            filesLikelyTouched: [
+              ".kimbho/"
+            ],
+            riskLevel: "low",
+            sandboxModeOverride: "read-only"
+          }
+        ]
+      },
+      {
+        id: "m2-answer",
+        title: "Answer",
+        objective: "Review the gathered analysis artifacts and produce the final project explanation.",
+        tasks: [
+          {
+            id: "t3-project-brief",
+            title: "Review the analysis artifacts and prepare the project explanation",
+            description: "Inspect the repo-analysis and architecture artifacts, then summarize the current project in terms that answer the user's question.",
+            type: "documentation",
+            status: "pending",
+            agentRole: "reviewer",
+            dependsOn: [
+              "t1-repo-analysis",
+              "t2-architecture"
+            ],
+            acceptanceCriteria: [
+              "The answer addresses the user's question directly.",
+              "The summary is grounded in repository evidence instead of generic assistant chatter."
+            ],
+            outputs: [
+              "Project explanation summary"
+            ],
+            filesLikelyTouched: [
+              ".kimbho/logs/",
+              "kimbho_init.md"
+            ],
+            riskLevel: "low",
+            sandboxModeOverride: "read-only",
+            allowedTools: [
+              "file.read",
+              "file.search",
+              "file.list",
+              "repo.index",
+              "repo.query",
+              "git.diff"
+            ],
+            deniedTools: [
+              "file.write",
+              "file.patch",
+              "shell.exec"
+            ],
+            agentPromptPreamble: [
+              "This is a read-only repository explanation task.",
+              "Do not modify product files, install packages, or run development servers.",
+              `Answer the operator's question: ${prompt}`,
+              "Use the repo-analysis and architecture artifacts plus direct file inspection if needed.",
+              "Finish with a concise but concrete summary of the project, stack, entrypoints, commands, and notable risks or gaps."
+            ].join("\n")
+          }
+        ]
+      }
+    ],
+    verificationChecklist: [
+      "Repo analysis artifacts were captured.",
+      "The architecture summary is grounded in the workspace.",
+      "The final explanation answers the user's question without changing source files."
+    ],
+    executionNotes: [
+      "Read-only analysis run triggered directly from a workspace question.",
+      "Prefer repo/file tools and existing memory artifacts over generic assistant responses."
+    ]
+  };
+}
 function hasRenderableDiff(toolId, output) {
   if (!output || output.trim().length === 0) {
     return false;
@@ -50913,6 +51066,22 @@ async function handleChatPrompt(cwd, prompt, runtime) {
     maxCharsPerFile: 3e3
   });
   const skillContext = await resolveActivatedSkillContext(cwd, hydrated.prompt);
+  const workspaceInfoPrompt = looksLikeWorkspaceInfoPrompt(hydrated.prompt);
+  let workspaceOverview = null;
+  if (workspaceInfoPrompt) {
+    const existingOverview = await readMarkdownIfExists(import_node_path33.default.join(cwd, "kimbho_init.md"));
+    if (existingOverview) {
+      workspaceOverview = existingOverview.slice(0, 6e3);
+    } else {
+      try {
+        const generated = await generateProjectInitFile(cwd, "kimbho_init.md");
+        const generatedOverview = await readMarkdownIfExists(generated.outputPath);
+        workspaceOverview = generatedOverview?.slice(0, 6e3) ?? null;
+      } catch {
+        workspaceOverview = null;
+      }
+    }
+  }
   const compactionPath = await compactConversationIfNeeded(cwd, runtime, runtime.focusRole);
   if (compactionPath) {
     console.log(color(DIM, `[compacting] condensed ${runtime.focusRole} chat context -> ${compactionPath}`));
@@ -50928,27 +51097,34 @@ async function handleChatPrompt(cwd, prompt, runtime) {
   let result;
   const activity = new ShellActivityIndicator(pickIdleStatusLabel(prompt));
   activity.start();
+  const systemPromptSections = [
+    brain.settings.promptPreamble,
+    adaptiveMemory.chatSummary.length > 0 ? `Adaptive memory:
+${adaptiveMemory.chatSummary}` : null,
+    memoryContext.length > 0 ? [
+      "Workspace memory:",
+      ...memoryContext.map((record2) => `File: ${record2.filePath}
+${record2.content}`)
+    ].join("\n\n") : null,
+    workspaceOverview ? [
+      "Workspace question handling:",
+      "The user is asking about the current repository. Ground the answer in the workspace context below and do not reply with a generic assistant introduction.",
+      `Workspace overview:
+${workspaceOverview}`
+    ].join("\n\n") : null,
+    skillContext.systemPromptSections.length > 0 ? [
+      "Active skill packs:",
+      ...skillContext.systemPromptSections
+    ].join("\n\n") : null,
+    runtime.conversationSummaries[runtime.focusRole] ? `Compacted conversation summary:
+${runtime.conversationSummaries[runtime.focusRole]}` : null
+  ].filter((value) => Boolean(value));
   try {
     result = await brain.client.generateText({
       model: brain.model,
       messages,
-      ...brain.settings.promptPreamble || runtime.conversationSummaries[runtime.focusRole] ? {
-        systemPrompt: [
-          brain.settings.promptPreamble,
-          adaptiveMemory.chatSummary.length > 0 ? `Adaptive memory:
-${adaptiveMemory.chatSummary}` : null,
-          memoryContext.length > 0 ? [
-            "Workspace memory:",
-            ...memoryContext.map((record2) => `File: ${record2.filePath}
-${record2.content}`)
-          ].join("\n\n") : null,
-          skillContext.systemPromptSections.length > 0 ? [
-            "Active skill packs:",
-            ...skillContext.systemPromptSections
-          ].join("\n\n") : null,
-          runtime.conversationSummaries[runtime.focusRole] ? `Compacted conversation summary:
-${runtime.conversationSummaries[runtime.focusRole]}` : null
-        ].filter((value) => Boolean(value)).join("\n\n")
+      ...systemPromptSections.length > 0 ? {
+        systemPrompt: systemPromptSections.join("\n\n")
       } : {},
       ...typeof brain.settings.temperature === "number" ? {
         temperature: brain.settings.temperature
@@ -51147,6 +51323,174 @@ async function executePendingRunProposal(runtime) {
   void drainQueuedWork(runtime);
   return request.cwd;
 }
+async function synthesizeWorkspaceAnalysisAnswer(cwd, prompt, runtime, snapshot) {
+  const config2 = await loadConfig(cwd);
+  const projectInit = await readMarkdownIfExists(import_node_path33.default.join(cwd, "kimbho_init.md"));
+  const artifactPaths = Array.from(new Set(
+    snapshot.events.flatMap((event) => [
+      ...event.artifacts,
+      ...event.toolResults.flatMap((toolResult) => toolResult.artifacts)
+    ])
+  ));
+  const prioritizedArtifacts = artifactPaths.filter((artifactPath) => /repo-analysis|architecture-brief|project-brief|transcript/i.test(import_node_path33.default.basename(artifactPath))).slice(0, 4);
+  const artifactSections = (await Promise.all(
+    prioritizedArtifacts.map(async (artifactPath) => {
+      const content = await readMarkdownIfExists(artifactPath);
+      if (!content) {
+        return null;
+      }
+      return `Artifact: ${artifactPath}
+${content.slice(0, 4e3)}`;
+    })
+  )).filter((section) => Boolean(section));
+  if (!config2) {
+    return [
+      "Repository analysis completed.",
+      projectInit ? `Current workspace summary:
+${projectInit.slice(0, 4e3)}` : "Project summary is available in the session artifacts, but no configured model was available to synthesize a narrative answer."
+    ].join("\n\n");
+  }
+  const resolver = new BrainResolver(config2, createDefaultBrainProviderRegistry(cwd));
+  const brain = await resolver.resolve(runtime.focusRole);
+  const result = await brain.client.generateText({
+    model: brain.model,
+    systemPrompt: [
+      brain.settings.promptPreamble,
+      "You are summarizing the current repository after a read-only multi-agent analysis session.",
+      "Answer the user's question directly and concretely from the provided workspace evidence.",
+      "Do not greet, do not speak generically about your own capabilities, and do not invent repository details.",
+      "Prefer a crisp project overview with stack, structure, key entrypoints, commands, and notable risks or gaps."
+    ].filter(Boolean).join("\n\n"),
+    userPrompt: [
+      `User question: ${prompt}`,
+      projectInit ? `Workspace overview:
+${projectInit.slice(0, 6e3)}` : null,
+      artifactSections.length > 0 ? artifactSections.join("\n\n") : "No detailed analysis artifacts were available; answer from the workspace overview only."
+    ].filter((value) => Boolean(value)).join("\n\n"),
+    ...typeof brain.settings.temperature === "number" ? {
+      temperature: brain.settings.temperature
+    } : {},
+    ...typeof brain.settings.maxTokens === "number" ? {
+      maxTokens: brain.settings.maxTokens
+    } : {}
+  });
+  return result.text;
+}
+async function handleWorkspaceAnalysisPrompt(cwd, prompt, runtime) {
+  const hydrated = await hydratePromptWithMcpResources(cwd, prompt);
+  await recordAdaptiveTextObservation(cwd, hydrated.prompt, "chat");
+  const skillAwareRequest = await preparePlanningRequest({
+    goal: `Analyze the current repository and answer the user's question: ${hydrated.prompt}`,
+    mode: "run",
+    cwd,
+    workspaceState: "existing",
+    constraints: [
+      "Read-only repository analysis only.",
+      "Do not modify source files, install packages, or start development servers.",
+      "Use multiple agents to inspect the workspace and synthesize the answer when helpful."
+    ]
+  });
+  const request = skillAwareRequest.request;
+  const plan = buildWorkspaceAnalysisPlan(request, hydrated.prompt);
+  const planPath = await savePlan(plan, request.cwd);
+  const orchestrator = new ExecutionOrchestrator();
+  const initialSnapshot = orchestrator.createSessionSnapshot(
+    orchestrator.buildEnvelope(request, plan)
+  );
+  const startedAt = Date.now();
+  const telemetry = createExecutionTelemetry();
+  const controller = new AbortController();
+  runtime.activeExecution = {
+    controller,
+    label: hydrated.prompt
+  };
+  const liveBoard = createLiveRunBoard(
+    initialSnapshot.id,
+    hydrated.prompt,
+    request,
+    plan,
+    resolveShellMaxAutoTasks(runtime),
+    resolveShellMaxAgentSteps(runtime),
+    DEFAULT_MAX_REPAIR_ATTEMPTS2
+  );
+  const tui = import_node_process35.default.stdout.isTTY ? new ShellExecutionTui(liveBoard, telemetry, startedAt, "analyzing", !runtime.dashboard) : null;
+  const activity = tui ? null : new ShellActivityIndicator("analyzing");
+  if (tui) {
+    tui.start();
+    tui.pushEvent(renderLiveExecutionEvent({
+      type: "task-note",
+      sessionId: initialSnapshot.id,
+      message: "Read-only repository analysis session started."
+    }, liveBoard, startedAt, {
+      includeProgress: false
+    }));
+  } else {
+    console.log(renderRunStartCard(liveBoard));
+    console.log("");
+    activity?.start();
+  }
+  let snapshot;
+  try {
+    snapshot = await orchestrator.continueSession(initialSnapshot, {
+      maxAutoTasks: resolveShellMaxAutoTasks(runtime),
+      maxAgentSteps: resolveShellMaxAgentSteps(runtime),
+      maxRepairAttempts: DEFAULT_MAX_REPAIR_ATTEMPTS2,
+      signal: controller.signal,
+      onProgress: async (event) => {
+        updateLiveRunBoard(liveBoard, event);
+        if (event.type === "tool-started") {
+          telemetry.toolCalls += 1;
+        }
+        if (event.type === "model-usage") {
+          telemetry.modelCalls += 1;
+          telemetry.inputTokens += event.usage?.inputTokens ?? 0;
+          telemetry.outputTokens += event.usage?.outputTokens ?? 0;
+        }
+        if (tui) {
+          tui.updateActivity(statusLabelForEvent(event));
+          tui.pushEvent(renderLiveExecutionEvent(event, liveBoard, startedAt, {
+            includeProgress: false
+          }));
+        } else {
+          activity?.update(statusLabelForEvent(event));
+          activity?.suspend();
+          for (const line of renderLiveExecutionEvent(event, liveBoard, startedAt)) {
+            console.log(line);
+          }
+          activity?.resume();
+        }
+      }
+    });
+  } finally {
+    tui?.stop();
+    activity?.stop();
+    runtime.activeExecution = null;
+  }
+  const sessionPath = await saveSession(snapshot, request.cwd);
+  await recordAdaptiveSessionOutcome(request.cwd, snapshot);
+  runtime.currentCwd = request.cwd;
+  const answer = await synthesizeWorkspaceAnalysisAnswer(request.cwd, hydrated.prompt, runtime, snapshot);
+  const conversation = trimConversation([
+    ...getConversation(runtime, runtime.focusRole),
+    {
+      role: "user",
+      content: hydrated.prompt
+    },
+    {
+      role: "assistant",
+      content: answer
+    }
+  ]);
+  runtime.conversations[runtime.focusRole] = conversation;
+  console.log("");
+  console.log(color(DIM, `elapsed: ${((Date.now() - startedAt) / 1e3).toFixed(1)}s`));
+  console.log(color(DIM, renderExecutionTelemetry(telemetry, startedAt)));
+  console.log(renderShellSessionSummary(snapshot, planPath, sessionPath));
+  console.log("");
+  console.log(color(DIM, "[analysis answer]"));
+  console.log(renderTerminalMarkdown(answer));
+  void drainQueuedWork(runtime);
+}
 async function resumeGoalExecution(cwd, runtime) {
   const session = await loadLatestSession(cwd);
   if (!session) {
@@ -52848,6 +53192,10 @@ async function startPendingRunExecution(cwd, runtime) {
     console.log(color(DIM, "Waiting on a hook question before starting the plan."));
     return;
   }
+  if (!proposal) {
+    console.log("No pending run proposal. Start with a build/change request or /run <goal>.");
+    return;
+  }
   if (proposal && planRequiresOperatorReview(proposal.plan)) {
     await emitShellHookEvent(
       proposal.request.cwd,
@@ -52864,6 +53212,15 @@ async function startPendingRunExecution(cwd, runtime) {
       }
     );
   }
+  const confirmedProposal = runtime.pendingRunProposal;
+  if (runtime.pendingHookElicitation) {
+    console.log(color(DIM, "Waiting on a hook question before starting the plan."));
+    return;
+  }
+  if (!confirmedProposal) {
+    console.log(color(DIM, "Pending plan was cleared before execution could start."));
+    return;
+  }
   console.log(color(DIM, "Starting the approved plan..."));
   void executePendingRunProposal(runtime).catch((error2) => {
     console.error(error2 instanceof Error ? error2.message : String(error2));
@@ -52971,6 +53328,14 @@ async function handleShellCommand(cwd, input, state, runtime, execute) {
     return cwd;
   }
   if (!firstToken?.startsWith("/") && !TOP_LEVEL_COMMANDS.has(head) && !head.startsWith("-")) {
+    if (looksLikeWorkspaceInfoPrompt(trimmed)) {
+      if (runtime.activeExecution || runtime.queueDrainPromise || runtime.pendingRunProposal) {
+        queuePlannerRequest(cwd, `Analyze the current repository and answer: ${trimmed}`, runtime, "run");
+        return cwd;
+      }
+      await handleWorkspaceAnalysisPrompt(cwd, trimmed, runtime);
+      return cwd;
+    }
     const intent = inferPromptIntent(trimmed);
     if (intent === "run") {
       if (runtime.activeExecution || runtime.queueDrainPromise || runtime.pendingRunProposal) {