@sean.holung/minicode 0.3.2 → 0.3.3

package/dist/src/shared/graph-styles.js

@@ -0,0 +1,119 @@
+// graph-styles.ts — Pure style definitions for the Cytoscape graph.
+// Extracted so they can be tested without browser globals.
+export const KIND_COLORS = {
+    function: { border: '#7aa2f7', bg: 'rgba(122,162,247,0.15)' },
+    class: { border: '#bb9af7', bg: 'rgba(187,154,247,0.15)' },
+    interface: { border: '#2ac3de', bg: 'rgba(42,195,222,0.15)' },
+    type: { border: '#e0af68', bg: 'rgba(224,175,104,0.15)' },
+    variable: { border: '#9ece6a', bg: 'rgba(158,206,106,0.15)' },
+    method: { border: '#7dcfff', bg: 'rgba(125,207,255,0.15)' },
+};
+export const EDGE_STYLES = {
+    calls: { lineStyle: 'solid', opacity: 0.5, color: '#565f89', width: 1 },
+    imports: { lineStyle: 'dashed', opacity: 0.4, color: '#565f89', width: 1 },
+    extends: { lineStyle: 'solid', opacity: 0.7, color: '#bb9af7', width: 2 },
+    implements: { lineStyle: 'dashed', opacity: 0.6, color: '#2ac3de', width: 1.5 },
+    references: { lineStyle: 'dotted', opacity: 0.3, color: '#565f89', width: 1 },
+};
+export function buildStylesheet() {
+    const styles = [
+        {
+            selector: 'node',
+            style: {
+                'label': 'data(label)',
+                'font-size': 11,
+                'color': '#c0caf5',
+                'text-valign': 'bottom',
+                'text-halign': 'center',
+                'text-margin-y': 5,
+                'width': 20,
+                'height': 20,
+                'shape': 'roundrectangle',
+                'border-width': 1.5,
+                'border-color': '#565f89',
+                'background-color': 'rgba(34,35,54,0.8)',
+                'font-family': "'JetBrains Mono', monospace",
+                'text-wrap': 'none',
+            },
+        },
+        {
+            selector: 'edge',
+            style: {
+                'width': 1,
+                'line-color': '#565f89',
+                'target-arrow-color': '#565f89',
+                'target-arrow-shape': 'triangle',
+                'arrow-scale': 0.6,
+                'curve-style': 'bezier',
+                'opacity': 0.4,
+            },
+        },
+    ];
+    for (const [kind, colors] of Object.entries(KIND_COLORS)) {
+        styles.push({
+            selector: `node.${kind}`,
+            style: {
+                'color': colors.border,
+                'border-color': colors.border,
+                'background-color': colors.bg,
+            },
+        });
+    }
+    for (const [kind, s] of Object.entries(EDGE_STYLES)) {
+        styles.push({
+            selector: `edge.${kind}`,
+            style: {
+                'line-style': s.lineStyle,
+                'line-color': s.color,
+                'target-arrow-color': s.color,
+                'opacity': s.opacity,
+                'width': s.width,
+            },
+        });
+    }
+    styles.push({ selector: 'node.pinned', style: { 'border-color': '#e0af68', 'border-width': 3 } });
+    styles.push({ selector: 'node.faded', style: { 'opacity': 0.15 } });
+    styles.push({ selector: 'edge.faded', style: { 'opacity': 0.05 } });
+    styles.push({ selector: 'node.highlighted', style: { 'border-width': 2.5, 'z-index': 10 } });
+    styles.push({ selector: 'edge.highlighted', style: { 'opacity': 0.9, 'width': 2, 'z-index': 10 } });
+    styles.push({
+        selector: 'node.analysis-flagged',
+        style: {
+            'border-style': 'double',
+            'border-width': 3,
+            'overlay-color': '#7dcfff',
+            'overlay-opacity': 0.05,
+        },
+    });
+    styles.push({
+        selector: 'node.analysis-selected',
+        style: {
+            'border-color': '#f7768e',
+            'border-width': 4,
+            'background-color': 'rgba(247,118,142,0.18)',
+            'z-index': 30,
+        },
+    });
+    styles.push({
+        selector: 'edge.analysis-flagged',
+        style: {
+            'opacity': 0.55,
+            'width': 1.75,
+        },
+    });
+    styles.push({
+        selector: 'edge.analysis-selected',
+        style: {
+            'line-color': '#f7768e',
+            'target-arrow-color': '#f7768e',
+            'opacity': 0.95,
+            'width': 3,
+            'z-index': 30,
+        },
+    });
+    styles.push({ selector: 'node.agent-pulse', style: { 'border-color': '#ff9e64', 'border-width': 4, 'background-color': 'rgba(255,158,100,0.25)' } });
+    styles.push({ selector: 'node.search-match', style: { 'border-color': '#e0af68', 'border-width': 2.5 } });
+    styles.push({ selector: 'node.expanded', style: { 'border-width': 2.5 } });
+    styles.push({ selector: 'node.hover-target', style: { 'border-width': 3, 'width': 24, 'height': 24, 'overlay-color': '#c0caf5', 'overlay-opacity': 0.08, 'z-index': 20 } });
+    return styles;
+}

