codemini-cli 0.1.19 → 0.2.1

package/src/core/project-index.js

@@ -0,0 +1,510 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { getFileIndexPath, getProjectIndexDir, getProjectMapPath, getProjectWorkspaceDir } from './paths.js';
+
+const SKIP_DIRS = new Set(['.git', 'node_modules', '.codemini', '.codemini-project', '.codemini-global', 'dist', 'coverage']);
+const PROJECT_MARKER_FILES = new Set([
+  'package.json',
+  'tsconfig.json',
+  'pyproject.toml',
+  'requirements.txt',
+  'go.mod',
+  'Cargo.toml',
+  'composer.json',
+  'Gemfile',
+  'pom.xml',
+  'build.gradle',
+  'build.gradle.kts',
+  'Makefile',
+  '.gitignore'
+]);
+const SOURCE_EXTENSIONS = new Set([
+  '.js', '.jsx', '.mjs', '.cjs', '.ts', '.tsx', '.py', '.go', '.c', '.h', '.cpp', '.cc', '.cxx', '.hpp', '.hh',
+  '.sh', '.bash', '.java', '.rs', '.cs', '.php', '.rb'
+]);
+const LANGUAGE_BY_EXT = {
+  '.js': 'js', '.jsx': 'jsx', '.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',
+  '.sh': 'bash', '.bash': 'bash', '.java': 'java', '.rs': 'rust', '.cs': 'csharp', '.php': 'php', '.rb': 'ruby'
+};
+
+const initCache = new Map();
+const PROJECT_CONTEXT_MAX_FILES = 6;
+
+function sha1(input) {
+  return crypto.createHash('sha1').update(String(input || '')).digest('hex');
+}
+
+function clipList(values, max = 32) {
+  return [...new Set((Array.isArray(values) ? values : []).filter(Boolean))].slice(0, max);
+}
+
+function rel(cwd, filePath) {
+  return path.relative(cwd, filePath).replace(/\\/g, '/');
+}
+
+function normalizeRelativePath(value) {
+  return String(value || '').replace(/\\/g, '/').replace(/^\.\/+/, '').replace(/^\/+/, '');
+}
+
+async function safeStat(filePath) {
+  try {
+    return await fs.stat(filePath);
+  } catch {
+    return null;
+  }
+}
+
+async function safeReadJson(filePath, fallback) {
+  try {
+    return JSON.parse(await fs.readFile(filePath, 'utf8'));
+  } catch {
+    return fallback;
+  }
+}
+
+function tokenizeQuery(text) {
+  return [...new Set(String(text || '').toLowerCase().match(/[a-z0-9_./-]+/g) || [])].filter(Boolean);
+}
+
+function trimInline(value, max = 240) {
+  const text = String(value || '').replace(/\s+/g, ' ').trim();
+  if (!text) return '';
+  if (text.length <= max) return text;
+  return `${text.slice(0, max - 3)}...`;
+}
+
+function trimMultiline(value, max = 1800) {
+  const text = String(value || '').trim();
+  if (!text) return '';
+  if (text.length <= max) return text;
+  return `${text.slice(0, max - 3).trimEnd()}...`;
+}
+
+async function writeJson(filePath, value) {
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+}
+
+function escapeRegex(value) {
+  return String(value || '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function gitignorePatternToRegex(pattern) {
+  const normalized = normalizeRelativePath(pattern);
+  let regexBody = '';
+  for (let index = 0; index < normalized.length; index += 1) {
+    const ch = normalized[index];
+    const next = normalized[index + 1];
+    if (ch === '*') {
+      if (next === '*') {
+        regexBody += '.*';
+        index += 1;
+      } else {
+        regexBody += '[^/]*';
+      }
+      continue;
+    }
+    if (ch === '?') {
+      regexBody += '[^/]';
+      continue;
+    }
+    regexBody += escapeRegex(ch);
+  }
+  return new RegExp(`^${regexBody}$`);
+}
+
+async function readGitignoreRules(cwd) {
+  try {
+    const raw = await fs.readFile(path.join(cwd, '.gitignore'), 'utf8');
+    return raw
+      .split(/\r?\n/)
+      .map((line) => line.trim())
+      .filter((line) => line && !line.startsWith('#'))
+      .map((line) => {
+        const negated = line.startsWith('!');
+        const source = negated ? line.slice(1) : line;
+        const dirOnly = source.endsWith('/');
+        const anchored = source.startsWith('/');
+        const normalized = normalizeRelativePath(dirOnly ? source.slice(0, -1) : source);
+        return {
+          negated,
+          dirOnly,
+          anchored,
+          normalized,
+          hasSlash: normalized.includes('/'),
+          regex: gitignorePatternToRegex(normalized)
+        };
+      })
+      .filter((rule) => rule.normalized);
+  } catch {
+    return [];
+  }
+}
+
+function matchesGitignoreRule(rule, relativePath, isDirectory) {
+  if (!rule || !relativePath) return false;
+  if (rule.dirOnly && !isDirectory) return false;
+  const normalizedPath = normalizeRelativePath(relativePath);
+  if (!normalizedPath) return false;
+  if (rule.anchored || rule.hasSlash) {
+    return rule.regex.test(normalizedPath);
+  }
+  return normalizedPath.split('/').some((segment) => rule.regex.test(segment));
+}
+
+function shouldIgnorePath(relativePath, isDirectory, gitignoreRules = []) {
+  const normalizedPath = normalizeRelativePath(relativePath);
+  if (!normalizedPath) return false;
+  const topName = normalizedPath.split('/')[0];
+  if (topName && SKIP_DIRS.has(topName)) return true;
+  let ignored = false;
+  for (const rule of gitignoreRules) {
+    if (!matchesGitignoreRule(rule, normalizedPath, isDirectory)) continue;
+    ignored = !rule.negated;
+  }
+  return ignored;
+}
+
+async function detectWorkspaceKind(cwd) {
+  const gitDir = await safeStat(path.join(cwd, '.git'));
+  if (gitDir?.isDirectory()) return 'project';
+  for (const marker of PROJECT_MARKER_FILES) {
+    const stat = await safeStat(path.join(cwd, marker));
+    if (stat?.isFile()) return 'project';
+  }
+  return 'directory';
+}
+
+async function findNearestProjectRoot(startDir, workspaceRoot) {
+  let current = path.resolve(startDir);
+  const root = path.resolve(workspaceRoot);
+  while (current.startsWith(root)) {
+    if ((await detectWorkspaceKind(current)) === 'project') return current;
+    if (current === root) break;
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return null;
+}
+
+async function findProjectRootFromFile(workspaceRoot, relativePath = '') {
+  const absolutePath = path.resolve(workspaceRoot, String(relativePath || '.'));
+  const stat = await safeStat(absolutePath);
+  const probeStart = stat?.isDirectory() ? absolutePath : path.dirname(absolutePath);
+  return findNearestProjectRoot(probeStart, workspaceRoot);
+}
+
+async function findNearestIndexedProjectRoot(startDir, workspaceRoot) {
+  let current = path.resolve(startDir);
+  const root = path.resolve(workspaceRoot);
+  while (current.startsWith(root)) {
+    const projectMapStat = await safeStat(getProjectMapPath(current));
+    const fileIndexStat = await safeStat(getFileIndexPath(current));
+    if (projectMapStat?.isFile() && fileIndexStat?.isFile()) return current;
+    if (current === root) break;
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return null;
+}
+
+async function walkFiles(cwd, start = cwd, out = [], gitignoreRules = []) {
+  const entries = await fs.readdir(start, { withFileTypes: true });
+  for (const entry of entries) {
+    const absolutePath = path.join(start, entry.name);
+    const relativePath = rel(cwd, absolutePath);
+    if (entry.isDirectory()) {
+      if (shouldIgnorePath(relativePath, true, gitignoreRules)) continue;
+      await walkFiles(cwd, absolutePath, out, gitignoreRules);
+      continue;
+    }
+    if (shouldIgnorePath(relativePath, false, gitignoreRules)) continue;
+    out.push(absolutePath);
+  }
+  return out;
+}
+
+function categorizeDirectory(relativeDir) {
+  const text = String(relativeDir || '').toLowerCase();
+  if (!text || text === '.') return 'root';
+  if (/(^|\/)(src|app|apps)\b/.test(text)) return 'source';
+  if (/(^|\/)(test|tests|__tests__|spec)\b/.test(text)) return 'test';
+  if (/(^|\/)(scripts|bin)\b/.test(text)) return 'script';
+  if (/(^|\/)(config|configs)\b/.test(text)) return 'config';
+  return 'other';
+}
+
+function extractMatches(regex, text, group = 1) {
+  const out = [];
+  for (const match of String(text || '').matchAll(regex)) {
+    const value = String(match[group] || '').trim();
+    if (value) out.push(value);
+  }
+  return out;
+}
+
+function buildFileEntry(relativePath, content, stat) {
+  const ext = path.extname(relativePath).toLowerCase();
+  const imports = clipList([
+    ...extractMatches(/import\s+(?:[^'"]*from\s+)?['"]([^'"]+)['"]/g, content),
+    ...extractMatches(/require\(\s*['"]([^'"]+)['"]\s*\)/g, content),
+    ...extractMatches(/\buse\s+([A-Za-z0-9_:\\]+)/g, ext === '.rs' ? content : '')
+  ]);
+  const exports = clipList([
+    ...extractMatches(/export\s+(?:async\s+)?function\s+([A-Za-z0-9_$]+)/g, content),
+    ...extractMatches(/export\s+class\s+([A-Za-z0-9_$]+)/g, content),
+    ...extractMatches(/export\s+const\s+([A-Za-z0-9_$]+)/g, content),
+    ...extractMatches(/module\.exports\s*=\s*([A-Za-z0-9_$]+)/g, content),
+    ...extractMatches(/exports\.([A-Za-z0-9_$]+)/g, content)
+  ]);
+  const functions = clipList([
+    ...extractMatches(/\bfunction\s+([A-Za-z0-9_$]+)/g, content),
+    ...extractMatches(/\bdef\s+([A-Za-z0-9_]+)/g, content),
+    ...extractMatches(/\bfunc\s+([A-Za-z0-9_]+)/g, content),
+    ...extractMatches(/\bfn\s+([A-Za-z0-9_]+)/g, content),
+    ...extractMatches(/^\s*(?:public|private|protected|internal)?\s*(?:static\s+)?[A-Za-z0-9_<>,[\]?]+\s+([A-Za-z0-9_]+)\s*\(/gm, content),
+    ...extractMatches(/^\s*function\s+([A-Za-z0-9_]+)/gm, content),
+    ...extractMatches(/^\s*def\s+([A-Za-z0-9_]+)/gm, content)
+  ]);
+  const classes = clipList([
+    ...extractMatches(/\bclass\s+([A-Za-z0-9_$]+)/g, content)
+  ]);
+  const calls = clipList([
+    ...extractMatches(/\b([A-Za-z0-9_$]+)\s*\(/g, content).filter((name) => !['if', 'for', 'while', 'switch', 'return', 'function', 'class', 'catch'].includes(name))
+  ], 64);
+
+  return {
+    file: relativePath,
+    language: LANGUAGE_BY_EXT[ext] || 'text',
+    hash: sha1(content),
+    size: Number(stat?.size || content.length || 0),
+    mtimeMs: Number(stat?.mtimeMs || 0),
+    imports,
+    exports,
+    functions,
+    classes,
+    calls
+  };
+}
+
+async function scanProject(cwd) {
+  const workspaceKind = await detectWorkspaceKind(cwd);
+  if (workspaceKind !== 'project') {
+    return {
+      workspaceKind,
+      projectMap: null,
+      fileIndex: null,
+      gitignoreRules: []
+    };
+  }
+
+  const gitignoreRules = await readGitignoreRules(cwd);
+  const allFiles = await walkFiles(cwd, cwd, [], gitignoreRules);
+  const relativeFiles = allFiles.map((filePath) => rel(cwd, filePath));
+  const sourceFiles = allFiles.filter((filePath) => SOURCE_EXTENSIONS.has(path.extname(filePath).toLowerCase()));
+
+  const packageJson = await safeReadJson(path.join(cwd, 'package.json'), null);
+  const tsconfigExists = Boolean(await safeStat(path.join(cwd, 'tsconfig.json')));
+  const sourceRoots = clipList(relativeFiles.filter((value) => /^(src|app|apps)\b/.test(value)).map((value) => value.split('/')[0]), 12);
+  const testRoots = clipList(relativeFiles.filter((value) => /^(tests|test|__tests__)\b/.test(value)).map((value) => value.split('/')[0]), 12);
+  const entryCandidates = clipList(
+    relativeFiles.filter((value) => /(^|\/)(main|index|server|app)\.(js|jsx|mjs|cjs|ts|tsx|py|go|rs|java|cs|php|rb)$/.test(value)),
+    16
+  );
+  const languages = clipList(sourceFiles.map((filePath) => LANGUAGE_BY_EXT[path.extname(filePath).toLowerCase()] || '').filter(Boolean), 16);
+  const importantFiles = clipList(
+    relativeFiles.filter((value) => ['package.json', 'tsconfig.json', 'pyproject.toml', 'go.mod', 'Cargo.toml', 'composer.json', 'Gemfile'].includes(value)),
+    16
+  );
+  const packageManagers = clipList([
+    packageJson ? 'npm' : '',
+    relativeFiles.includes('bun.lockb') ? 'bun' : '',
+    relativeFiles.includes('pnpm-lock.yaml') ? 'pnpm' : '',
+    relativeFiles.includes('yarn.lock') ? 'yarn' : ''
+  ].filter(Boolean));
+  const frameworkHints = clipList([
+    packageJson?.dependencies?.react || packageJson?.devDependencies?.react ? 'react' : '',
+    packageJson?.dependencies?.express ? 'express' : '',
+    packageJson?.dependencies?.vue ? 'vue' : '',
+    packageJson?.dependencies?.next ? 'next' : '',
+    tsconfigExists ? 'typescript' : ''
+  ].filter(Boolean));
+
+  const directories = {};
+  for (const value of relativeFiles) {
+    const dir = path.posix.dirname(value);
+    if (!dir || dir === '.') continue;
+    if (!(dir in directories)) directories[dir] = categorizeDirectory(dir);
+  }
+
+  const files = [];
+  for (const filePath of sourceFiles) {
+    const content = await fs.readFile(filePath, 'utf8');
+    const stat = await fs.stat(filePath);
+    files.push(buildFileEntry(rel(cwd, filePath), content, stat));
+  }
+
+  return {
+    workspaceKind,
+    projectMap: {
+      projectRoot: cwd,
+      workspaceKind,
+      languages,
+      packageManagers,
+      importantFiles,
+      sourceRoots,
+      testRoots,
+      entryCandidates,
+      frameworkHints,
+      directories,
+      gitignoreEnabled: gitignoreRules.length > 0,
+      updatedAt: new Date().toISOString()
+    },
+    fileIndex: {
+      updatedAt: new Date().toISOString(),
+      files
+    },
+    gitignoreRules
+  };
+}
+
+export async function initializeProjectIndex(cwd = process.cwd()) {
+  const targetRoot = (await findNearestProjectRoot(cwd, cwd)) || path.resolve(cwd);
+  const cacheKey = targetRoot;
+  if (initCache.has(cacheKey)) return initCache.get(cacheKey);
+  const promise = (async () => {
+    const workspaceDir = getProjectWorkspaceDir(cwd);
+    await fs.mkdir(workspaceDir, { recursive: true });
+    const { workspaceKind, projectMap, fileIndex } = await scanProject(targetRoot);
+    if (workspaceKind !== 'project' || !projectMap || !fileIndex) {
+      return {
+        workspaceKind,
+        projectRoot: null,
+        projectMap: null,
+        fileIndex: null,
+        summary: '',
+        skipped: true
+      };
+    }
+    await fs.mkdir(getProjectIndexDir(targetRoot), { recursive: true });
+    await writeJson(getProjectMapPath(targetRoot), projectMap);
+    await writeJson(getFileIndexPath(targetRoot), fileIndex);
+    return {
+      workspaceKind,
+      projectRoot: targetRoot,
+      projectMap,
+      fileIndex,
+      summary: `initialized ${path.basename(targetRoot) || '.'}/.codemini-project (${Array.isArray(fileIndex?.files) ? fileIndex.files.length : 0} files)`
+    };
+  })();
+  initCache.set(cacheKey, promise);
+  try {
+    return await promise;
+  } catch (error) {
+    initCache.delete(cacheKey);
+    throw error;
+  }
+}
+
+export async function refreshIndexedFile(cwd = process.cwd(), relativePath = '') {
+  if (!relativePath) return null;
+  const workspaceDir = getProjectWorkspaceDir(cwd);
+  await fs.mkdir(workspaceDir, { recursive: true });
+  const projectRoot = await findProjectRootFromFile(cwd, relativePath);
+  if (!projectRoot) return null;
+  const fileIndexPath = getFileIndexPath(projectRoot);
+  const gitignoreRules = await readGitignoreRules(projectRoot);
+  const absolutePath = path.join(cwd, relativePath);
+  const stat = await safeStat(absolutePath);
+  let action = 'updated';
+  const projectRelativePath = path.relative(projectRoot, absolutePath).replace(/\\/g, '/');
+  const current = await safeReadJson(fileIndexPath, { updatedAt: '', files: [] });
+  const files = Array.isArray(current.files) ? [...current.files] : [];
+  const index = files.findIndex((entry) => entry.file === projectRelativePath);
+
+  if (shouldIgnorePath(projectRelativePath, Boolean(stat?.isDirectory?.()), gitignoreRules)) {
+    if (index >= 0) files.splice(index, 1);
+    action = 'removed';
+  } else if (!stat || !stat.isFile()) {
+    if (index >= 0) files.splice(index, 1);
+    action = 'removed';
+  } else {
+    const ext = path.extname(relativePath).toLowerCase();
+    if (!SOURCE_EXTENSIONS.has(ext)) {
+      if (index >= 0) files.splice(index, 1);
+      action = 'removed';
+    } else {
+      const content = await fs.readFile(absolutePath, 'utf8');
+      const nextEntry = buildFileEntry(projectRelativePath, content, stat);
+      if (index >= 0) {
+        files[index] = nextEntry;
+      } else {
+        files.push(nextEntry);
+        action = 'added';
+      }
+    }
+  }
+
+  await writeJson(fileIndexPath, {
+    updatedAt: new Date().toISOString(),
+    files: files.sort((left, right) => left.file.localeCompare(right.file))
+  });
+
+  return {
+    path: projectRelativePath,
+    projectRoot,
+    action,
+    summary: `${action} ${path.basename(projectRoot) || '.'}/.codemini-project for ${projectRelativePath}`
+  };
+}
+
+export async function buildProjectContextSnippet(cwd = process.cwd(), userText = '') {
+  const indexedRoot = await findNearestIndexedProjectRoot(cwd, cwd);
+  if (!indexedRoot) return '';
+
+  const projectMap = await safeReadJson(getProjectMapPath(indexedRoot), null);
+  const fileIndex = await safeReadJson(getFileIndexPath(indexedRoot), null);
+  if (!projectMap || !Array.isArray(fileIndex?.files)) return '';
+
+  const lines = [
+    'Project Context:',
+    `- project_root: ${indexedRoot}`,
+    `- languages: ${(projectMap.languages || []).slice(0, 6).join(', ') || 'unknown'}`,
+    `- source_roots: ${(projectMap.sourceRoots || []).slice(0, 6).join(', ') || 'none'}`,
+    `- test_roots: ${(projectMap.testRoots || []).slice(0, 6).join(', ') || 'none'}`,
+    `- entry_candidates: ${(projectMap.entryCandidates || []).slice(0, 6).join(', ') || 'none'}`,
+    `- framework_hints: ${(projectMap.frameworkHints || []).slice(0, 6).join(', ') || 'none'}`
+  ];
+
+  const tokens = tokenizeQuery(userText);
+  const scored = [];
+  for (const entry of fileIndex.files) {
+    let score = 0;
+    const fileText = String(entry.file || '').toLowerCase();
+    for (const token of tokens) {
+      if (fileText.includes(token)) score += 5;
+      if ((entry.exports || []).some((value) => String(value).toLowerCase() === token)) score += 4;
+      if ((entry.functions || []).some((value) => String(value).toLowerCase() === token)) score += 4;
+      if ((entry.classes || []).some((value) => String(value).toLowerCase() === token)) score += 4;
+      if ((entry.imports || []).some((value) => String(value).toLowerCase().includes(token))) score += 1;
+    }
+    if (score > 0) scored.push({ entry, score });
+  }
+  scored.sort((left, right) => right.score - left.score || String(left.entry.file).localeCompare(String(right.entry.file)));
+  const selected = scored.slice(0, PROJECT_CONTEXT_MAX_FILES).map((item) => item.entry);
+  if (selected.length > 0) {
+    lines.push('- relevant_files:');
+    for (const entry of selected) {
+      lines.push(
+        `  - ${entry.file} :: exports=[${(entry.exports || []).slice(0, 4).join(', ')}] functions=[${(entry.functions || []).slice(0, 4).join(', ')}] classes=[${(entry.classes || []).slice(0, 4).join(', ')}]`
+      );
+    }
+  }
+
+  const snippet = trimMultiline(lines.join('\n'));
+  return snippet;
+}

package/src/core/provider/openai-compatible.js

@@ -205,6 +205,7 @@ export async function createChatCompletionStream({
   temperature = 0.2,
   tools,
   onTextDelta,
+  onToolCallDelta,
   timeoutMs = 90000,
   maxRetries = 2
 }) {
@@ -248,6 +249,14 @@ export async function createChatCompletionStream({
       if (td.function?.name) current.name = `${current.name}${td.function.name}`;
       if (td.function?.arguments) current.arguments = `${current.arguments}${td.function.arguments}`;
       toolCallsByIndex.set(idx, current);
+      if (onToolCallDelta) {
+        onToolCallDelta({
+          index: idx,
+          id: current.id || `tc-${idx + 1}`,
+          name: current.name,
+          arguments: current.arguments || '{}'
+        });
+      }
     }
   }
 

package/src/core/shell-profile.js

@@ -118,5 +118,5 @@ export function getEffectivePolicy(config) {
 
 export function getShellSystemPrompt(value) {
   const profile = getShellProfile(value);
-  return `You are CodeMini CLI working in a ${profile.label} shell environment. Prefer OpenCode-style primary tools first: use read to inspect files, grep to search file contents, glob to find files by pattern, list to inspect directories, edit to modify existing files, write to create or fully rewrite files when appropriate, patch to apply unified diffs, and run for one-shot shell commands. Treat edit as the default editing path for existing code. Internal low-level edit strategies such as target resolution, block replacement, exact text replacement, and anchored inserts are handled inside edit rather than exposed as separate tools. Use generate_diff when you need a structured preview of a proposed file change. Use start_service, list_services, get_service_status, get_service_logs, and stop_service for long-running servers or watchers. Use run only for one-shot commands that should exit on their own. For existing code files, prefer grep/read/edit and only use write with full_file_rewrite=true when a whole-file rewrite is truly intended. Avoid unnecessary tool calls.`;
+  return `You are CodeMini CLI working in a ${profile.label} shell environment. Prefer OpenCode-style primary tools first: use read to inspect files, grep to search file contents, glob to find files by pattern, list to inspect directories, edit to modify existing files, write to create or fully rewrite files when appropriate, patch to apply unified diffs, and run for one-shot shell commands like install, build, test, or other finite tasks. For structural code edits such as changing a function, method, or class, prefer the AST-first workflow: use ast_query to select the syntax node, use read_ast_node to inspect that node, then use edit with ast_target and kind=replace_block so the write stays constrained to the selected node. Fall back to plain grep/read/edit only when AST selection is not appropriate. Classify frontend, backend, database, and Docker work carefully: use run for finite commands, and use start_service, list_services, get_service_status, get_service_logs, and stop_service for long-running servers, watchers, and dev processes. Treat edit as the default editing path for existing code. Internal low-level edit strategies such as target resolution, block replacement, exact text replacement, and anchored inserts are handled inside edit rather than exposed as separate tools. Use generate_diff when you need a structured preview of a proposed file change. For existing code files, prefer grep/read/edit and only use write with full_file_rewrite=true when a whole-file rewrite is truly intended. Avoid unnecessary tool calls.`;
 }

package/src/core/shell.js

@@ -26,9 +26,129 @@ const READY_OUTPUT_PATTERNS = [
 const AUTO_STOP_GRACE_MS = 150;
 const LONG_RUNNING_STARTUP_WINDOW_MS = 1500;
 
+function normalizeCommand(command) {
+  return String(command || '').trim();
+}
+
+function matchesAny(value, patterns) {
+  return patterns.some((pattern) => pattern.test(value));
+}
+
+export function classifyCommandIntent(command) {
+  const value = normalizeCommand(command);
+
+  if (!value) {
+    return { kind: 'generic', longRunning: false };
+  }
+
+  if (
+    /\b(?:npm|pnpm|yarn|bun)\s+install\b/i.test(value) ||
+    /\b(?:npm|pnpm|yarn|bun)\s+(?:ci|i|add)\b/i.test(value) ||
+    /\buv\s+pip\s+install\b/i.test(value) ||
+    /\bpip\s+install\b/i.test(value) ||
+    /\bcargo\s+install\b/i.test(value) ||
+    /\bbundle\s+install\b/i.test(value) ||
+    /\bcomposer\s+install\b/i.test(value)
+  ) {
+    return { kind: 'install', longRunning: false };
+  }
+
+  if (/\b(?:build|compile|bundle|pack|transpile)\b/i.test(value)) {
+    return { kind: 'build', longRunning: false };
+  }
+
+  if (
+    /\b(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?(?:test|lint|check|typecheck)\b/i.test(value) ||
+    /\b(?:jest|vitest|mocha|ava|pytest|go\s+test|cargo\s+test|dotnet\s+test)\b/i.test(value)
+  ) {
+    return { kind: 'test', longRunning: false };
+  }
+
+  const frontendServicePatterns = [
+    /\bvite\b/i,
+    /\bnext\s+dev\b/i,
+    /\bnuxt\s+dev\b/i,
+    /\bastro\s+dev\b/i,
+    /\bremix\s+dev\b/i,
+    /\bsvelte-kit\s+dev\b/i,
+    /\bwebpack\s+serve\b/i,
+    /\bvue-cli-service\s+serve\b/i,
+    /\breact-scripts\s+start\b/i,
+    /\bstorybook\b/i,
+    /\b(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?(?:dev|start|serve|preview)\b.*\b(?:client|frontend|front-end|web|ui)\b/i,
+    /\b(?:client|frontend|front-end|web|ui)\b.*\b(?:dev|start|serve|preview)\b/i
+  ];
+  if (matchesAny(value, frontendServicePatterns)) {
+    return { kind: 'frontend-service', longRunning: true };
+  }
+
+  const backendServicePatterns = [
+    /\bpython\s+-m\s+http\.server\b/i,
+    /\buvicorn\b/i,
+    /\bgunicorn\b/i,
+    /\bflask\s+run\b/i,
+    /\bdjango\s+runserver\b/i,
+    /\brails\s+(?:s|server)\b/i,
+    /\bmvn(?:w)?\s+spring-boot:run\b/i,
+    /\bgradle(?:w)?\s+bootRun\b/i,
+    /\bgradle(?:w)?\s+run\b/i,
+    /\bjava\b.*\bserver\b/i,
+    /\bdotnet\s+run\b/i,
+    /\bgo\s+run\b.*\b(server|cmd\/server|main\.go)\b/i,
+    /\bnest\s+start\b/i,
+    /\bnodemon\b/i,
+    /\bts-node-dev\b/i,
+    /\bair\b/i,
+    /\bphp\s+artisan\s+serve\b/i,
+    /\bsymfony\s+server:start\b/i,
+    /\b(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?(?:dev|start|serve|preview)\b.*\b(?:server|api|backend)\b/i,
+    /\b(?:server|api|backend)\b.*\b(?:dev|start|serve|preview)\b/i
+  ];
+  if (matchesAny(value, backendServicePatterns)) {
+    return { kind: 'backend-service', longRunning: true };
+  }
+
+  const databaseServicePatterns = [
+    /\bpostgres(?:ql)?\b/i,
+    /\bmysql\b/i,
+    /\bmariadb\b/i,
+    /\bmongod\b/i,
+    /\bredis-server\b/i,
+    /\b(?:docker|docker-compose|docker compose)\s+.*\b(?:db|database|postgres|mysql|mongo|redis)\b/i,
+    /\b(?:db|database|postgres|mysql|mongo|redis)\b.*\b(?:start|up|serve|run)\b/i
+  ];
+  if (matchesAny(value, databaseServicePatterns)) {
+    return { kind: 'database-service', longRunning: true };
+  }
+
+  const dockerServicePatterns = [
+    /\bdocker\s+compose\s+up\b/i,
+    /\bdocker-compose\s+up\b/i,
+    /\bdocker\s+run\b/i,
+    /\bdocker\s+start\b/i
+  ];
+  if (matchesAny(value, dockerServicePatterns)) {
+    return { kind: 'docker-service', longRunning: true };
+  }
+
+  if (
+    /\b(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?(?:dev|start|serve|preview|watch)\b/i.test(value) ||
+    /\b(?:vite|serve)\b/i.test(value) ||
+    /\b(?:watch|serve|server|dev|preview)\b/i.test(value)
+  ) {
+    return { kind: 'service', longRunning: true };
+  }
+
+  if (/\b(?:watch|serve|server|dev|preview)\b/i.test(value)) {
+    return { kind: 'service', longRunning: true };
+  }
+
+  return { kind: 'generic', longRunning: false };
+}
+
 export function isLikelyLongRunningCommand(command) {
-  const value = String(command || '');
-  return LONG_RUNNING_COMMAND_RE.test(value) || GENERIC_LONG_RUNNING_HINT_RE.test(value);
+  const { longRunning } = classifyCommandIntent(command);
+  return longRunning || LONG_RUNNING_COMMAND_RE.test(normalizeCommand(command)) || GENERIC_LONG_RUNNING_HINT_RE.test(normalizeCommand(command));
 }
 
 export function hasReadyOutput(text) {

package/src/core/task-store.js

@@ -1,14 +1,15 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { getProjectLegacyTasksFilePath, getProjectTasksDir } from './paths.js';
 
 function legacyTasksFilePath(cwd = process.cwd()) {
-  return path.join(cwd, '.coder', 'tasks.json');
+  return getProjectLegacyTasksFilePath(cwd);
 }
 
 function tasksFilePath(cwd = process.cwd(), sessionId = '') {
   const sid = String(sessionId || '').trim();
   if (!sid) return legacyTasksFilePath(cwd);
-  return path.join(cwd, '.coder', 'tasks', `${sid}.json`);
+  return path.join(getProjectTasksDir(cwd), `${sid}.json`);
 }
 
 async function ensureDir(filePath) {