codemini-cli 0.5.8 → 0.5.10

package/src/core/command-loader.js

@@ -11,6 +11,8 @@ import { readSkillRegistry } from './skill-registry.js';
 
 const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
 const BUNDLED_SKILLS_DIR = path.resolve(MODULE_DIR, '..', '..', 'skills');
+const SKILL_CATALOG_FILE = 'codemini.skills.json';
+const FRONTMATTER_READ_BYTES = 16 * 1024;
 
 function parseArrayText(value) {
   const inner = value.slice(1, -1).trim();
@@ -46,6 +48,79 @@ function parseFrontmatter(raw) {
   return { metadata, content };
 }
 
+function readFrontmatterMetadata(filePath) {
+  let fd;
+  try {
+    fd = fs.openSync(filePath, 'r');
+    const buffer = Buffer.alloc(FRONTMATTER_READ_BYTES);
+    const bytesRead = fs.readSync(fd, buffer, 0, buffer.length, 0);
+    const raw = buffer.subarray(0, bytesRead).toString('utf8');
+    if (!raw.startsWith('---\n')) return {};
+    const end = raw.indexOf('\n---\n', 4);
+    if (end === -1) return {};
+    return parseFrontmatter(raw.slice(0, end + 5)).metadata;
+  } catch {
+    return {};
+  } finally {
+    if (fd !== undefined) {
+      try { fs.closeSync(fd); } catch {}
+    }
+  }
+}
+
+function readSkillCatalog(baseDir) {
+  const catalogPath = path.join(baseDir, SKILL_CATALOG_FILE);
+  try {
+    const parsed = JSON.parse(fs.readFileSync(catalogPath, 'utf8'));
+    return parsed && typeof parsed === 'object' && parsed.skills && typeof parsed.skills === 'object'
+      ? parsed.skills
+      : {};
+  } catch {
+    return {};
+  }
+}
+
+function normalizeStringArray(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => String(item || '').trim()).filter(Boolean);
+  }
+  const single = String(value || '').trim();
+  return single ? [single] : [];
+}
+
+function catalogMetadata(catalog, name) {
+  const entry = catalog?.[name];
+  if (!entry || typeof entry !== 'object') return {};
+  return {
+    ...(entry.description ? { description: String(entry.description) } : {}),
+    ...(entry.mode ? { mode: String(entry.mode) } : {}),
+    ...(entry.enabled !== undefined ? { enabled: entry.enabled !== false } : {}),
+    ...(entry.priority !== undefined ? { priority: Number(entry.priority) } : {}),
+    triggers: normalizeStringArray(entry.triggers)
+  };
+}
+
+function commandWithContent(command, parsedContent) {
+  if (parsedContent !== undefined) {
+    return { ...command, content: parsedContent };
+  }
+
+  let cached;
+  let loaded = false;
+  return Object.defineProperty({ ...command }, 'content', {
+    enumerable: true,
+    configurable: true,
+    get() {
+      if (!loaded) {
+        const raw = fs.readFileSync(command.path, 'utf8');
+        cached = parseFrontmatter(raw).content;
+        loaded = true;
+      }
+      return cached;
+    }
+  });
+}
+
 function safeEntries(dir) {
   try {
     return fs.readdirSync(dir);
@@ -104,77 +179,95 @@ function loadMarkdownCommandsFromDir(baseDir, source, out) {
 
 function loadLegacySkillsFromDir(baseDir, source, out) {
   if (!fs.existsSync(baseDir)) return;
+  const catalog = readSkillCatalog(baseDir);
   for (const entry of safeEntries(baseDir)) {
     if (!isSafeEntry(entry)) continue;
     const full = path.join(baseDir, entry);
     const stat = fs.statSync(full);
     if (!stat.isDirectory()) continue;
+    const catalogMeta = catalogMetadata(catalog, entry);
     const skillFile = path.join(full, 'SKILL.md');
     if (!fs.existsSync(skillFile)) continue;
-    const raw = fs.readFileSync(skillFile, 'utf8');
-    const parsed = parseFrontmatter(raw);
-    setCommand(out, entry, {
+    const frontmatter = readFrontmatterMetadata(skillFile);
+    setCommand(out, entry, commandWithContent({
       name: entry,
       source: `${source}-skill`,
       path: skillFile,
       metadata: {
-        description: parsed.metadata.description || 'Legacy skill',
+        ...frontmatter,
+        ...catalogMeta,
+        description: catalogMeta.description || frontmatter.description || 'Legacy skill',
         type: 'skill'
-      },
-      content: parsed.content
-    });
+      }
+    }));
   }
 }
 
 function loadBundledSkillsFromDir(baseDir, out) {
   if (!fs.existsSync(baseDir)) return;
+  const catalog = readSkillCatalog(baseDir);
   for (const entry of safeEntries(baseDir)) {
     if (!isSafeEntry(entry)) continue;
     const full = path.join(baseDir, entry);
     const stat = fs.statSync(full);
     if (!stat.isDirectory()) continue;
+    const catalogMeta = catalogMetadata(catalog, entry);
     const skillFile = path.join(full, 'SKILL.md');
     if (!fs.existsSync(skillFile)) continue;
-    const raw = fs.readFileSync(skillFile, 'utf8');
-    const parsed = parseFrontmatter(raw);
-    setCommand(out, entry, {
+    const frontmatter = readFrontmatterMetadata(skillFile);
+    setCommand(out, entry, commandWithContent({
       name: entry,
       source: 'bundled-skill',
       path: skillFile,
       metadata: {
-        ...parsed.metadata,
+        ...frontmatter,
+        ...catalogMeta,
         type: 'skill',
-        version: parsed.metadata.version || '0.1.0',
-        description: parsed.metadata.description || 'Bundled skill'
-      },
-      content: parsed.content
-    });
+        version: frontmatter.version || '0.1.0',
+        description: catalogMeta.description || frontmatter.description || 'Bundled skill'
+      }
+    }));
+  }
+}
+
+function applySkillCatalogPatches(baseDir, out) {
+  const catalog = readSkillCatalog(baseDir);
+  for (const name of Object.keys(catalog)) {
+    const existing = out.get(name);
+    if (!existing || existing.metadata?.type !== 'skill') continue;
+    const meta = catalogMetadata(catalog, name);
+    existing.metadata = {
+      ...existing.metadata,
+      ...meta,
+      description: meta.description || existing.metadata.description || ''
+    };
   }
 }
 
 function loadInstalledSkillsFromRegistry(baseDir, registry, out) {
   if (!registry || !Array.isArray(registry.skills)) return;
+  const catalog = readSkillCatalog(baseDir);
   for (const skill of registry.skills) {
     if (skill.enabled === false) continue;
     const name = skill.name;
     if (out.has(name)) continue;
+    const catalogMeta = catalogMetadata(catalog, name);
     const entry = skill.entryFile || 'SKILL.md';
     const full = path.join(baseDir, name, entry);
     if (!fs.existsSync(full)) continue;
-    const raw = fs.readFileSync(full, 'utf8');
-    const parsed = parseFrontmatter(raw);
-    setCommand(out, name, {
+    const frontmatter = readFrontmatterMetadata(full);
+    setCommand(out, name, commandWithContent({
       name,
       source: 'registry-skill',
       path: full,
       metadata: {
-        ...parsed.metadata,
+        ...frontmatter,
+        ...catalogMeta,
         type: 'skill',
-        version: skill.version || parsed.metadata.version || '0.0.0',
-        description: skill.description || parsed.metadata.description || 'Installed skill'
-      },
-      content: parsed.content
-    });
+        version: skill.version || frontmatter.version || '0.0.0',
+        description: catalogMeta.description || skill.description || frontmatter.description || 'Installed skill'
+      }
+    }));
   }
 }
 