package/dist/src/tools/find-path.js

@@ -0,0 +1,75 @@
+import { expectNonEmptyString, expectOptionalNumber } from "@minicode/agent-sdk";
+import { getSymbolDisplayName } from "../indexer/symbol-names.js";
+export function createFindPathTool(projectIndex) {
+    return {
+        name: "find_path",
+        description: "Find the path between two symbols in the dependency graph, or trace a symbol back to its entry point. Use to understand execution flow and how a function gets called.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                from: {
+                    type: "string",
+                    description: "Symbol name or qualified name to start from.",
+                },
+                to: {
+                    type: "string",
+                    description: "Symbol name or qualified name to reach. If omitted, traces back to entry point(s).",
+                },
+                max_depth: {
+                    type: "number",
+                    description: "Maximum search depth. Default 10 for path finding, 20 for entry point tracing.",
+                },
+            },
+            required: ["from"],
+            additionalProperties: false,
+        },
+        execute: async (input) => {
+            const from = expectNonEmptyString(input, "from");
+            const to = typeof input.to === "string" && input.to.length > 0 ? input.to : undefined;
+            const maxDepth = expectOptionalNumber(input, "max_depth");
+            const fromSymbol = projectIndex.getSymbol(from);
+            if (!fromSymbol) {
+                return `Symbol "${from}" not found in the project index.`;
+            }
+            if (to) {
+                // Path between two symbols
+                const toSymbol = projectIndex.getSymbol(to);
+                if (!toSymbol) {
+                    return `Symbol "${to}" not found in the project index.`;
+                }
+                const path = projectIndex.findPath(from, to, maxDepth ?? 10);
+                if (path.length === 0) {
+                    return `No path found between "${from}" and "${to}".`;
+                }
+                const lines = path.map((s, i) => {
+                    const arrow = i < path.length - 1 ? " ->" : "";
+                    return `${i + 1}. [${s.kind}] ${getSymbolDisplayName(s)} (${s.filePath}:${s.startLine})${arrow}`;
+                });
+                return [
+                    `# Path from ${getSymbolDisplayName(fromSymbol)} to ${getSymbolDisplayName(toSymbol)} (${path.length} symbols)`,
+                    "",
+                    ...lines,
+                ].join("\n");
+            }
+            else {
+                // Trace to entry point(s)
+                const paths = projectIndex.findPathToEntryPoint(from, maxDepth ?? 20);
+                if (paths.length === 0) {
+                    return `No entry point paths found for "${from}". It may itself be an entry point.`;
+                }
+                const sections = paths.map((p, pi) => {
+                    const lines = p.map((s, i) => {
+                        const arrow = i < p.length - 1 ? " ->" : "";
+                        return `  ${i + 1}. [${s.kind}] ${getSymbolDisplayName(s)} (${s.filePath}:${s.startLine})${arrow}`;
+                    });
+                    return [`## Path ${pi + 1}`, ...lines].join("\n");
+                });
+                return [
+                    `# Entry point paths for ${getSymbolDisplayName(fromSymbol)} (${paths.length} path${paths.length === 1 ? "" : "s"})`,
+                    "",
+                    ...sections,
+                ].join("\n\n");
+            }
+        },
+    };
+}

