codemini-cli 0.1.19 → 0.2.1

package/README.md

@@ -26,6 +26,7 @@ It is designed for teams that want a coding assistant that feels practical, cont
 - Configurable reply language through `ui.reply_language` (`zh` / `en`)
 - Richer slash completion with priority sorting, inline descriptions, and left/right paging
 - Structured code tools for small models: `grep`, `read`, `edit`
+- Tree-sitter AST tools for small models: `ast_query`, `read_ast_node`, node-scoped `edit`
 - More conservative `plan auto` acceptance checks with reviewer/tester goal checklists
 - Tone presets through `soul`, without changing plans or code behavior
 - Example soul presets include `professional`, `playful`, `anime`, `pirate`, `caveman`, and `ceo`
@@ -67,6 +68,8 @@ codemini skill list|install|enable|disable|inspect|reindex
 - Ambiguous feature requests can pause for lightweight brainstorming first, and `/brainstorm <question>` gives an explicit way to compare options before coding
 - `plan auto` now turns the original goal into an acceptance checklist, uses a lighter chain only for truly tiny tasks, and treats unmet checklist items as failure signals
 - Structured code tools reduce shell-noise for small models by preferring `grep/read -> edit`
+- Tree-sitter-aware code tools support `grep/read -> ast_query/read_ast_node -> edit(ast_target)` for function/class-level edits with explicit node range limits
+- Current Tree-sitter language support includes JavaScript/JSX, TypeScript/TSX, Python, Go, C, C++, Bash, Java, Rust, C#, PHP, and Ruby
 
 ### Skill Loading
 
@@ -74,16 +77,15 @@ CodeMini CLI loads skills from these locations:
 
 - Bundled repo skills: `skills/<name>/SKILL.md`
 - Installed global skills: `<base-config-dir>/skills/<name>/SKILL.md`
-- Project-scoped legacy skills: `.coder/skills/<name>/SKILL.md`
+- Project-scoped skills: `.codemini/skills/<name>/SKILL.md`
 
 The base config directory is resolved in this order:
 
-- `CODEMINI_CONFIG_DIR`
-- `COMPANY_CODER_CONFIG_DIR`
-- Windows: `%APPDATA%\\codemini-cli\\`
-- macOS: `~/Library/Preferences/codemini-cli`
-- Linux/XDG: `$XDG_CONFIG_HOME/codemini-cli`
-- Fallback in restricted environments: `.codemini-cli/`
+- `CODEMINI_GLOBAL_DIR`
+- Windows: `%APPDATA%\\codemini-global\\`
+- macOS: `~/Library/Preferences/codemini-global`
+- Linux/XDG: `$XDG_CONFIG_HOME/codemini-global`
+- Fallback in restricted environments: `.codemini-global/`
 
 ### Brainstorming
 