@@ -201,10 +294,12 @@ export async function loadCommandsAndSkills(cwd = process.cwd()) {
   const commands = new Map();
 
   loadBundledSkillsFromDir(BUNDLED_SKILLS_DIR, commands);
+  applySkillCatalogPatches(getProjectSkillsDir(cwd), commands);
   loadMarkdownCommandsFromDir(getCommandsDir(), 'global', commands);
   loadMarkdownCommandsFromDir(getProjectCommandsDir(cwd), 'project', commands);
   loadLegacySkillsFromDir(getSkillsDir(), 'global', commands);
   loadLegacySkillsFromDir(getProjectSkillsDir(cwd), 'project', commands);
+  applySkillCatalogPatches(getProjectSkillsDir(cwd), commands);
   const registry = await readSkillRegistry();
   loadInstalledSkillsFromRegistry(getSkillsDir(), registry, commands);
 

package/src/core/command-policy.js

@@ -196,7 +196,25 @@ function suggestionForToken(token, config) {
   return 'Prefer structured tools like read, edit, write, grep, glob, and list first. If you need shell fallback, use allowed shell commands for search and local context such as rg, find, grep, sed, cat, or ls.';
 }
 
-function validateCdSegment(command, workspaceRoot) {
+function allowedPathRoots(workspaceRoot, config = {}) {
+  return [
+    workspaceRoot,
+    ...(Array.isArray(config?.policy?.allowed_paths) ? config.policy.allowed_paths : [])
+  ]
+    .map((item) => String(item || '').trim())
+    .filter(Boolean)
+    .map((item) => path.resolve(item));
+}
+
+function isWithinAnyRoot(candidatePath, roots = []) {
+  const resolvedCandidate = path.resolve(candidatePath);
+  return roots.some((root) => {
+    const relative = path.relative(root, resolvedCandidate);
+    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+  });
+}
+
+function validateCdSegment(command, workspaceRoot, config = {}) {
   const tokens = tokenizeTopLevel(command);
   if (tokens.length === 1) {
     return { allowed: false, reason: 'cd requires a target path in safe mode' };
@@ -210,11 +228,9 @@ function validateCdSegment(command, workspaceRoot) {
     return { allowed: false, reason: 'cd target is not allowed in safe mode' };
   }
 
-  const resolvedRoot = path.resolve(workspaceRoot);
-  const resolvedTarget = path.resolve(resolvedRoot, rawTarget);
-  const relative = path.relative(resolvedRoot, resolvedTarget);
-  if (relative.startsWith('..') || path.isAbsolute(relative)) {
-    return { allowed: false, reason: `cd escapes workspace: ${rawTarget}` };
+  const resolvedTarget = path.resolve(path.resolve(workspaceRoot), rawTarget);
+  if (!isWithinAnyRoot(resolvedTarget, allowedPathRoots(workspaceRoot, config))) {
+    return { allowed: false, reason: `cd escapes workspace or allowed paths: ${rawTarget}` };
   }
 
   return { allowed: true };
@@ -246,7 +262,7 @@ export function evaluateCommandPolicy(command, config, workspaceRoot = process.c
   for (const item of inspectedTokens) {
     if (SHELL_KEYWORDS.has(item.token)) continue;
     if (item.token === 'cd') {
-      const cdCheck = validateCdSegment(item.raw, workspaceRoot);
+      const cdCheck = validateCdSegment(item.raw, workspaceRoot, config);
       if (!cdCheck.allowed) {
         return { allowed: false, reason: cdCheck.reason, suggestion: suggestionForToken(item.token, config) };
       }
@@ -263,11 +279,19 @@ export function evaluateCommandPolicy(command, config, workspaceRoot = process.c
     }
   }
 
-  const workspaceLower = String(workspaceRoot).toLowerCase().replace(/\//g, '\\');
+  const allowedLower = allowedPathRoots(workspaceRoot, config).map((item) => item.toLowerCase().replace(/\//g, '\\'));
   const windowsAbsPath = lower.match(/[a-z]:\\[^\s'"]+/g) || [];
   for (const p of windowsAbsPath) {
-    if (!p.startsWith(workspaceLower)) {
-      return { allowed: false, reason: `absolute path outside workspace: ${p}`, suggestion: suggestionForToken(token, config) };
+    if (!allowedLower.some((root) => p === root || p.startsWith(`${root}\\`))) {
+      return { allowed: false, reason: `absolute path outside workspace or allowed paths: ${p}`, suggestion: suggestionForToken(token, config) };
+    }
+  }
+
+  const posixAbsPath = cmd.match(/(?<![:/\w])\/(?!\/)[^\s'"]+/g) || [];
+  const allowedResolved = allowedPathRoots(workspaceRoot, config);
+  for (const p of posixAbsPath) {
+    if (!isWithinAnyRoot(p, allowedResolved)) {
+      return { allowed: false, reason: `absolute path outside workspace or allowed paths: ${p}`, suggestion: suggestionForToken(token, config) };
     }
   }
 

package/src/core/config-store.js

@@ -36,7 +36,9 @@ const DEFAULT_CONFIG = {
     read_file_max_chars: 24000,
     prompt_budget_audit: false,
     microcompact_enabled: true,
-    microcompact_keep_recent: 5
+    microcompact_keep_recent: 5,
+    project_instructions_enabled: true,
+    project_instructions_max_chars: 12000
   },
   execution: {
     mode: 'normal',
@@ -89,6 +91,7 @@ const DEFAULT_CONFIG = {
   policy: {
     safe_mode: true,
     allow_dangerous_commands: false,
+    allowed_paths: [],
     command_allowlist: [],
     blocked_commands: [],
     blocked_path_patterns: [],
@@ -195,6 +198,9 @@ function normalizePolicyLists(config) {
   next.policy.command_allowlist = uniqueStrings(
     Array.isArray(next.policy.command_allowlist) ? next.policy.command_allowlist : []
   );
+  next.policy.allowed_paths = uniqueStrings(
+    Array.isArray(next.policy.allowed_paths) ? next.policy.allowed_paths : []
+  );
   next.policy.blocked_commands = uniqueStrings(
     Array.isArray(next.policy.blocked_commands) ? next.policy.blocked_commands : []
   );
@@ -212,6 +218,13 @@ function parseValue(input) {
   if (input === 'true') return true;
   if (input === 'false') return false;
   if (input === 'null') return null;
+  if ((input.startsWith('[') && input.endsWith(']')) || (input.startsWith('{') && input.endsWith('}'))) {
+    try {
+      return JSON.parse(input);
+    } catch {
+      return input;
+    }
+  }
   if (!Number.isNaN(Number(input)) && input.trim() !== '') return Number(input);
   return input;
 }

package/src/core/project-index.js

@@ -25,6 +25,7 @@ const PROJECT_MARKER_FILES = new Set([
 const LANGUAGE_BY_EXT = EXTENSION_LANGUAGE_MAP;
 
 const initCache = new BoundedCache({ maxSize: 32, ttlMs: 10 * 60 * 1000 });
+const ignoreRulesCache = new BoundedCache({ maxSize: 128, ttlMs: 60 * 1000 });
 const PROJECT_CONTEXT_MAX_FILES = 6;
 
 function clipList(values, max = 32) {
@@ -92,9 +93,24 @@ function gitignorePatternToRegex(pattern) {
 }
 
 async function readIgnoreFileRules(cwd, fileName) {
+  const filePath = path.join(cwd, fileName);
+  const stat = await safeStat(filePath);
+  const cacheKey = `${filePath}:${Number(stat?.mtimeMs || 0)}:${Number(stat?.size || 0)}`;
+  if (ignoreRulesCache.has(cacheKey)) return ignoreRulesCache.get(cacheKey);
+
+  for (const key of ignoreRulesCache.keys()) {
+    if (String(key).startsWith(`${filePath}:`) && key !== cacheKey) {
+      ignoreRulesCache.delete(key);
+    }
+  }
+
   try {
-    const raw = await fs.readFile(path.join(cwd, fileName), 'utf8');
-    return raw
+    if (!stat?.isFile()) {
+      ignoreRulesCache.set(cacheKey, []);
+      return [];
+    }
+    const raw = await fs.readFile(filePath, 'utf8');
+    const rules = raw
       .split(/\r?\n/)
       .map((line) => line.trim())
       .filter((line) => line && !line.startsWith('#'))
@@ -114,7 +130,10 @@ async function readIgnoreFileRules(cwd, fileName) {
         };
       })
       .filter((rule) => rule.normalized);
+    ignoreRulesCache.set(cacheKey, rules);
+    return rules;
   } catch {
+    ignoreRulesCache.set(cacheKey, []);
     return [];
   }
 }

package/src/core/project-instructions.js

@@ -0,0 +1,98 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+const DEFAULT_MAX_CHARS = 12000;
+const CANDIDATE_FILES = [
+  'AGENTS.md',
+  path.join('.agents', 'AGENTS.md'),
+  path.join('.agents', 'agents.md'),
+  path.join('.codemini', 'AGENTS.md'),
+  'CLAUDE.md'
+];
+
+function trimProjectInstructions(value, maxChars = DEFAULT_MAX_CHARS) {
+  const text = String(value || '').trim();
+  if (!text) return '';
+  const limit = Math.max(1000, Number(maxChars) || DEFAULT_MAX_CHARS);
+  if (text.length <= limit) return text;
+  return `${text.slice(0, limit - 120).trimEnd()}\n\n[Project instructions truncated: keep AGENTS.md concise or move details into linked docs.]`;
+}
+
+async function readFirstExistingFile(cwd, candidates = CANDIDATE_FILES) {
+  let current = path.resolve(cwd);
+  while (true) {
+    for (const candidate of candidates) {
+      const absolutePath = path.resolve(current, candidate);
+      let stat;
+      try {
+        stat = await fs.stat(absolutePath);
+      } catch {
+        continue;
+      }
+      if (!stat?.isFile()) continue;
+      const content = await fs.readFile(absolutePath, 'utf8');
+      const relativePath = path.relative(cwd, absolutePath) || candidate;
+      return {
+        path: absolutePath,
+        relativePath: relativePath.split(path.sep).join('/'),
+        content
+      };
+    }
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return null;
+}
+
+export async function loadProjectInstructions({
+  cwd = process.cwd(),
+  config = {},
+  maxChars = config?.context?.project_instructions_max_chars
+} = {}) {
+  const enabled = config?.context?.project_instructions_enabled !== false;
+  if (!enabled) return '';
+
+  const found = await readFirstExistingFile(cwd);
+  if (!found) return '';
+
+  const body = trimProjectInstructions(found.content, maxChars);
+  if (!body) return '';
+
+  return [
+    'Project Instructions:',
+    `Source: ${found.relativePath}`,
+    body
+  ].join('\n');
+}
+
+export function buildDefaultAgentsMd() {
+  return `# AGENTS.md
+
+This file gives coding agents stable project instructions. Keep it short and use it as a map, not as full documentation.
+
+## Project
+
+- Describe what this repository is and the main runtime or product surface.
+- Note required runtime versions and package managers.
+
+## Commands
+
+- Install: \`npm install\`
+- Test: \`npm test\`
+- Build: add the project build command here.
+
+## Task Routing
+
+- CLI or command behavior: list the entry files here.
+- Runtime behavior: list the core runtime files here.
+- Web UI behavior: list the server, state, and component roots here.
+- Tests: list focused test files for common changes.
+
+## Rules
+
+- Use project/file indexes for orientation, then inspect real source files before editing.
+- Keep generated output and build artifacts out of manual edits.
+- Put reusable workflows in skills; put always-needed project facts and routing rules here.
+`;
+}

package/src/core/shell.js

@@ -23,6 +23,74 @@ const READY_OUTPUT_PATTERNS = [
   /\bhttp:\/\/127\.0\.0\.1\b/i,
   /\bhttp:\/\/localhost\b/i
 ];
+const INSTALL_COMMAND_PATTERNS = [
+  /\b(?:npm|pnpm|yarn|bun)\s+install\b/i,
+  /\b(?:npm|pnpm|yarn|bun)\s+(?:ci|i|add)\b/i,
+  /\buv\s+pip\s+install\b/i,
+  /\bpip\s+install\b/i,
+  /\bcargo\s+install\b/i,
+  /\bbundle\s+install\b/i,
+  /\bcomposer\s+install\b/i
+];
+const BUILD_COMMAND_RE = /\b(?:build|compile|bundle|pack|transpile)\b/i;
+const TEST_COMMAND_PATTERNS = [
+  /\b(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?(?:test|lint|check|typecheck)\b/i,
+  /\b(?:jest|vitest|mocha|ava|pytest|go\s+test|cargo\s+test|dotnet\s+test)\b/i
+];
+const FRONTEND_SERVICE_PATTERNS = [
+  /\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
+];
+const BACKEND_SERVICE_PATTERNS = [
+  /\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
+];
+const DATABASE_SERVICE_PATTERNS = [
+  /\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
+];
+const DOCKER_SERVICE_PATTERNS = [
+  /\bdocker\s+compose\s+up\b/i,
+  /\bdocker-compose\s+up\b/i,
+  /\bdocker\s+run\b/i,
+  /\bdocker\s+start\b/i
+];
+const PACKAGE_SERVICE_RE = /\b(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?(?:dev|start|serve|preview|watch)\b/i;
+const VITE_OR_SERVE_RE = /\b(?:vite|serve)\b/i;
+const SERVICE_HINT_RE = /\b(?:watch|serve|server|dev|preview)\b/i;
 const AUTO_STOP_GRACE_MS = 150;
 const LONG_RUNNING_STARTUP_WINDOW_MS = 1500;
 
@@ -41,105 +109,43 @@ export function classifyCommandIntent(command) {
     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)
-  ) {
+  if (matchesAny(value, INSTALL_COMMAND_PATTERNS)) {
     return { kind: 'install', longRunning: false };
   }
 
-  if (/\b(?:build|compile|bundle|pack|transpile)\b/i.test(value)) {
+  if (BUILD_COMMAND_RE.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)
-  ) {
+  if (matchesAny(value, TEST_COMMAND_PATTERNS)) {
     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)) {
+  if (matchesAny(value, FRONTEND_SERVICE_PATTERNS)) {
     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)) {
+  if (matchesAny(value, BACKEND_SERVICE_PATTERNS)) {
     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)) {
+  if (matchesAny(value, DATABASE_SERVICE_PATTERNS)) {
     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)) {
+  if (matchesAny(value, DOCKER_SERVICE_PATTERNS)) {
     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)
+    PACKAGE_SERVICE_RE.test(value) ||
+    VITE_OR_SERVE_RE.test(value) ||
+    SERVICE_HINT_RE.test(value)
   ) {
     return { kind: 'service', longRunning: true };
   }
 
-  if (/\b(?:watch|serve|server|dev|preview)\b/i.test(value)) {
+  if (SERVICE_HINT_RE.test(value)) {
     return { kind: 'service', longRunning: true };
   }