codemini-cli 0.2.0 → 0.2.1

package/src/core/tools.js

@@ -13,8 +13,10 @@ import {
   terminateChild
 } from './shell.js';
 import { evaluateCommandPolicy } from './command-policy.js';
+import { queryAst, readAstNode, resolveAstTarget } from './ast.js';
+import { initializeProjectIndex, refreshIndexedFile } from './project-index.js';
 
-const SKIP_DIRS = new Set(['.git', 'node_modules', '.coder', '.codemini-cli', 'dist', 'coverage']);
+const SKIP_DIRS = new Set(['.git', 'node_modules', '.codemini', '.codemini-global', 'dist', 'coverage']);
 const TEXT_EXTENSIONS = new Set([
   '.js',
   '.jsx',
@@ -1525,11 +1527,13 @@ function normalizeEditTargetArgs(args = {}) {
     }
     return {
       file,
+      ast_target: normalizedEdit.ast_target ?? args?.ast_target,
       edit: normalizedEdit
     };
   }
   return {
     file,
+    ast_target: args?.ast_target,
     edit: {
       kind: args?.kind,
       target: args?.target,
@@ -1545,6 +1549,7 @@ function normalizeEditTargetArgs(args = {}) {
 async function editTarget(root, args) {
   const normalized = normalizeEditTargetArgs(args);
   const file = normalized.file;
+  const astTarget = normalized.ast_target;
   const edit = normalized.edit || {};
   let kind = String(edit.kind || '').trim();
   const hasContent = edit.new_content != null || edit.content != null;
@@ -1561,6 +1566,19 @@ async function editTarget(root, args) {
     }
   }
   if (!file || !kind) throw new Error('edit requires file and edit.kind');
+  if (astTarget) {
+    if (kind !== 'replace_block') {
+      throw new Error('AST-scoped edit only supports replace_block');
+    }
+    const resolved = await resolveAstTarget(root, file, astTarget);
+    const beforeContent = resolved.content;
+    const node = resolved.node;
+    const afterContent = `${beforeContent.slice(0, node.startIndex)}${edit.new_content || ''}${beforeContent.slice(node.endIndex)}`;
+    await fs.writeFile(resolved.absolutePath, afterContent, 'utf8');
+    resolved.tree.delete();
+    resolved.parser.delete();
+    return editResult(file, 'replace_block', beforeContent, afterContent, node.startPosition.row + 1);
+  }
   if (kind === 'replace_block') {
     const resolvedTarget =
       edit.target ||
@@ -1614,7 +1632,85 @@ async function editTarget(root, args) {
   throw new Error(`edit does not support kind: ${kind}`);
 }
 
-export function getBuiltinTools({ workspaceRoot = process.cwd(), config }) {
+export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSystemEvent }) {
+  const emitSystemTool = (event) => {
+    if (typeof onSystemEvent === 'function' && event) onSystemEvent(event);
+  };
+  const astSelectionCache = new Map();
+  let lastAstTarget = null;
+  const rememberAstSelection = (filePath, astTarget) => {
+    const key = String(filePath || '').trim();
+    if (!key || !astTarget) return;
+    lastAstTarget = astTarget;
+    astSelectionCache.set(key, astTarget);
+  };
+  const hasExplicitBlockHints = (args = {}) =>
+    Boolean(
+      args?.ast_target ||
+        args?.symbol ||
+        args?.line ||
+        args?.target ||
+        args?.edit?.ast_target ||
+        args?.edit?.symbol ||
+        args?.edit?.line ||
+        args?.edit?.target
+    );
+  const resolveCachedAstTarget = (args = {}, { requireAstScope = false } = {}) => {
+    const file = String(args?.path || args?.file || args?.ast_target?.path || '').trim();
+    if (args?.ast_target) return args.ast_target;
+    if (file) {
+      if (requireAstScope && hasExplicitBlockHints(args)) return null;
+      return astSelectionCache.get(file) || lastAstTarget || null;
+    }
+    return lastAstTarget || null;
+  };
+  const ensureProjectIndex = async () => {
+    const eventId = `project-index:${Date.now()}`;
+    const name = 'project_index(.codemini-project/project-map.json,.codemini-project/file-index.json)';
+    try {
+      const result = await initializeProjectIndex(workspaceRoot);
+      if (result?.skipped || !result?.summary) {
+        return result;
+      }
+      emitSystemTool({ type: 'system_tool:end', id: eventId, name, summary: result?.summary });
+      return result;
+    } catch (error) {
+      emitSystemTool({
+        type: 'system_tool:error',
+        id: eventId,
+        name,
+        summary: error instanceof Error ? error.message : String(error)
+      });
+      return null;
+    }
+  };
+  const refreshProjectFile = async (filePath) => {
+    const relativePath = String(filePath || '').trim();
+    if (!relativePath) return null;
+    const eventId = `file-index:${relativePath}:${Date.now()}`;
+    const name = `file_index(${relativePath})`;
+    try {
+      const result = await refreshIndexedFile(workspaceRoot, relativePath);
+      if (!result?.summary) {
+        return result;
+      }
+      emitSystemTool({
+        type: 'system_tool:end',
+        id: eventId,
+        name,
+        summary: result?.summary || `updated .codemini-project for ${relativePath}`
+      });
+      return result;
+    } catch (error) {
+      emitSystemTool({
+        type: 'system_tool:error',
+        id: eventId,
+        name,
+        summary: error instanceof Error ? error.message : String(error)
+      });
+      return null;
+    }
+  };
   const definitions = [
     {
       type: 'function',
@@ -1693,7 +1789,7 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config }) {
       function: {
         name: 'edit',
         description:
-          'Preferred edit tool for existing files. Accepts natural forms such as file + new_content for whole-file rewrites, file + symbol/line + new_content for block edits, file + old_text + new_text for exact replacements, and file + anchor_text + content for anchored inserts. A nested edit object is also supported.',
+          'Preferred edit tool for existing files. Accepts natural forms such as file + new_content for whole-file rewrites, file + symbol/line + new_content for block edits, file + old_text + new_text for exact replacements, and file + anchor_text + content for anchored inserts. When ast_target is provided, only replace_block is allowed and the write is constrained to that exact syntax node. If a file has just been selected via ast_query, the cached ast_target may be reused when omitted.',
         parameters: {
           type: 'object',
           properties: {
@@ -1707,6 +1803,7 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config }) {
             position: { type: 'string' },
             kind: { type: 'string' },
             target: { type: 'object' },
+            ast_target: { type: 'object' },
             symbol: { type: 'string' },
             line: { type: 'number' },
             edit: { type: 'object' },
@@ -1715,6 +1812,42 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config }) {
         }
       }
     },
+    {
+      type: 'function',
+      function: {
+        name: 'ast_query',
+        description:
+          'Run a Tree-sitter query against a code file and return explicit ast_target objects that can be passed into read_ast_node or edit for node-scoped changes. Prefer the returned ast_target verbatim in the next read_ast_node or edit call.',
+        parameters: {
+          type: 'object',
+          properties: {
+            path: { type: 'string' },
+            language: { type: 'string' },
+            query: { type: 'string' },
+            capture_name: { type: 'string' },
+            max_results: { type: 'number' }
+          },
+          required: ['path', 'query']
+        }
+      }
+    },
+    {
+      type: 'function',
+      function: {
+        name: 'read_ast_node',
+        description:
+          'Read the current source and compact structural context for a previously selected AST node using ast_target. If omitted, the most recent ast_query selection for the same file may be reused.',
+        parameters: {
+          type: 'object',
+          properties: {
+            path: { type: 'string' },
+            language: { type: 'string' },
+            ast_target: { type: 'object' }
+          },
+          required: ['path', 'ast_target']
+        }
+      }
+    },
     {
       type: 'function',
       function: {
@@ -1876,10 +2009,44 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config }) {
     grep: (args) => grep(workspaceRoot, args),
     glob: (args) => glob(workspaceRoot, args),
     list: (args) => list(workspaceRoot, args),
-    edit: (args) => editTarget(workspaceRoot, args),
+    ast_query: async (args) => {
+      const result = await queryAst(workspaceRoot, args);
+      const firstTarget = result?.matches?.[0]?.ast_target;
+      if (firstTarget?.path) rememberAstSelection(firstTarget.path, firstTarget);
+      return result;
+    },
+    read_ast_node: (args) => {
+      const astTarget = resolveCachedAstTarget(args);
+      if (!astTarget) throw new Error('read_ast_node requires ast_target or a prior ast_query on the same file');
+      if (astTarget.path) rememberAstSelection(astTarget.path, astTarget);
+      return readAstNode(workspaceRoot, { ...args, ast_target: astTarget });
+    },
+    edit: async (args) => {
+      await ensureProjectIndex();
+      const normalizedKind = String(args?.edit?.kind || args?.kind || '').trim();
+      const astTarget = resolveCachedAstTarget(args, { requireAstScope: normalizedKind === 'replace_block' });
+      const result = await editTarget(workspaceRoot, astTarget ? { ...args, ast_target: astTarget } : args);
+      if (result?.path) await refreshProjectFile(result.path);
+      return result;
+    },
     generate_diff: (args) => generateDiff(workspaceRoot, args),
-    patch: (args) => applyPatch(workspaceRoot, args),
-    write: (args) => writeFile(workspaceRoot, args),
+    patch: async (args) => {
+      await ensureProjectIndex();
+      const result = await applyPatch(workspaceRoot, args);
+      if (result?.path) await refreshProjectFile(result.path);
+      if (Array.isArray(result?.files)) {
+        for (const item of result.files) {
+          if (item?.path) await refreshProjectFile(item.path);
+        }
+      }
+      return result;
+    },
+    write: async (args) => {
+      await ensureProjectIndex();
+      const result = await writeFile(workspaceRoot, args);
+      if (result?.path) await refreshProjectFile(result.path);
+      return result;
+    },
     run: (args) => runCommand(workspaceRoot, config, args),
     start_service: (args) => startService(workspaceRoot, config, args),
     list_services: () => listServices(workspaceRoot),

package/src/tui/chat-app.js

@@ -140,6 +140,10 @@ const TUI_COPY = {
       doingCodeGeneration: '正在生成代码',
       doneSkill: '已完成技能',
       doingSkill: '正在执行技能',
+      doneProjectIndex: '已初始化项目索引',
+      doingProjectIndex: '正在初始化项目索引',
+      doneFileIndex: '已刷新文件索引',
+      doingFileIndex: '正在刷新文件索引',
       toolFailed: (name) => `工具执行失败: ${name}`,
       waitingModelContinue: (detail) => `${detail}，等待模型继续`,
       waitingModelAdjust: (detail) => `${detail}，等待模型调整`
@@ -266,6 +270,10 @@ const TUI_COPY = {
       doingCodeGeneration: 'Generating code',
       doneSkill: 'Completed skill',
       doingSkill: 'Running skill',
+      doneProjectIndex: 'Project index initialized',
+      doingProjectIndex: 'Initializing project index',
+      doneFileIndex: 'File index refreshed',
+      doingFileIndex: 'Refreshing file index',
       toolFailed: (name) => `Tool failed: ${name}`,
       waitingModelContinue: (detail) => `${detail}, waiting for model to continue`,
       waitingModelAdjust: (detail) => `${detail}, waiting for model to adjust`
@@ -431,6 +439,12 @@ function getActivityDisplayParts(activity) {
       secondary: `(${activity?.name || 'unknown'})`
     };
   }
+  if ((activity?.type || 'tool') === 'system_tool') {
+    return {
+      primary: 'Index',
+      secondary: parsed.target ? `(${parsed.target})` : parsed.base ? `(${parsed.base})` : ''
+    };
+  }
   const labels = {
     read: 'Read',
     edit: 'Edit',
@@ -457,6 +471,21 @@ function getActivityDisplayParts(activity) {
 
 function describeToolActivity(name, copy, { done = false, blocked = false } = {}) {
   const parsed = parseToolDisplayName(name);
+  if (parsed.base === 'project_index') {
+    return blocked
+      ? `${copy.toolActivity.blocked}: project index`
+      : done
+        ? copy.toolActivity.doneProjectIndex
+        : copy.toolActivity.doingProjectIndex;
+  }
+  if (parsed.base === 'file_index') {
+    const safeTarget = trimText(parsed.target || '.codemini-project/file-index.json', 72);
+    return blocked
+      ? `${copy.toolActivity.blocked}: ${safeTarget}`
+      : done
+        ? `${copy.toolActivity.doneFileIndex}: ${safeTarget}`
+        : `${copy.toolActivity.doingFileIndex}: ${safeTarget}`;
+  }
   if (parsed.base === 'run' || parsed.base === 'start_service') {
     const intent = classifyCommandIntent(parsed.target);
     const target = parsed.target || intent.kind || 'command';
@@ -765,8 +794,11 @@ function PlanStrip({ planState, copy }) {
   );
 }
 
-function Header({ sessionId, model, shellName }) {
+function Header({ sessionId, model, shellName, safeMode = true }) {
   const shortSession = String(sessionId || '').slice(-12) || '-';
+  const modeValue = safeMode ? 'SAFE' : 'OPEN';
+  const modeColor = safeMode ? 'greenBright' : 'redBright';
+  const modeTextColor = safeMode ? 'black' : 'white';
   return h(
     Box,
     { width: '100%', justifyContent: 'center', marginTop: 1, marginBottom: 2 },
@@ -781,12 +813,6 @@ function Header({ sessionId, model, shellName }) {
         alignItems: 'center',
         minWidth: 88
       },
-      h(
-        Box,
-        { width: '100%', justifyContent: 'space-between', marginBottom: 1 },
-        h(Text, { color: 'cyan' }, 'CLI'),
-        h(Text, { color: 'greenBright' }, 'SAFE')
-      ),
       ...BANNER.map((line, idx) =>
         h(
           Box,
@@ -801,8 +827,9 @@ function Header({ sessionId, model, shellName }) {
         Box,
         { flexDirection: 'row', justifyContent: 'center' },
         h(StatusPill, { label: 'MODEL', value: model, color: 'cyanBright', textColor: 'black' }),
-        h(StatusPill, { label: 'SHELL', value: shellName || 'powershell', color: 'greenBright', textColor: 'black' }),
-        h(StatusPill, { label: 'SESSION', value: shortSession, color: 'magentaBright', textColor: 'black' })
+        h(StatusPill, { label: 'SHELL', value: shellName || 'powershell', color: 'yellowBright', textColor: 'black' }),
+        h(StatusPill, { label: 'SESSION', value: shortSession, color: 'magentaBright', textColor: 'black' }),
+        h(StatusPill, { label: 'MODE', value: modeValue, color: modeColor, textColor: modeTextColor })
       )
     )
   );
@@ -1498,10 +1525,12 @@ function buildMessageRows(msg, showToolDetails, contentWidth = 72, copy) {
   };
 
   if (Array.isArray(msg?.segments) && msg.segments.length > 0) {
-    const totalTools = msg.segments.filter((segment) => segment.type === 'tool' || segment.type === 'skill').length;
+    const totalTools = msg.segments.filter(
+      (segment) => segment.type === 'tool' || segment.type === 'skill' || segment.type === 'system_tool'
+    ).length;
     let toolIndex = 0;
     for (const segment of msg.segments) {
-      if (segment.type === 'tool' || segment.type === 'skill') {
+      if (segment.type === 'tool' || segment.type === 'skill' || segment.type === 'system_tool') {
         pushActivityRows(segment, toolIndex, totalTools);
         toolIndex += 1;
       } else {
@@ -1548,6 +1577,10 @@ function renderMessageRow(msg, row, idx, loaderTick) {
         ? row.status === 'error'
           ? 'redBright'
           : 'cyanBright'
+        : activity.type === 'system_tool'
+          ? row.status === 'error' || row.status === 'blocked'
+            ? 'redBright'
+            : 'blueBright'
         : row.status === 'error' || row.status === 'blocked'
           ? 'redBright'
           : 'cyanBright';
@@ -2017,7 +2050,7 @@ function makeIdleStatus(copy, snapshot, variant = 'ready') {
   );
 }
 
-export function ChatApp({ runtime, sessionId, model, language = 'zh', shellName = 'powershell', version = '' }) {
+export function ChatApp({ runtime, sessionId, model, language = 'zh', shellName = 'powershell', version = '', safeMode = true }) {
   const copy = getCopy(language);
   const stdoutCols = Number(process.stdout?.columns || 120);
   const [inputValue, setInputValue] = useState('');
@@ -2060,6 +2093,23 @@ export function ChatApp({ runtime, sessionId, model, language = 'zh', shellName
   const messagesRef = useRef([]);
   const pendingQueueRef = useRef([]);
   const deltaBufferRef = useRef('');
+
+  useEffect(() => {
+    const rawStartupActivities = runtime.consumeStartupEvents?.();
+    const startupActivities = Array.isArray(rawStartupActivities) ? rawStartupActivities : [];
+    if (startupActivities.length === 0) return;
+    setMessages((prev) => [
+      ...prev,
+      {
+        id: nextId(),
+        label: 'system',
+        text: '',
+        color: 'yellowBright',
+        toolCalls: startupActivities,
+        segments: startupActivities
+      }
+    ]);
+  }, [runtime]);
   const deltaFlushTimerRef = useRef(null);
   const escSeqRef = useRef('');
   const planTextBufferRef = useRef('');
@@ -2582,6 +2632,54 @@ export function ChatApp({ runtime, sessionId, model, language = 'zh', shellName
             arguments: event.arguments
           });
         }
+        if (event?.type === 'system_tool:start') {
+          ensureActiveAssistant();
+          const detail = describeToolActivity(event.name, copy);
+          setRuntimeStatus(makeStatus(copy.runtime.toolRunning, detail, 'blueBright'));
+          setInputStage('tooling');
+          updateActivityStatusOnActiveAssistant({
+            type: 'system_tool',
+            id: event.id,
+            name: event.name,
+            status: 'running',
+            summary: event.summary
+          });
+          setActiveAssistantMeta({ loading: true, phase: 'tooling', liveStatus: detail });
+        }
+        if (event?.type === 'system_tool:end') {
+          const detail = describeToolActivity(event.name, copy, { done: true });
+          setRuntimeStatus(makeStatus(copy.runtime.toolCompleted, copy.toolActivity.waitingModelContinue(detail), 'blueBright'));
+          setInputStage('thinking');
+          updateActivityStatusOnActiveAssistant({
+            type: 'system_tool',
+            id: event.id,
+            name: event.name,
+            status: 'done',
+            summary: event.summary
+          });
+          setActiveAssistantMeta({
+            loading: true,
+            phase: 'thinking',
+            liveStatus: copy.toolActivity.waitingModelContinue(detail)
+          });
+        }
+        if (event?.type === 'system_tool:error') {
+          const detail = copy.toolActivity.toolFailed(event.name);
+          setRuntimeStatus(makeStatus(copy.runtime.toolFailed, event.summary || detail, 'redBright'));
+          setInputStage('thinking');
+          updateActivityStatusOnActiveAssistant({
+            type: 'system_tool',
+            id: event.id,
+            name: event.name,
+            status: 'error',
+            summary: event.summary
+          });
+          setActiveAssistantMeta({
+            loading: true,
+            phase: 'thinking',
+            liveStatus: copy.toolActivity.waitingModelAdjust(detail)
+          });
+        }
         if (event?.type === 'skill:start') {
           ensureActiveAssistant();
           const detail = describeSkillActivity(event.name, copy);
@@ -3087,7 +3185,7 @@ export function ChatApp({ runtime, sessionId, model, language = 'zh', shellName
   return h(
     Box,
     { flexDirection: 'column' },
-    h(Header, { sessionId: displaySessionId, model: displayModel, shellName }),
+    h(Header, { sessionId: displaySessionId, model: displayModel, shellName, safeMode }),
     h(MessageList, {
       messages: visibleMessages,
       loaderTick,