codemini-cli 0.1.19 → 0.2.1

package/src/core/tools.js

@@ -4,6 +4,7 @@ import crypto from 'node:crypto';
 import { spawn } from 'node:child_process';
 import net from 'node:net';
 import {
+  classifyCommandIntent,
   hasReadyOutput,
   isDangerousCommand,
   isLikelyLongRunningCommand,
@@ -12,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',
@@ -793,7 +796,16 @@ async function runCommand(root, config, args) {
     throw new Error('run requires command');
   }
   if (isLikelyLongRunningCommand(command)) {
-    throw new Error('Command looks like a long-running service. Use start_service instead of run.');
+    const intent = classifyCommandIntent(command);
+    const labelMap = {
+      'frontend-service': 'frontend service',
+      'backend-service': 'backend service',
+      'database-service': 'database service',
+      'docker-service': 'Docker service',
+      service: 'long-running service'
+    };
+    const label = labelMap[intent.kind] || 'long-running service';
+    throw new Error(`Command looks like a ${label}. Use start_service instead of run.`);
   }
   if (
     !config.policy.allow_dangerous_commands &&
@@ -1515,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,
@@ -1535,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;
@@ -1551,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 ||
@@ -1604,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',
@@ -1683,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: {
@@ -1697,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' },
@@ -1705,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: {
@@ -1727,7 +1870,8 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config }) {
       type: 'function',
       function: {
         name: 'run',
-        description: 'Primary run tool. Execute a one-shot shell command in workspace. Do not use for long-running services.',
+        description:
+          'Primary run tool. Execute a one-shot shell command in workspace such as install, build, test, or other finite tasks. Do not use for long-running services or watchers.',
         parameters: {
           type: 'object',
           properties: {
@@ -1771,7 +1915,8 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config }) {
       type: 'function',
       function: {
         name: 'start_service',
-        description: 'Start a long-running local service and return a compact service handle instead of blocking on process exit.',
+        description:
+          'Start a long-running local service, such as a frontend, backend, database, or dev watcher, and return a compact service handle instead of blocking on process exit.',
         parameters: {
           type: 'object',
           properties: {
@@ -1864,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),