codemini-cli 0.3.9 → 0.4.0

package/src/core/tools.js

@@ -23,6 +23,12 @@ import { runDreamConsolidation } from './dream-consolidate.js';
 import { normalizePlanState } from './plan-state.js';
 import { normalizeTodos } from './todo-state.js';
 import { createFffAdapter } from './fff-adapter.js';
+import {
+  getToolOutputSanitizeOptions,
+  sanitizePreviewLines,
+  sanitizeTextForModel,
+  summarizeRunOutput
+} from './tool-output.js';
 const BACKGROUND_TASK_RECENT_OUTPUT_LIMIT = 80;
 const BACKGROUND_TASK_POLL_MS = 150;
 const MAX_AST_ENCLOSING_BYTES = 300_000;
@@ -333,11 +339,10 @@ async function webFetchPage(args = {}) {
     const html = await page.content();
     const $ = cheerio.load(html);
     const bodyText = $('body').text() || $.root().text();
-    const text = normalizeWhitespace(bodyText);
+    const text = String(bodyText || '').replace(/[^\S\n]+/g, ' ').replace(/\n{3,}/g, '\n\n').trim();
     const title = trimPreview($('title').first().text() || (await page.title()), 240);
     const description = extractHtmlMeta($, 'description') || extractHtmlMeta($, 'og:description');
     const links = collectPageLinks($, finalUrl, maxLinks);
-    const htmlExcerpt = html.length > 4000 ? `${html.slice(0, 4000)}...` : html;
 
     return {
       url,
@@ -345,7 +350,6 @@ async function webFetchPage(args = {}) {
       title,
       description,
       text,
-      html_excerpt: htmlExcerpt,
       links,
       metadata: {
         status: response?.status?.() ?? null,
@@ -747,40 +751,6 @@ function findEnclosingSymbolLine(lines, anchorLine) {
   return 0;
 }
 
-function buildUnifiedDiff(oldContent, newContent, filePath = 'file') {
-  const oldLines = splitLines(oldContent);
-  const newLines = splitLines(newContent);
-  let prefix = 0;
-  while (prefix < oldLines.length && prefix < newLines.length && oldLines[prefix] === newLines[prefix]) {
-    prefix += 1;
-  }
-
-  let suffix = 0;
-  while (
-    suffix < oldLines.length - prefix &&
-    suffix < newLines.length - prefix &&
-    oldLines[oldLines.length - 1 - suffix] === newLines[newLines.length - 1 - suffix]
-  ) {
-    suffix += 1;
-  }
-
-  const oldChanged = oldLines.slice(prefix, oldLines.length - suffix);
-  const newChanged = newLines.slice(prefix, newLines.length - suffix);
-  const oldStart = prefix + 1;
-  const newStart = prefix + 1;
-  const oldCount = Math.max(1, oldChanged.length);
-  const newCount = Math.max(1, newChanged.length);
-
-  const body = [
-    `--- ${filePath}`,
-    `+++ ${filePath}`,
-    `@@ -${oldStart},${oldCount} +${newStart},${newCount} @@`,
-    ...oldChanged.map((line) => `-${line}`),
-    ...newChanged.map((line) => `+${line}`)
-  ];
-  return body.join('\n');
-}
-
 async function getFileState(root, relativePath) {
   const target = await resolveInWorkspace(root, relativePath);
   const stat = await fs.stat(target);
@@ -924,12 +894,15 @@ async function writeFile(root, args) {
   }
   const previewStart = Math.max(0, (changeLine || 1) - 1);
   const previewLines = afterLines.slice(previewStart, previewStart + 6);
+  const changed = countChangedLines(before, after);
   return {
     ok: true,
     path: rawPath,
     action: normalizedArgs?.append ? 'append' : existed ? 'overwrite' : 'create',
     changed_line: changeLine || Math.max(1, afterLines.length),
-    diff_preview: previewLines.map((line, idx) => `${previewStart + idx + 1}| ${line}`).join('\n')
+    diff_preview: previewLines.map((line, idx) => `${previewStart + idx + 1}| ${line}`).join('\n'),
+    lines_added: changed.added,
+    lines_removed: changed.removed
   };
 }
 
@@ -1045,10 +1018,9 @@ function shellCommandForBackgroundTask(command, shellSpec) {
 }
 
 function appendRecentOutput(task, chunk) {
-  const lines = String(chunk || '')
-    .split(/\r?\n/)
-    .map((line) => trimLinePreview(line, 220))
-    .filter(Boolean);
+  const lines = sanitizePreviewLines(chunk, { maxLineLength: 220 }).map((line) =>
+    trimLinePreview(line, 220)
+  );
   if (lines.length === 0) return;
   for (const line of lines) {
     backgroundTaskLogCursorCounter += 1;
@@ -1499,18 +1471,47 @@ async function validateEdit(root, args) {
   throw new Error(`validate_edit does not support kind: ${kind}`);
 }
 
+function countChangedLines(beforeContent, afterContent) {
+  const before = splitLines(beforeContent);
+  const after = splitLines(afterContent);
+  const m = before.length;
+  const n = after.length;
+  // LCS via rolling DP — O(m*n) time, O(min(m,n)) space
+  const short = m <= n ? before : after;
+  const long = m <= n ? after : before;
+  const shortLen = short.length;
+  const longLen = long.length;
+  let prev = new Array(longLen + 1).fill(0);
+  let curr = new Array(longLen + 1).fill(0);
+  for (let i = 1; i <= shortLen; i++) {
+    for (let j = 1; j <= longLen; j++) {
+      if (short[i - 1] === long[j - 1]) {
+        curr[j] = prev[j - 1] + 1;
+      } else {
+        curr[j] = Math.max(prev[j], curr[j - 1]);
+      }
+    }
+    [prev, curr] = [curr, prev];
+    curr.fill(0);
+  }
+  const lcsLen = prev[longLen];
+  return { added: n - lcsLen, removed: m - lcsLen };
+}
+
 function editResult(pathText, action, beforeContent, afterContent, changedLine = 1) {
   const afterLines = splitLines(afterContent);
   const previewStart = Math.max(0, changedLine - 1);
   const diffPreview = afterLines.slice(previewStart, previewStart + 6).map((line, idx) => `${previewStart + idx + 1}| ${line}`).join('\n');
+  const changed = countChangedLines(beforeContent, afterContent);
   return {
     ok: true,
     path: pathText,
     action,
     changed_line: changedLine,
     diff_preview: diffPreview,
-    diff: buildUnifiedDiff(beforeContent, afterContent, pathText),
-    new_hash: sha256(afterContent)
+    new_hash: sha256(afterContent),
+    lines_added: changed.added,
+    lines_removed: changed.removed
   };
 }
 
@@ -1767,7 +1768,7 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
   };
   const ensureProjectIndex = async () => {
     const eventId = `project-index:${Date.now()}`;
-    const name = 'project_index(.codemini-project/project-map.json,.codemini-project/file-index.json)';
+    const name = 'project_index(.codemini/project-map.json,.codemini/file-index.json)';
     try {
       const result = await initializeProjectIndex(workspaceRoot);
       if (result?.skipped || !result?.summary) {
@@ -1799,7 +1800,7 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
         type: 'system_tool:end',
         id: eventId,
         name,
-        summary: result?.summary || `updated .codemini-project for ${relativePath}`
+        summary: result?.summary || `updated .codemini for ${relativePath}`
       });
       return result;
     } catch (error) {
@@ -2210,52 +2211,23 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
         }
       }
     },
-    remember_user: {
+    save_memory: {
       type: 'function',
       function: {
-        name: 'remember_user',
-        description: 'Store a durable user preference, communication habit, or long-term instruction for future sessions. Use this for things like reply style, language, explanation depth, or stable guardrails. Never store secrets, tokens, passwords, or one-off task details.',
-        parameters: {
-          type: 'object',
-          properties: {
-            content: { type: 'string', description: 'Stable preference or instruction to remember' },
-            kind: { type: 'string', description: 'preference, workflow, constraint, or warning' },
-            summary: { type: 'string', description: 'Short summary for the memory index' },
-            replace_similar: { type: 'boolean', description: 'Replace an existing similar memory when true' }
-          },
-          required: ['content']
-        }
-      }
-    },
-    remember_global: {
-      type: 'function',
-      function: {
-        name: 'remember_global',
-        description: 'Store a durable cross-project workflow, environment fact, or generally reusable lesson that can help across many repositories. Use this for stable habits like preferred search tools or repeatable debugging workflow. Never store secrets.',
-        parameters: {
-          type: 'object',
-          properties: {
-            content: { type: 'string' },
-            kind: { type: 'string' },
-            summary: { type: 'string' },
-            replace_similar: { type: 'boolean' }
-          },
-          required: ['content']
-        }
-      }
-    },
-    remember_project: {
-      type: 'function',
-      function: {
-        name: 'remember_project',
-        description: 'Store a durable project-specific convention, architecture note, key module warning, or local workflow expectation. Use this for repository-specific rules, important files, testing conventions, or architectural boundaries. Never store secrets or transient task state.',
+        name: 'save_memory',
+        description:
+          'Save a durable observation or knowledge to persistent memory. Use this when you notice a reusable pattern, a user correction, a stable preference, a project convention, or a workflow insight. Do NOT use for casual chatter, trivial typos, one-off noise, or secrets. The memory is saved immediately and available in future sessions.',
         parameters: {
           type: 'object',
           properties: {
-            content: { type: 'string' },
-            kind: { type: 'string' },
-            summary: { type: 'string' },
-            replace_similar: { type: 'boolean' }
+            content: { type: 'string', description: 'The knowledge or observation to remember' },
+            summary: { type: 'string', description: 'Short summary for the memory index (under 80 chars)' },
+            scope: {
+              type: 'string',
+              description: 'Where to store this memory. "user" = personal preferences (language, style, interaction habits). "global" = cross-project knowledge useful in ANY repository (environment quirks, general workflows, tool tips). "project" = specific to THIS repository only (architecture conventions, local config, test commands, file locations). Default: "global".'
+            },
+            kind: { type: 'string', description: 'Memory kind: preference, pattern, correction, observation, decision, failure, win, gap, convention. Default: observation' },
+            replace_similar: { type: 'boolean', description: 'Replace an existing similar memory when true. Default: true.' }
           },
           required: ['content']
         }
@@ -2305,26 +2277,6 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
         }
       }
     },
-    capture_memory: {
-      type: 'function',
-      function: {
-        name: 'capture_memory',
-        description:
-          'Capture a high-signal observation into the dream loop inbox during active work. Use this when you notice a reusable pattern, a user correction, a repeated failure with stable fix, a stable preference, or a workflow win. Do NOT use for casual chatter, trivial typos, or one-off noise. This is lightweight — entries land in inbox and are consolidated later.',
-        parameters: {
-          type: 'object',
-          properties: {
-            summary: { type: 'string', description: 'Short high-signal summary of the observation' },
-            details: { type: 'string', description: 'Detailed explanation of the observation' },
-            scope: { type: 'string', description: 'Scope: global, repo, or thread. Default: global' },
-            type: { type: 'string', description: 'Observation type: correction, failure, preference, pattern, win, gap, decision. Default: observation' },
-            tags: { type: 'array', items: { type: 'string' }, description: 'Optional tags for categorization' },
-            suggested_action: { type: 'string', description: 'Optional suggested follow-up action' }
-          },
-          required: ['summary']
-        }
-      }
-    },
     dream_consolidate: {
       type: 'function',
       function: {
@@ -2584,42 +2536,32 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
         hasPendingApproval: nextPlan?.status === 'pending_approval'
       };
     },
-    run: (args) => runCommand(workspaceRoot, config, args),
-    remember_user: async (args = {}) => {
-      const saved = await rememberMemory({
-        scope: 'user',
-        content: args.content,
-        kind: args.kind,
-        summary: args.summary,
-        replaceSimilar: args.replace_similar !== false,
-        workspaceRoot,
-        config
-      });
-      return { ok: true, scope: 'user', memory: saved };
-    },
-    remember_global: async (args = {}) => {
-      const saved = await rememberMemory({
-        scope: 'global',
-        content: args.content,
-        kind: args.kind,
-        summary: args.summary,
-        replaceSimilar: args.replace_similar !== false,
-        workspaceRoot,
-        config
-      });
-      return { ok: true, scope: 'global', memory: saved };
-    },
-    remember_project: async (args = {}) => {
+    run: Object.assign(
+      (args) => runCommand(workspaceRoot, config, args),
+      {
+        prepareApproval: async (args) => ({
+          command: args?.command || '',
+          risk: args?._risk || 'high',
+          evaluation: args?._evaluation || null
+        })
+      }
+    ),
+    save_memory: async (args = {}) => {
+      const rawScope = String(args.scope || 'global').toLowerCase();
+      const memoryScope = rawScope === 'repo' || rawScope === 'project' ? 'project'
+        : rawScope === 'user' ? 'user'
+        : 'global';
       const saved = await rememberMemory({
-        scope: 'project',
+        scope: memoryScope,
         content: args.content,
-        kind: args.kind,
-        summary: args.summary,
+        kind: args.kind || 'observation',
+        summary: args.summary || String(args.content || '').slice(0, 80),
+        source: 'tool',
         replaceSimilar: args.replace_similar !== false,
         workspaceRoot,
         config
       });
-      return { ok: true, scope: 'project', memory: saved };
+      return { ok: true, scope: memoryScope, memory: saved };
     },
     list_memory: async (args = {}) => ({
       scope: String(args.scope || ''),
@@ -2634,18 +2576,6 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
       ok: true,
       ...(await forgetMemory({ scope: args.scope, id: args.id, workspaceRoot }))
     }),
-    capture_memory: async (args = {}) => {
-      const entry = await captureToInbox({
-        scope: args.scope,
-        type: args.type,
-        summary: args.summary,
-        details: args.details,
-        suggestedAction: args.suggested_action,
-        tags: args.tags,
-        source: 'tool'
-      });
-      return { ok: true, captured: entry };
-    },
     dream_consolidate: async (args = {}) => {
       return runDreamConsolidation({
         dryRun: args.dry_run === true,
@@ -2681,7 +2611,7 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
     }
   };
 
-  const formatters = {
+  const rawFormatters = {
     read(result) {
       if (typeof result === 'string') return result;
       if (!result || typeof result !== 'object') return String(result);
@@ -2880,9 +2810,11 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
         }
         return parts.join('\n');
       }
+      const runSummary = summarizeRunOutput(result);
+      if (runSummary) return runSummary;
       const command = String(result.command || '').slice(0, 200);
-      const stdout = String(result.stdout || '').slice(0, 500);
-      const stderr = String(result.stderr || '').slice(0, 500);
+      const stdout = String(result.stdout || '');
+      const stderr = String(result.stderr || '');
       const code = result.code ?? 0;
       const parts = [`[exit: ${code}]`];
       if (command) parts.push(`command: ${command}`);
@@ -2903,6 +2835,11 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
       return result?.memory?.content ? `stored project memory: ${result.memory.content}` : JSON.stringify(result);
     },
 
+    save_memory(result) {
+      const scope = result?.scope || 'global';
+      return result?.memory?.content ? `stored ${scope} memory: ${result.memory.content}` : JSON.stringify(result);
+    },
+
     list_memory(result) {
       if (!result || typeof result !== 'object' || !Array.isArray(result.items)) return JSON.stringify(result);
       if (result.items.length === 0) return `No ${result.scope || ''} memories found.`;
@@ -2938,8 +2875,7 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
       const kind = result.kind || '';
       const content = result.content || result.source || '';
       const header = `${kind} ${name}`;
-      if (typeof content !== 'string' || content.length <= 2000) return `${header}\n${content}`;
-      return `${header}\n${content.slice(0, 1200)}\n... [omitted ${content.length - 1600} chars] ...\n${content.slice(-400)}`;
+      return `${header}\n${content}`;
     },
 
     web_fetch(result) {
@@ -2951,7 +2887,9 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
       if (Array.isArray(result.links) && result.links.length > 0) {
         lines.push(`links: ${result.links.slice(0, 5).map((item) => item.href).join(', ')}`);
       }
-      if (result.text) lines.push(trimPreview(result.text, 1200));
+      if (result.text) {
+        lines.push(result.text);
+      }
       return lines.join('\n');
     },
 
@@ -2992,6 +2930,13 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config, onSyste
     }
   };
 
+  const formatters = Object.fromEntries(
+    Object.entries(rawFormatters).map(([name, formatter]) => [
+      name,
+      (result, args) => sanitizeTextForModel(formatter(result, args), getToolOutputSanitizeOptions(name))
+    ])
+  );
+
   async function dispose() {
     if (activeFffAdapter?.dispose) {
       try {