@@ -104,9 +106,19 @@ For information on how to perform a release, please see the [Release Checklist](
 
 ### Data Layout
 
-- Project-scoped workspace data: `.coder/`
-- Global user data on Windows: `%APPDATA%\\codemini-cli\\`
-- Restricted-environment fallback: `.codemini-cli/`
+- Project-scoped workspace data: `.codemini/`
+- Global user data on Windows: `%APPDATA%\\codemini-global\\`
+- Restricted-environment fallback: `.codemini-global/`
+
+### Project Index
+
+CodeMini CLI now maintains a lightweight project index inside `.codemini-project/`:
+
+- `project-map.json` for project skeleton metadata such as languages, important files, source roots, test roots, and entry candidates
+- `file-index.json` for per-file symbols, imports, exports, functions, classes, and basic call hints
+
+The index is initialized once when entering a project and refreshed incrementally after code edits, writes, and patches. Session data stays in `.codemini/`; project structure lives in `.codemini-project/`. The index is intentionally lightweight and fact-based rather than an LLM-generated project report.
+At request time, CodeMini injects a short project-context summary from this index into the model prompt instead of dumping the full index.
 
 ### Positioning
 
@@ -141,6 +153,7 @@ CodeMini CLI 是一个为小模型工作流优化过的代码助手 CLI，重点
 - 支持通过 `ui.reply_language` 配置回复语言，当前支持 `zh` / `en`
 - slash 补全支持优先级排序、右侧简短说明和左右分页
 - 为小模型补了结构化代码工具：`grep`、`read`、`edit`
+- 为小模型补了 Tree-sitter AST 工具：`ast_query`、`read_ast_node`，以及带 node 范围限制的 `edit`
 - `plan auto` 会基于原始目标生成验收清单，并更保守地处理 reviewer/tester 结果
 - `soul` 只影响语气，不影响计划和代码行为
 - 可用的 `soul` 示例包括 `professional`、`playful`、`anime`、`pirate`、`caveman`、`ceo`
@@ -182,6 +195,8 @@ codemini skill list|install|enable|disable|inspect|reindex
 - 对于需求仍不明确的功能请求，CLI 会先偏向轻量 brainstorm；也可以显式使用 `/brainstorm <问题>` 先比较方案再决定是否编码
 - `plan auto` 会先把原始目标展开成验收清单；只有真正很小的任务才会走轻量链路；如果 reviewer 或 tester 标记了未满足或未验证的验收项，就不会按成功处理
 - 为了减少小模型被 shell 原始输出干扰，新增了 `grep/read -> edit` 这套结构化代码工具流
+- 现在也支持 `grep/read -> ast_query/read_ast_node -> edit(ast_target)` 这套 AST 工作流，适合函数级/类级精准编辑，并且能限制小模型只能修改显式选中的 node 范围
+- 当前内置的 Tree-sitter 语言支持包括 JavaScript/JSX、TypeScript/TSX、Python、Go、C、C++、Bash、Java、Rust、C#、PHP、Ruby
 
 ### Skill 加载位置
 
@@ -189,16 +204,15 @@ CodeMini CLI 会从这些位置读取 skill：
 
 - 仓库内置 skill：`skills/<name>/SKILL.md`
 - 全局已安装 skill：`<base-config-dir>/skills/<name>/SKILL.md`
-- 项目级旧式 skill：`.coder/skills/<name>/SKILL.md`
+- 项目级 skill：`.codemini/skills/<name>/SKILL.md`
 
 `base-config-dir` 的解析顺序是：
 
-- `CODEMINI_CONFIG_DIR`
-- `COMPANY_CODER_CONFIG_DIR`
-- Windows：`%APPDATA%\\codemini-cli\\`
-- macOS：`~/Library/Preferences/codemini-cli`
-- Linux / XDG：`$XDG_CONFIG_HOME/codemini-cli`
-- 受限环境回退：`.codemini-cli/`
+- `CODEMINI_GLOBAL_DIR`
+- Windows：`%APPDATA%\\codemini-global\\`
+- macOS：`~/Library/Preferences/codemini-global`
+- Linux / XDG：`$XDG_CONFIG_HOME/codemini-global`
+- 受限环境回退：`.codemini-global/`
 
 ### Brainstorm 用法
 
@@ -215,6 +229,16 @@ CodeMini CLI 会从这些位置读取 skill：
 
 ### 数据目录
 
-- 项目工作区数据：`.coder/`
-- Windows 全局用户数据：`%APPDATA%\\codemini-cli\\`
-- 受限环境回退目录：`.codemini-cli/`
+- 项目工作区数据：`.codemini/`
+- Windows 全局用户数据：`%APPDATA%\\codemini-global\\`
+- 受限环境回退目录：`.codemini-global/`
+
+### 项目索引
+
+CodeMini CLI 现在会在 `.codemini-project/` 下维护一份轻量项目索引：
+
+- `project-map.json`：记录项目骨架信息，例如语言、关键文件、源码目录、测试目录、入口候选
+- `file-index.json`：记录文件级结构信息，例如 symbols、imports、exports、functions、classes、基础 calls
+
+这份索引会在进入项目时初始化一次，在 `edit`、`write`、`patch` 后做增量刷新。`.codemini/` 继续保存会话态数据，`.codemini-project/` 保存项目结构索引。它是程序维护的轻量事实索引，不是模型生成的项目总结。
+在真正请求模型时，CodeMini 会从这份索引里裁一小段项目摘要注入 prompt，而不是把整份索引直接塞进去。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codemini-cli",
-  "version": "0.1.19",
+  "version": "0.2.1",
   "description": "Coding CLI optimized for small-model workflows and Windows PowerShell",
   "keywords": [
     "cli",
@@ -46,9 +46,11 @@
     "access": "public"
   },
   "dependencies": {
+    "@cursorless/tree-sitter-wasms": "^0.5.0",
     "ink": "^6.3.1",
     "openai": "^6.33.0",
-    "react": "^19.0.0"
+    "react": "^19.0.0",
+    "web-tree-sitter": "^0.26.7"
   },
   "license": "MIT"
 }

package/src/cli.js

@@ -4,7 +4,7 @@ import { handleConfig } from './commands/config.js';
 import { handleDoctor } from './commands/doctor.js';
 import { handleSkill } from './commands/skill.js';
 