package/dist/src/tools/find-references.js

@@ -1,4 +1,5 @@
 import { expectNonEmptyString, expectOptionalNumber } from "@minicode/agent-sdk";
+import { getSymbolDisplayName } from "../indexer/symbol-names.js";
 const DEFAULT_LIMIT = 50;
 export function createFindReferencesTool(projectIndex) {
     return {
@@ -36,13 +37,17 @@ export function createFindReferencesTool(projectIndex) {
                 return `No references found for "${name}".`;
             }
             const shown = refs.slice(skip, skip + limit);
-            const lines = shown.map((e) => `- ${e.from} (${e.kind})`);
+            const lines = shown.map((e) => {
+                const fromSymbol = projectIndex.getSymbol(e.from);
+                const label = fromSymbol ? getSymbolDisplayName(fromSymbol) : e.from;
+                return `- ${label} (${e.kind})`;
+            });
             const remaining = refs.length - skip - shown.length;
             const footer = remaining > 0
                 ? `\n... and ${remaining} more (use skip: ${skip + limit}, limit: ${limit} for next page)`
                 : "";
             return [
-                `# References to ${symbol.qualifiedName} (${refs.length} total)`,
+                `# References to ${getSymbolDisplayName(symbol)} (${refs.length} total)`,
                 "",
                 ...lines,
                 footer,

package/dist/src/tools/get-dependencies.js

@@ -1,4 +1,5 @@
 import { expectNonEmptyString, expectOptionalNumber } from "@minicode/agent-sdk";
+import { getSymbolDisplayName } from "../indexer/symbol-names.js";
 export function createGetDependenciesTool(projectIndex) {
     return {
         name: "get_dependencies",
@@ -38,7 +39,7 @@ export function createGetDependenciesTool(projectIndex) {
             const cone = projectIndex.getDependencyCone(name, depth);
             const shown = cone.slice(skip, skip + limit);
             const lines = shown.map((s) => {
-                const header = `${s.kind} ${s.qualifiedName}`;
+                const header = `${s.kind} ${getSymbolDisplayName(s)}`;
                 return `${header}\n  ${s.signature}`;
             });
             const remaining = cone.length - skip - shown.length;
@@ -46,7 +47,7 @@ export function createGetDependenciesTool(projectIndex) {
                 ? `\n\n... and ${remaining} more (use skip: ${skip + limit}, limit: ${limit} for next page)`
                 : "";
             return [
-                `# Dependencies of ${symbol.qualifiedName} (depth ${depth}, ${cone.length} total)`,
+                `# Dependencies of ${getSymbolDisplayName(symbol)} (depth ${depth}, ${cone.length} total)`,
                 "",
                 ...lines,
                 footer,

package/dist/src/tools/read-symbol.js

@@ -1,5 +1,6 @@
 import { readFile, stat } from "node:fs/promises";
 import { resolveWorkspacePath, validateFileReadSize, expectNonEmptyString, expectOptionalBoolean, } from "@minicode/agent-sdk";
+import { getSymbolDisplayName } from "../indexer/symbol-names.js";
 const LEADING_CONTEXT_LINES = 3;
 export function createReadSymbolTool(config, projectIndex) {
     return {
@@ -45,7 +46,7 @@ export function createReadSymbolTool(config, projectIndex) {
                     .map((line, i) => `${startLine + i}|${line}`)
                     .join("\n");
                 const parts = [
-                    `# ${symbol.qualifiedName} (${symbol.kind})`,
+                    `# ${getSymbolDisplayName(symbol)} (${symbol.kind})`,
                     `File: ${symbol.filePath}`,
                     `Lines: ${symbol.startLine}-${symbol.endLine}`,
                     "",
@@ -57,14 +58,20 @@ export function createReadSymbolTool(config, projectIndex) {
                 const usedBy = projectIndex.dependencyEdges
                     .filter((e) => e.to === symbol.qualifiedName || e.to === symbol.name)
                     .slice(0, 5)
-                    .map((e) => e.from);
+                    .map((e) => {
+                    const ref = projectIndex.getSymbol(e.from);
+                    return ref ? getSymbolDisplayName(ref) : e.from;
+                });
                 if (usedBy.length > 0) {
                     parts.push("", "## Used by", "", usedBy.map((s) => `- ${s}`).join("\n"));
                 }
                 const calls = projectIndex.dependencyEdges
                     .filter((e) => e.from === symbol.qualifiedName || e.from === symbol.name)
                     .slice(0, 5)
-                    .map((e) => e.to);
+                    .map((e) => {
+                    const dep = projectIndex.getSymbol(e.to);
+                    return dep ? getSymbolDisplayName(dep) : e.to;
+                });
                 if (calls.length > 0) {
                     parts.push("", "## Calls", "", calls.map((s) => `- ${s}`).join("\n"));
                 }
@@ -74,13 +81,13 @@ export function createReadSymbolTool(config, projectIndex) {
                 if (typeRefs.length > 0) {
                     parts.push("", "## Referenced Types", "");
                     for (const ref of typeRefs) {
-                        parts.push(`### ${ref.qualifiedName}`, ref.signature, "");
+                        parts.push(`### ${getSymbolDisplayName(ref)}`, ref.signature, "");
                     }
                 }
                 return parts.join("\n");
             }
             const sigParts = [
-                `# ${symbol.qualifiedName} (${symbol.kind})`,
+                `# ${getSymbolDisplayName(symbol)} (${symbol.kind})`,
                 `File: ${symbol.filePath}`,
                 `Lines: ${symbol.startLine}-${symbol.endLine}`,
                 "",

package/dist/src/tools/registry.js

@@ -2,6 +2,7 @@ import { ToolRegistry, createReadFileTool, createWriteFileTool, createEditFileTo
 import { createFindReferencesTool } from "./find-references.js";
 import { createGetDependenciesTool } from "./get-dependencies.js";
 import { createReadSymbolTool } from "./read-symbol.js";
+import { createFindPathTool } from "./find-path.js";
 import { createSearchCodeMapTool } from "./search-code-map.js";
 export { ToolRegistry };
 /**
@@ -27,7 +28,8 @@ export function createToolRegistry(config, projectIndex) {
         tools.splice(1, 0, createReadSymbolTool(config, projectIndex));
         tools.splice(2, 0, createFindReferencesTool(projectIndex));
         tools.splice(3, 0, createGetDependenciesTool(projectIndex));
-        tools.splice(4, 0, createSearchCodeMapTool(projectIndex));
+        tools.splice(4, 0, createFindPathTool(projectIndex));
+        tools.splice(5, 0, createSearchCodeMapTool(projectIndex));
     }
     return new ToolRegistry(tools);
 }

package/dist/src/tools/search-code-map.js

@@ -1,4 +1,5 @@
 import { expectNonEmptyString, expectOptionalNumber } from "@minicode/agent-sdk";
+import { getSymbolDisplayName, getSymbolLookupNames } from "../indexer/symbol-names.js";
 const DEFAULT_LIMIT = 30;
 function matchesPattern(text, pattern) {
     const lowerText = text.toLowerCase();
@@ -44,7 +45,8 @@ export function createSearchCodeMapTool(projectIndex) {
             const skip = Math.max(0, expectOptionalNumber(input, "skip") ?? 0);
             const symbols = [...projectIndex.symbols.values()];
             const matches = symbols.filter((sym) => {
-                if (!matchesPattern(sym.name, pattern) && !matchesPattern(sym.qualifiedName, pattern)) {
+                const lookupNames = getSymbolLookupNames(sym);
+                if (!lookupNames.some((candidate) => matchesPattern(candidate, pattern))) {
                     return false;
                 }
                 if (kind && sym.kind !== kind) {
@@ -53,7 +55,7 @@ export function createSearchCodeMapTool(projectIndex) {
                 return true;
             });
             const shown = matches.slice(skip, skip + limit);
-            const lines = shown.map((s) => `- ${s.qualifiedName} (${s.kind}) — ${s.filePath}`);
+            const lines = shown.map((s) => `- ${getSymbolDisplayName(s)} (${s.kind}) — ${s.filePath}`);
             const remaining = matches.length - skip - shown.length;
             const footer = remaining > 0
                 ? `\n... and ${remaining} more (use skip: ${skip + limit}, limit: ${limit} for next page)`

package/dist/src/ui/app.js

@@ -16,7 +16,7 @@ function AppInner({ store, onRunTurn, onCtrlC }) {
         onRunTurn(input);
     }, [onRunTurn]);
     const disabled = state.phase !== "idle" && state.phase !== "loading";
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(ActivityPane, { items: state.items }), _jsx(HeaderBar, { model: state.model, step: state.step, maxSteps: state.maxSteps, inputTokens: state.inputTokens, outputTokens: state.outputTokens, workspaceRoot: state.workspaceRoot, indexStatus: state.indexStatus }), _jsx(InputComposer, { onSubmit: handleSubmit, disabled: disabled, ...(onCtrlC && { onCtrlC }) }), state.errorMessage && (_jsx(Box, { paddingX: 1, children: _jsx(Box, { borderStyle: "single", borderColor: "red", paddingX: 1, children: _jsxs(Text, { color: "red", children: ["Error: ", state.errorMessage] }) }) }))] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(ActivityPane, { items: state.items }), _jsx(HeaderBar, { model: state.model, step: state.step, maxSteps: state.maxSteps, inputTokens: state.inputTokens, outputTokens: state.outputTokens, contextTokens: state.contextTokens, maxContextTokens: state.maxContextTokens, workspaceRoot: state.workspaceRoot, indexStatus: state.indexStatus }), _jsx(InputComposer, { onSubmit: handleSubmit, disabled: disabled, ...(onCtrlC && { onCtrlC }) }), state.errorMessage && (_jsx(Box, { paddingX: 1, children: _jsx(Box, { borderStyle: "single", borderColor: "red", paddingX: 1, children: _jsxs(Text, { color: "red", children: ["Error: ", state.errorMessage] }) }) }))] }));
 }
 export function runInkApp(store, onRunTurn, onCtrlC) {
     process.stdout.write("\x1b[2J\x1b[H");

package/dist/src/ui/cli-ink.js

@@ -1,8 +1,10 @@
 import process from "node:process";
 import { CodingAgent, createModelClient } from "@minicode/agent-sdk";
-import { formatConfigForDisplay, loadAgentConfig } from "../agent/config.js";
+import { loadAgentConfig, getConfigSetupMessage } from "../agent/config.js";
+import { handleConfigSlashCommand } from "../cli/config-slash-command.js";
 import { computeFileHashes, getWorkspaceCacheDir, loadIndex, saveIndex, } from "../indexer/cache.js";
 import { buildProjectIndex } from "../indexer/project-index.js";
+import { sortModelsAlphabetically } from "../model-utils.js";
 import { listSessions, loadSession, loadSessionByLabel, saveSession, } from "../session/session-store.js";
 import { createToolRegistry } from "../tools/registry.js";
 import { UiStore } from "./state/ui-store.js";
@@ -11,6 +13,11 @@ export async function runInkCli(verbose, initialTask) {
     const store = new UiStore();
     store.setPhase("loading");
     const config = await loadAgentConfig();
+    const setupMessage = getConfigSetupMessage(config);
+    if (setupMessage) {
+        console.error(setupMessage);
+        process.exit(2);
+    }
     const modelClient = createModelClient(config);
     let projectIndex;
     let indexStatus = "building...";
@@ -38,6 +45,7 @@ export async function runInkCli(verbose, initialTask) {
         maxSteps: config.maxSteps,
         indexStatus,
     });
+    store.setContextStatus(0, config.maxContextTokens);
     store.setPhase("idle");
     const toolRegistry = createToolRegistry(config, projectIndex);
     function createUiUpdateHandler() {
@@ -74,6 +82,9 @@ export async function runInkCli(verbose, initialTask) {
                     });
                     store.setPhase("model_wait");
                     break;
+                case "context_status":
+                    store.setContextStatus(event.contextTokens, event.maxContextTokens);
+                    break;
             }
         };
     }
@@ -122,14 +133,15 @@ export async function runInkCli(verbose, initialTask) {
         if (trimmed === "/help") {
             store.addItem({
                 type: "system",
-                content: 'Commands: "/help", "/config", "/compact", "/save [label]", "/load [label]", "/sessions", "/exit".',
+                content: 'Commands: "/help", "/config [keys|get|set|unset]", "/compact", "/reasoning [level]", "/models", "/model [name]", "/save [label]", "/load [label]", "/sessions", "/exit".',
             });
             return;
         }
-        if (trimmed === "/config") {
+        const configCommand = await handleConfigSlashCommand(trimmed, { config });
+        if (configCommand.handled) {
             store.addItem({
                 type: "system",
-                content: formatConfigForDisplay(config),
+                content: configCommand.message ?? "",
             });
             return;
         }
@@ -153,6 +165,69 @@ export async function runInkCli(verbose, initialTask) {
             }
             return;
         }
+        if (trimmed === "/reasoning" || trimmed.startsWith("/reasoning ")) {
+            const VALID_LEVELS = ["xhigh", "high", "medium", "low", "minimal", "none"];
+            const arg = trimmed.slice("/reasoning".length).trim().toLowerCase();
+            if (arg.length === 0) {
+                const current = agent.getReasoningEffort() ?? "(unset)";
+                store.addItem({
+                    type: "system",
+                    content: `Current reasoning effort: ${current}\nValid levels: ${VALID_LEVELS.join(", ")}, off`,
+                });
+                return;
+            }
+            if (arg === "off") {
+                agent.setReasoningEffort(undefined);
+                store.addItem({ type: "system", content: "Reasoning effort disabled." });
+                return;
+            }
+            if (VALID_LEVELS.includes(arg)) {
+                agent.setReasoningEffort(arg);
+                store.addItem({ type: "system", content: `Reasoning effort set to: ${arg}` });
+            }
+            else {
+                store.addItem({
+                    type: "system",
+                    content: `Invalid reasoning level "${arg}". Valid levels: ${VALID_LEVELS.join(", ")}, off`,
+                });
+            }
+            return;
+        }
+        if (trimmed === "/models") {
+            if (modelClient.listModels) {
+                store.addItem({ type: "system", content: "Fetching models..." });
+                const models = sortModelsAlphabetically(await modelClient.listModels());
+                if (models.length === 0) {
+                    store.addItem({ type: "system", content: "No models found (provider may not support listing)." });
+                }
+                else {
+                    const lines = models.map((m) => {
+                        const marker = m.id === config.model ? " (active)" : "";
+                        return `  ${m.id}${marker}`;
+                    });
+                    store.addItem({ type: "system", content: `Available models (${models.length}):\n${lines.join("\n")}` });
+                }
+            }
+            else {
+                store.addItem({ type: "system", content: "Current provider does not support listing models." });
+            }
+            return;
+        }
+        if (trimmed.startsWith("/model ")) {
+            const newModel = trimmed.slice("/model ".length).trim();
+            if (newModel.length === 0) {
+                store.addItem({ type: "system", content: `Current model: ${config.model}` });
+                return;
+            }
+            config.model = newModel;
+            store.setConfig({ model: newModel, workspaceRoot: config.workspaceRoot, maxSteps: config.maxSteps, indexStatus: "" });
+            store.addItem({ type: "system", content: `Model switched to: ${newModel}` });
+            return;
+        }
+        if (trimmed === "/model") {
+            store.addItem({ type: "system", content: `Current model: ${config.model}` });
+            return;
+        }
         if (trimmed === "/save" || trimmed.startsWith("/save ")) {
             const label = trimmed.slice("/save".length).trim() || undefined;
             try {

package/dist/src/ui/components/header-bar.js

@@ -1,6 +1,10 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from "ink";
 import { c } from "../theme.js";
-export function HeaderBar({ model, step, maxSteps, inputTokens, outputTokens, workspaceRoot, indexStatus, }) {
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "single", paddingX: 1, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, children: c.cyan("minicode") }), _jsx(Text, { children: "  " }), _jsxs(Text, { children: [c.dim("model:"), " "] }), _jsx(Text, { children: model || "—" }), _jsx(Text, { children: "  " }), _jsxs(Text, { children: [c.dim("steps:"), " "] }), _jsxs(Text, { children: [step, "/", maxSteps] }), _jsx(Text, { children: "  " }), _jsxs(Text, { children: [c.dim("tokens:"), " "] }), _jsxs(Text, { children: [inputTokens, " in / ", outputTokens, " out"] })] }), _jsxs(Box, { children: [_jsxs(Text, { children: [c.dim("cwd:"), " "] }), _jsx(Text, { children: workspaceRoot || "—" }), _jsx(Text, { children: "  " }), _jsxs(Text, { children: [c.dim("index:"), " "] }), _jsx(Text, { children: indexStatus || "—" })] })] }));
+export function HeaderBar({ model, step, maxSteps, inputTokens, outputTokens, contextTokens, maxContextTokens, workspaceRoot, indexStatus, }) {
+    const contextPct = maxContextTokens > 0
+        ? Math.min(100, Math.round((contextTokens / maxContextTokens) * 100))
+        : 0;
+    const contextColor = contextPct >= 80 ? c.red : contextPct >= 60 ? c.yellow : c.green;
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "single", paddingX: 1, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, children: c.cyan("minicode") }), _jsx(Text, { children: "  " }), _jsxs(Text, { children: [c.dim("model:"), " "] }), _jsx(Text, { children: model || "—" }), _jsx(Text, { children: "  " }), _jsxs(Text, { children: [c.dim("steps:"), " "] }), _jsxs(Text, { children: [step, "/", maxSteps] }), _jsx(Text, { children: "  " }), _jsxs(Text, { children: [c.dim("tokens:"), " "] }), _jsxs(Text, { children: [inputTokens, " in / ", outputTokens, " out"] })] }), _jsxs(Box, { children: [_jsxs(Text, { children: [c.dim("cwd:"), " "] }), _jsx(Text, { children: workspaceRoot || "—" }), _jsx(Text, { children: "  " }), _jsxs(Text, { children: [c.dim("index:"), " "] }), _jsx(Text, { children: indexStatus || "—" }), _jsx(Text, { children: "  " }), _jsxs(Text, { children: [c.dim("context:"), " "] }), _jsx(Text, { children: contextColor(`${contextPct}%`) }), _jsx(Text, { children: " " }), _jsxs(Text, { dimColor: true, children: ["(~", contextTokens.toLocaleString(), "/", maxContextTokens.toLocaleString(), ")"] })] })] }));
 }

package/dist/src/ui/state/ui-store.js

@@ -4,6 +4,8 @@ const DEFAULT_STATE = {
     maxSteps: 50,
     inputTokens: 0,
     outputTokens: 0,
+    contextTokens: 0,
+    maxContextTokens: 0,
     model: "",
     workspaceRoot: "",
     indexStatus: "",
@@ -43,6 +45,9 @@ export class UiStore {
     setTokenUsage(inputTokens, outputTokens) {
         this.update({ inputTokens, outputTokens });
     }
+    setContextStatus(contextTokens, maxContextTokens) {
+        this.update({ contextTokens, maxContextTokens });
+    }
     addItem(item) {
         this.update({
             items: [...this.state.items, item],