-const VERSION = '0.1.18';
+const VERSION = '0.2.1';
 
 function printHelp() {
   console.log(`codemini ${VERSION}

package/src/commands/chat.js

@@ -99,6 +99,7 @@ export async function handleChat(args) {
       model: parsed.model || config.model.name,
       language: config.ui?.language || 'zh',
       shellName: config.shell?.default || 'powershell',
+      safeMode: config.policy?.safe_mode !== false,
       version: pkg.version
     })
   );

package/src/core/agent-loop.js

@@ -262,7 +262,7 @@ export async function runAgentLoop({
       }
 
       if (!approved) {
-        if (onEvent) onEvent({ type: 'tool:blocked', name: displayName, id: call.id });
+        if (onEvent) onEvent({ type: 'tool:blocked', name: displayName, id: call.id, arguments: args });
         const blockedMessage = {
           role: 'tool',
           tool_call_id: call.id,
@@ -274,6 +274,7 @@ export async function runAgentLoop({
             type: 'tool:result',
             name: displayName,
             id: call.id,
+            arguments: args,
             content: blockedMessage.content,
             blocked: true
           });
@@ -281,7 +282,7 @@ export async function runAgentLoop({
         continue;
       }
 
-      if (onEvent) onEvent({ type: 'tool:start', name: displayName, id: call.id });
+      if (onEvent) onEvent({ type: 'tool:start', name: displayName, id: call.id, arguments: args });
       const handler = toolHandlers[toolName];
       if (!handler) {
         throw new Error(`Unknown tool: ${call.name}`);
@@ -297,6 +298,7 @@ export async function runAgentLoop({
             type: 'tool:error',
             name: displayName,
             id: call.id,
+            arguments: args,
             durationMs,
             summary: trimInline(message, 120)
           });
@@ -312,6 +314,7 @@ export async function runAgentLoop({
             type: 'tool:result',
             name: displayName,
             id: call.id,
+            arguments: args,
             content: toolMessage.content,
             error: true
           });
@@ -324,6 +327,7 @@ export async function runAgentLoop({
           type: 'tool:end',
           name: displayName,
           id: call.id,
+          arguments: args,
           durationMs,
           summary: summarizeToolResult(toolResult)
         });
@@ -339,6 +343,7 @@ export async function runAgentLoop({
           type: 'tool:result',
           name: displayName,
           id: call.id,
+          arguments: args,
           content: toolMessage.content
         });
       }

package/src/core/ast.js

@@ -0,0 +1,310 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { createRequire } from 'node:module';
+import { Parser, Language, Query } from 'web-tree-sitter';
+
+const require = createRequire(import.meta.url);
+
+const IDENTIFIER_NODE_TYPES = new Set([
+  'identifier',
+  'property_identifier',
+  'type_identifier',
+  'word',
+  'field_identifier',
+  'name'
+]);
+const WRAPPER_NODE_TYPES = new Set([
+  'declarator',
+  'qualified_identifier',
+  'template_function',
+  'template_type'
+]);
+const LANGUAGE_ALIASES = {
+  javascript: 'js',
+  js: 'js',
+  jsx: 'js',
+  typescript: 'ts',
+  ts: 'ts',
+  tsx: 'tsx',
+  python: 'python',
+  py: 'python',
+  go: 'go',
+  c: 'c',
+  cpp: 'cpp',
+  'c++': 'cpp',
+  bash: 'bash',
+  sh: 'bash',
+  shell: 'bash',
+  java: 'java',
+  rust: 'rust',
+  rs: 'rust',
+  csharp: 'csharp',
+  'c#': 'csharp',
+  cs: 'csharp',
+  php: 'php',
+  ruby: 'ruby',
+  rb: 'ruby'
+};
+const EXTENSION_LANGUAGE_MAP = {
+  '.js': 'js',
+  '.jsx': 'js',
+  '.mjs': 'js',
+  '.cjs': 'js',
+  '.ts': 'ts',
+  '.tsx': 'tsx',
+  '.py': 'python',
+  '.go': 'go',
+  '.c': 'c',
+  '.h': 'c',
+  '.cpp': 'cpp',
+  '.cc': 'cpp',
+  '.cxx': 'cpp',
+  '.hpp': 'cpp',
+  '.hh': 'cpp',
+  '.java': 'java',
+  '.rs': 'rust',
+  '.cs': 'csharp',
+  '.php': 'php',
+  '.rb': 'ruby',
+  '.sh': 'bash',
+  '.bash': 'bash'
+};
+const LANGUAGE_WASM_PATHS = {
+  js: require.resolve('@cursorless/tree-sitter-wasms/out/tree-sitter-javascript.wasm'),
+  ts: require.resolve('@cursorless/tree-sitter-wasms/out/tree-sitter-typescript.wasm'),
+  tsx: require.resolve('@cursorless/tree-sitter-wasms/out/tree-sitter-tsx.wasm'),
+  python: require.resolve('@cursorless/tree-sitter-wasms/out/tree-sitter-python.wasm'),
+  go: require.resolve('@cursorless/tree-sitter-wasms/out/tree-sitter-go.wasm'),
+  c: require.resolve('@cursorless/tree-sitter-wasms/out/tree-sitter-c.wasm'),
+  cpp: require.resolve('@cursorless/tree-sitter-wasms/out/tree-sitter-cpp.wasm'),
+  bash: require.resolve('@cursorless/tree-sitter-wasms/out/tree-sitter-bash.wasm'),
+  java: require.resolve('@cursorless/tree-sitter-wasms/out/tree-sitter-java.wasm'),
+  rust: require.resolve('@cursorless/tree-sitter-wasms/out/tree-sitter-rust.wasm'),
+  csharp: require.resolve('@cursorless/tree-sitter-wasms/out/tree-sitter-c_sharp.wasm'),
+  php: require.resolve('@cursorless/tree-sitter-wasms/out/tree-sitter-php.wasm'),
+  ruby: require.resolve('@cursorless/tree-sitter-wasms/out/tree-sitter-ruby.wasm')
+};
+const TREE_SITTER_WASM_PATH = require.resolve('web-tree-sitter/web-tree-sitter.wasm');
+
+const parserInitPromise = Parser.init({
+  locateFile(scriptName) {
+    return scriptName === 'web-tree-sitter.wasm' ? TREE_SITTER_WASM_PATH : scriptName;
+  }
+});
+const languageCache = new Map();
+
+function sha256(input) {
+  return `sha256:${crypto.createHash('sha256').update(String(input || '')).digest('hex')}`;
+}
+
+function clipText(text, maxLen = 220) {
+  const normalized = String(text || '').replace(/\s+/g, ' ').trim();
+  if (normalized.length <= maxLen) return normalized;
+  return `${normalized.slice(0, maxLen - 3)}...`;
+}
+
+function pointFromTarget(line, column) {
+  return {
+    row: Math.max(0, Number(line || 1) - 1),
+    column: Math.max(0, Number(column || 1) - 1)
+  };
+}
+
+function pointsEqual(left, right) {
+  return left.row === right.row && left.column === right.column;
+}
+
+function summarizeNode(node) {
+  if (!node) return '';
+  const text = clipText(node.text, 96);
+  return `${node.type}${text ? `: ${text}` : ''}`;
+}
+
+function selectEditableNode(node) {
+  let current = node;
+  while (current?.parent) {
+    if (IDENTIFIER_NODE_TYPES.has(current.type)) {
+      current = current.parent;
+      continue;
+    }
+    if (current.type.endsWith('_declarator') || WRAPPER_NODE_TYPES.has(current.type)) {
+      current = current.parent;
+      continue;
+    }
+    break;
+  }
+  return current;
+}
+
+function astTargetForNode(relativePath, language, node) {
+  return {
+    path: relativePath,
+    language,
+    node_type: node.type,
+    start_line: node.startPosition.row + 1,
+    start_column: node.startPosition.column + 1,
+    end_line: node.endPosition.row + 1,
+    end_column: node.endPosition.column + 1,
+    range_hash: sha256(node.text)
+  };
+}
+
+function inferLanguage(filePath, explicitLanguage = '') {
+  const alias = LANGUAGE_ALIASES[String(explicitLanguage || '').trim().toLowerCase()];
+  if (alias) return alias;
+  const ext = path.extname(String(filePath || '')).toLowerCase();
+  const inferred = EXTENSION_LANGUAGE_MAP[ext];
+  if (!inferred) {
+    throw new Error(`No Tree-sitter language configured for file: ${filePath}`);
+  }
+  return inferred;
+}
+
+async function loadLanguage(language) {
+  await parserInitPromise;
+  if (languageCache.has(language)) return languageCache.get(language);
+  const wasmPath = LANGUAGE_WASM_PATHS[language];
+  if (!wasmPath) throw new Error(`Unsupported Tree-sitter language: ${language}`);
+  const loaded = await Language.load(wasmPath);
+  languageCache.set(language, loaded);
+  return loaded;
+}
+
+async function parseContent(content, language) {
+  const loadedLanguage = await loadLanguage(language);
+  const parser = new Parser();
+  parser.setLanguage(loadedLanguage);
+  const tree = parser.parse(content);
+  return { parser, tree, loadedLanguage };
+}
+
+async function parseFile(root, relativePath, explicitLanguage = '') {
+  const target = path.resolve(root, relativePath);
+  const content = await fs.readFile(target, 'utf8');
+  const language = inferLanguage(relativePath, explicitLanguage);
+  const parsed = await parseContent(content, language);
+  return {
+    ...parsed,
+    path: relativePath,
+    absolutePath: target,
+    content,
+    language
+  };
+}
+
+function exactNodeForTarget(rootNode, target) {
+  const start = pointFromTarget(target.start_line, target.start_column);
+  const end = pointFromTarget(target.end_line, target.end_column);
+  let current = rootNode.namedDescendantForPosition(start, end) || rootNode.descendantForPosition(start, end);
+  while (current) {
+    if (pointsEqual(current.startPosition, start) && pointsEqual(current.endPosition, end)) {
+      return current;
+    }
+    current = current.parent;
+  }
+  return null;
+}
+
+export async function queryAst(root, args) {
+  const relativePath = String(args?.path || '').trim();
+  const querySource = String(args?.query || '').trim();
+  if (!relativePath || !querySource) {
+    throw new Error('ast_query requires path and query');
+  }
+  const captureName = String(args?.capture_name || '').trim();
+  const maxResults = Math.max(1, Math.min(100, Number(args?.max_results || 12)));
+  const parsed = await parseFile(root, relativePath, args?.language);
+  const query = new Query(parsed.loadedLanguage, querySource);
+  const captures = query.captures(parsed.tree.rootNode);
+  const matches = [];
+
+  for (const capture of captures) {
+    if (captureName && capture.name !== captureName) continue;
+    const targetNode = selectEditableNode(capture.node);
+    matches.push({
+      capture: capture.name,
+      node_type: targetNode.type,
+      start_line: targetNode.startPosition.row + 1,
+      start_column: targetNode.startPosition.column + 1,
+      end_line: targetNode.endPosition.row + 1,
+      end_column: targetNode.endPosition.column + 1,
+      text: clipText(targetNode.text),
+      ast_target: astTargetForNode(relativePath, parsed.language, targetNode)
+    });
+    if (matches.length >= maxResults) break;
+  }
+
+  query.delete();
+  parsed.tree.delete();
+  parsed.parser.delete();
+
+  return {
+    path: relativePath,
+    language: parsed.language,
+    query: querySource,
+    capture_name: captureName || undefined,
+    matches,
+    truncated: captures.length > matches.length
+  };
+}
+
+export async function readAstNode(root, args) {
+  const relativePath = String(args?.path || args?.ast_target?.path || '').trim();
+  const astTarget = args?.ast_target;
+  if (!relativePath || !astTarget) throw new Error('read_ast_node requires path and ast_target');
+  const parsed = await parseFile(root, relativePath, astTarget.language || args?.language);
+  const node = exactNodeForTarget(parsed.tree.rootNode, astTarget);
+  if (!node) {
+    throw new Error('AST target no longer matches the current file');
+  }
+
+  const result = {
+    path: relativePath,
+    language: parsed.language,
+    node: {
+      node_type: node.type,
+      start_line: node.startPosition.row + 1,
+      start_column: node.startPosition.column + 1,
+      end_line: node.endPosition.row + 1,
+      end_column: node.endPosition.column + 1
+    },
+    content: node.text,
+    parent_summary: summarizeNode(node.parent),
+    child_summaries: node.namedChildren.slice(0, 8).map((child) => summarizeNode(child))
+  };
+
+  parsed.tree.delete();
+  parsed.parser.delete();
+  return result;
+}
+
+export async function resolveAstTarget(root, relativePath, astTarget) {
+  if (!astTarget || typeof astTarget !== 'object') {
+    throw new Error('ast_target is required for AST-scoped edit');
+  }
+  if (String(astTarget.path || '').trim() !== String(relativePath || '').trim()) {
+    throw new Error('ast_target path does not match edit file');
+  }
+
+  const parsed = await parseFile(root, relativePath, astTarget.language);
+  const node = exactNodeForTarget(parsed.tree.rootNode, astTarget);
+  if (!node) {
+    parsed.tree.delete();
+    parsed.parser.delete();
+    throw new Error('AST target no longer matches the current file');
+  }
+
+  const currentHash = sha256(node.text);
+  if (String(astTarget.range_hash || '') !== currentHash) {
+    parsed.tree.delete();
+    parsed.parser.delete();
+    throw new Error('ast_target range_hash mismatch; the selected node changed and is now stale');
+  }
+
+  return {
+    ...parsed,
+    node,
+    current_hash: currentHash
+  };
+}