aegiscode 3.1.8 → 3.1.10

package/src/tools/builtin/grep.ts

@@ -0,0 +1,263 @@
+/**
+ * Grep 工具 - 内容搜索
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { glob } from 'glob';
+import { z } from 'zod';
+import { createTool } from '../createTool.js';
+import { ToolKind, ToolErrorType } from '../types.js';
+
+/**
+ * 
+ */
+const DEFAULT_IGNORE = [
+  '**/node_modules/**',
+  '**/.git/**',
+  '**/dist/**',
+  '**/build/**',
+  '**/.next/**',
+  '**/coverage/**',
+  '**/*.min.js',
+  '**/*.bundle.js',
+];
+
+/**
+ * 
+ */
+const MAX_RESULTS = 100;
+
+/**
+ * Grep 工具 Schema
+ */
+const GrepSchema = z.object({
+  pattern: z.string()
+    .min(1, '搜索模式不能为空')
+    .describe('The regular expression pattern to search for'),
+  
+  path: z.string()
+    .optional()
+    .describe('Directory to search in (defaults to current working directory)'),
+  
+  include: z.string()
+    .optional()
+    .describe('Glob pattern to filter files (e.g., "*.ts" for TypeScript files)'),
+  
+  case_sensitive: z.boolean()
+    .default(true)
+    .describe('Whether the search is case sensitive'),
+});
+
+/**
+ * 
+ */
+interface SearchMatch {
+  file: string;
+  line: number;
+  content: string;
+}
+
+/**
+ * 
+ */
+async function searchInFile(
+  filePath: string,
+  regex: RegExp
+): Promise<SearchMatch[]> {
+  try {
+    const content = await fs.readFile(filePath, 'utf-8');
+    const lines = content.split('\n');
+    const matches: SearchMatch[] = [];
+
+    for (let i = 0; i < lines.length; i++) {
+      if (regex.test(lines[i])) {
+        matches.push({
+          file: filePath,
+          line: i + 1,
+          content: lines[i].trim(),
+        });
+      }
+    }
+
+    return matches;
+  } catch {
+    // 忽略无法读取的文
+    return [];
+  }
+}
+
+/**
+ * Grep 工具
+ */
+export const grepTool = createTool({
+  name: 'Grep',
+  displayName: 'Content Search',
+  kind: ToolKind.ReadOnly,
+  schema: GrepSchema,
+
+  description: {
+    short: 'Search file contents using regular expressions',
+    long: `A powerful search tool for finding patterns in file contents.
+Supports full regex syntax and can filter files by glob pattern.`,
+    usageNotes: [
+      'Uses JavaScript regex syntax',
+      'Common patterns: "function\\s+\\w+" for function definitions',
+      'Use include parameter to filter files: "*.ts" for TypeScript only',
+      'Results are limited to 100 matches for performance',
+      'Automatically ignores node_modules, .git, dist directories',
+    ],
+    examples: [
+      {
+        description: 'Search for function definitions',
+        params: { pattern: 'function\\s+\\w+' },
+      },
+      {
+        description: 'Search in TypeScript files only',
+        params: { pattern: 'export', include: '*.ts' },
+      },
+      {
+        description: 'Case-insensitive search',
+        params: { pattern: 'todo', case_sensitive: false },
+      },
+    ],
+  },
+
+  category: '搜索',
+  tags: ['search', 'grep', 'regex'],
+
+  async execute(params, context) {
+    const { pattern, path: searchPath, include, case_sensitive } = params;
+    
+    // 默认搜索目
+    const cwd = searchPath || context?.cwd || process.cwd();
+
+    try {
+      // 创建正则表达
+      // 验证正则表达式是否包含未闭合的字符类或分组
+      const unclosedBracket = (pattern.match(/\[/g) || []).length !== (pattern.match(/\]/g) || []).length;
+      const unclosedParen = (pattern.match(/\(/g) || []).length !== (pattern.match(/\)/g) || []).length;
+      
+      if (unclosedBracket || unclosedParen) {
+        return {
+          success: false,
+          llmContent: `Invalid regex pattern: ${pattern} — unclosed bracket or parenthesis`,
+          displayContent: `error: invalid regex — unclosed bracket or parenthesis`,
+          error: {
+            type: ToolErrorType.VALIDATION_ERROR,
+            message: 'Invalid regex pattern — unclosed bracket or parenthesis',
+          },
+        };
+      }
+
+      let regex: RegExp;
+      try {
+        regex = new RegExp(pattern, case_sensitive ? 'g' : 'gi');
+      } catch (e) {
+        return {
+          success: false,
+          llmContent: `Invalid regex pattern: ${pattern}`,
+          displayContent: `error: invalid regex: ${pattern}`,
+          error: {
+            type: ToolErrorType.VALIDATION_ERROR,
+            message: 'Invalid regex pattern',
+          },
+        };
+      }
+
+      // 获取要搜索的文件列
+      const filePattern = include 
+        ? (include.startsWith('**/') ? include : `**/${include}`)
+        : '**/*';
+      
+      const files = await glob(filePattern, {
+        cwd,
+        ignore: DEFAULT_IGNORE,
+        nodir: true,
+        absolute: true,
+      });
+
+      // 过滤二进制文件（简单判
+      const textExtensions = [
+        '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
+        '.json', '.md', '.txt', '.yaml', '.yml',
+        '.html', '.css', '.scss', '.less',
+        '.py', '.rb', '.go', '.rs', '.java',
+        '.c', '.cpp', '.h', '.hpp',
+        '.sh', '.bash', '.zsh',
+        '.xml', '.svg',
+      ];
+      
+      const textFiles = files.filter(f => 
+        textExtensions.some(ext => f.endsWith(ext))
+      );
+
+      // 搜索所有文
+      const allMatches: SearchMatch[] = [];
+      
+      for (const file of textFiles) {
+        if (allMatches.length >= MAX_RESULTS) break;
+        
+        const matches = await searchInFile(file, regex);
+        allMatches.push(...matches);
+        
+        if (allMatches.length >= MAX_RESULTS) {
+          allMatches.length = MAX_RESULTS;
+          break;
+        }
+      }
+
+      if (allMatches.length === 0) {
+        return {
+          success: true,
+          llmContent: 'No matches found.',
+          displayContent: `no matches: ${pattern}`,
+          metadata: {
+            pattern,
+            cwd,
+            files_searched: textFiles.length,
+            matches: 0,
+          },
+        };
+      }
+
+      // 格式化输
+      const formattedMatches = allMatches
+        .map(m => {
+          const relPath = path.relative(cwd, m.file);
+          return `${relPath}:${m.line}: ${m.content}`;
+        })
+        .join('\n');
+
+      const truncated = allMatches.length >= MAX_RESULTS;
+      let summary = `${allMatches.length} match${allMatches.length === 1 ? '' : 'es'}`;
+      if (truncated) {
+        summary += ` (truncated)`;
+      }
+
+      return {
+        success: true,
+        llmContent: formattedMatches,
+        displayContent: summary,
+        metadata: {
+          pattern,
+          cwd,
+          files_searched: textFiles.length,
+          matches: allMatches.length,
+          truncated,
+        },
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'unknown error';
+      return {
+        success: false,
+        llmContent: `Grep search failed: ${errorMessage}`,
+        displayContent: `error: ${errorMessage}`,
+        error: {
+          type: ToolErrorType.EXECUTION_ERROR,
+          message: errorMessage,
+        },
+      };
+    }
+  },
+});

package/src/tools/builtin/index.ts

@@ -0,0 +1,61 @@
+/**
+ * 
+ */
+
+// 文件工
+export { readTool } from './read.js';
+export { editTool } from './edit.js';
+export { writeTool } from './write.js';
+
+// 搜索工
+export { grepTool } from './grep.js';
+export { globTool } from './glob.js';
+
+// Shell 工
+export { bashTool } from './bash.js';
+
+// Skills 工
+export { skillTool } from './skill.js';
+
+// Memory 工
+export { memoryTool } from './memory.js';
+
+// Multi-agent orchestration 工
+export { taskTool } from './task.js';
+export { councilTool } from './council.js';
+
+import { readTool } from './read.js';
+import { editTool } from './edit.js';
+import { writeTool } from './write.js';
+import { grepTool } from './grep.js';
+import { globTool } from './glob.js';
+import { bashTool } from './bash.js';
+import { skillTool } from './skill.js';
+import { memoryTool } from './memory.js';
+import { taskTool } from './task.js';
+import { councilTool } from './council.js';
+import type { Tool } from '../types.js';
+
+/**
+ * 
+ */
+export function getBuiltinTools(): Tool[] {
+  return [
+    // 文件工
+    readTool,
+    editTool,
+    writeTool,
+    // 搜索工
+    grepTool,
+    globTool,
+    // Shell 工
+    bashTool,
+    // Skills 工
+    skillTool,
+    // Memory 工
+    memoryTool,
+    // Multi-agent orchestration 工
+    taskTool,
+    councilTool,
+  ];
+}

package/src/tools/builtin/memory.ts

@@ -0,0 +1,66 @@
+/**
+ * Memory 工具 - 按需检索共享记
+ *
+ * Shared memory is intentionally NOT injected into every turn's system
+ * prompt by default — auto-injecting semantically-similar past memories
+ * caused models to recall and repeat their own past mistakes (e.g. a stuck
+ * session's hallucinated text got stored, then recalled as "context" in
+ * later sessions, reinforcing itself). Memory is opt-in: the model calls
+ * this tool only when it decides recalling past conversations would help.
+ */
+
+import { z } from 'zod';
+import { createTool } from '../createTool.js';
+import { ToolKind } from '../types.js';
+import { sharedMemory } from '../../memory/SharedMemory.js';
+
+const MemorySchema = z.object({
+  query: z.string()
+    .min(1, 'query 不能为空')
+    .describe('What to recall — a topic, decision, or past conversation to search for'),
+  maxEntries: z.number().int().min(1).max(10).optional()
+    .describe('Maximum number of memory entries to return (default 4)'),
+});
+
+export const memoryTool = createTool({
+  name: 'Memory',
+  displayName: 'Recall Memory',
+  kind: ToolKind.ReadOnly,
+  schema: MemorySchema,
+
+  description: {
+    short: 'Recall relevant context from past conversations and sessions',
+    long: `Searches shared long-term memory for past conversations, decisions, and summaries
+relevant to a query. This is opt-in — call it only when recalling prior context would
+genuinely help (e.g. "what did we decide about X last time", "have we hit this error before").`,
+    usageNotes: [
+      'Do NOT call this by default at the start of every task — only when past context is actually useful',
+      'Treat results as recollections that may be incomplete, outdated, or about a different situation — verify against the current codebase/state before relying on them',
+      'Never treat a past assistant message recalled here as proof that something is currently blocked, broken, or unavailable — confirm directly instead',
+    ],
+  },
+
+  category: '记忆',
+  tags: ['memory', 'recall', 'context'],
+
+  execute: async (params, context) => {
+    const { query, maxEntries } = params;
+    const result = await sharedMemory.buildContext(query, maxEntries || 4, context?.sessionId);
+
+    if (!result) {
+      return {
+        success: true,
+        llmContent: 'No relevant memory found for this query.',
+        displayContent: 'No relevant memory found',
+      };
+    }
+
+    return {
+      success: true,
+      llmContent: result,
+      displayContent: `Recalled memory for: ${query}`,
+    };
+  },
+});
+
+export default memoryTool;

package/src/tools/builtin/read.ts

@@ -0,0 +1,168 @@
+/**
+ * Read 工具 - 文件读取
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { z } from 'zod';
+import { createTool } from '../createTool.js';
+import { ToolKind, ToolErrorType } from '../types.js';
+
+/**
+ * 
+ */
+const DEFAULT_LINE_LIMIT = 2000;
+
+/**
+ * Read 工具 Schema
+ */
+const ReadSchema = z.object({
+  file_path: z.string()
+    .min(1, '文件路径不能为空')
+    .describe('The absolute path to the file to read'),
+  
+  offset: z.number()
+    .int()
+    .min(0)
+    .optional()
+    .describe('The line number to start reading from (0-based)'),
+  
+  limit: z.number()
+    .int()
+    .min(1)
+    .max(10000)
+    .optional()
+    .describe('The number of lines to read'),
+});
+
+/**
+ * Read 工具
+ */
+export const readTool = createTool({
+  name: 'Read',
+  displayName: 'File Read',
+  kind: ToolKind.ReadOnly,
+  schema: ReadSchema,
+
+  description: {
+    short: 'Reads a file from the local filesystem',
+    long: `Reads a file from the local filesystem. You can access any file directly by using this tool.
+If the User provides a path to a file assume that path is valid.`,
+    usageNotes: [
+      'The file_path parameter must be an absolute path, not a relative path',
+      `By default, it reads up to ${DEFAULT_LINE_LIMIT} lines starting from the beginning`,
+      'You can optionally specify a line offset and limit for long files',
+      'Lines in the output are numbered starting at 1',
+      'You can call multiple Read tools in parallel to read multiple files at once',
+    ],
+    examples: [
+      {
+        description: 'Read entire file',
+        params: { file_path: '/path/to/file.ts' },
+      },
+      {
+        description: 'Read with offset and limit',
+        params: { file_path: '/path/to/file.ts', offset: 100, limit: 50 },
+      },
+    ],
+    important: [
+      'file_path must be an absolute path',
+      'Prefer reading the whole file by not providing offset/limit',
+    ],
+  },
+
+  category: '文件操作',
+  tags: ['file', 'read', 'io'],
+
+  async execute(params, context) {
+    const { file_path, offset = 0, limit } = params;
+    const effectiveLimit = limit ?? DEFAULT_LINE_LIMIT;
+
+    try {
+      // 检查文件是否存
+      try {
+        await fs.access(file_path);
+      } catch {
+        return {
+          success: false,
+          llmContent: `File not found: ${file_path}`,
+          displayContent: `error: file not found: ${file_path}`,
+          error: {
+            type: ToolErrorType.EXECUTION_ERROR,
+            message: 'File not found',
+          },
+        };
+      }
+
+      // 获取文件信
+      const stat = await fs.stat(file_path);
+      
+      // 检查是否为目
+      if (stat.isDirectory()) {
+        return {
+          success: false,
+          llmContent: `Path is a directory, not a file: ${file_path}`,
+          displayContent: `error: ${file_path} is a directory`,
+          error: {
+            type: ToolErrorType.VALIDATION_ERROR,
+            message: 'Path is a directory',
+          },
+        };
+      }
+
+      // 读取文件内
+      const content = await fs.readFile(file_path, 'utf-8');
+      const lines = content.split('\n');
+      const totalLines = lines.length;
+
+      // 应用 offset 
+      const selectedLines = lines.slice(offset, offset + effectiveLimit);
+      
+      // 格式化输出（带行
+      const formattedContent = selectedLines
+        .map((line, i) => {
+          const lineNum = (offset + i + 1).toString().padStart(6, ' ');
+          return `${lineNum}|${line}`;
+        })
+        .join('\n');
+
+      // 计算是否有更多内
+      const hasMore = offset + effectiveLimit < totalLines;
+      const fileName = path.basename(file_path);
+
+      let summary = fileName;
+      if (offset > 0 || limit) {
+        summary += `  lines ${offset + 1}–${Math.min(offset + effectiveLimit, totalLines)} of ${totalLines}`;
+      } else {
+        summary += `  ${totalLines} lines`;
+      }
+      if (hasMore) {
+        summary += ` ···`;
+      }
+
+      return {
+        success: true,
+        llmContent: formattedContent,
+        displayContent: summary,
+        metadata: {
+          file_path,
+          total_lines: totalLines,
+          lines_read: selectedLines.length,
+          offset,
+          has_more: hasMore,
+        },
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'unknown error';
+      return {
+        success: false,
+        llmContent: `Failed to read file: ${errorMessage}`,
+        displayContent: `error: ${errorMessage}`,
+        error: {
+          type: ToolErrorType.EXECUTION_ERROR,
+          message: errorMessage,
+        },
+      };
+    }
+  },
+});

package/src/tools/builtin/skill.ts

@@ -0,0 +1,97 @@
+/**
+ * Skill 工具
+ * 
+ * 
+ * 
+ */
+
+import { z } from 'zod';
+import { createTool } from '../createTool.js';
+import { ToolKind } from '../types.js';
+import { getSkillRegistry } from '../../skills/index.js';
+
+/**
+ * Skill 工具参数 Schema
+ */
+const SkillSchema = z.object({
+  skill: z.string().describe('The name of the skill to load'),
+  args: z.string().optional().describe('Optional arguments to pass to the skill'),
+});
+
+/**
+ * Skill 工具
+ * 
+ * 
+ * 
+ */
+export const skillTool = createTool({
+  name: 'Skill',
+  displayName: 'Load Skill',
+  kind: ToolKind.ReadOnly,
+  schema: SkillSchema,
+
+  description: {
+    short: 'Load a skill to get specialized instructions',
+    long: `Load a skill to get specialized instructions for a task.
+
+Use this tool when:
+- You need specific guidance for a task that matches an available skill
+- The user explicitly requests to use a skill
+- You want to follow best practices defined in a skill
+
+The skill's instructions will be returned and you should follow them.`,
+  },
+
+  execute: async ({ skill, args }) => {
+    const registry = getSkillRegistry();
+    
+    // 检查 Skill 是否存
+    if (!registry.hasSkill(skill)) {
+      const allSkills = registry.getAllSkills();
+      const availableNames = allSkills.map(s => s.name).join(', ');
+      const errorMsg = `Skill "${skill}" not found. Available skills: ${availableNames || 'none'}`;
+      
+      return {
+        success: false,
+        llmContent: errorMsg,
+        displayContent: errorMsg,
+      };
+    }
+
+    // 加载完整内
+    const content = await registry.loadContent(skill);
+    
+    if (!content) {
+      const errorMsg = `Failed to load skill "${skill}"`;
+      return {
+        success: false,
+        llmContent: errorMsg,
+        displayContent: errorMsg,
+      };
+    }
+
+    // 构建返回内
+    let result = `## Skill: ${content.metadata.name}\n\n`;
+    
+    // 如果有工具限制，提
+    if (content.metadata.allowedTools && content.metadata.allowedTools.length > 0) {
+      result += `**Allowed tools for this skill:** ${content.metadata.allowedTools.join(', ')}\n\n`;
+    }
+    
+    // 添加指令内
+    result += content.instructions;
+    
+    // 如果有参数，添加到末
+    if (args) {
+      result += `\n\n## Arguments\n\n${args}`;
+    }
+
+    return {
+      success: true,
+      llmContent: result,
+      displayContent: `✓ Loaded skill: ${content.metadata.name}`,
+    };
+  },
+});
+
+export default skillTool;

package/src/tools/builtin/snapshot.ts

@@ -0,0 +1,40 @@
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+
+const SNAPSHOTS_DIR = path.join(os.homedir(), '.aegiscode', 'snapshots');
+const MAX_SNAPSHOTS = 50;
+
+export async function createSnapshot(filePath: string): Promise<string | null> {
+  try {
+    await fs.mkdir(SNAPSHOTS_DIR, { recursive: true });
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const basename = path.basename(filePath);
+    const snapshotPath = path.join(SNAPSHOTS_DIR, `${timestamp}_${basename}.bak`);
+    await fs.copyFile(filePath, snapshotPath);
+    await pruneSnapshots();
+    return snapshotPath;
+  } catch {
+    return null;
+  }
+}
+
+async function pruneSnapshots(): Promise<void> {
+  try {
+    const entries = await fs.readdir(SNAPSHOTS_DIR);
+    if (entries.length <= MAX_SNAPSHOTS) return;
+    const files = await Promise.all(
+      entries.map(async (name) => {
+        const p = path.join(SNAPSHOTS_DIR, name);
+        const stat = await fs.stat(p);
+        return { path: p, mtime: stat.mtime.getTime() };
+      })
+    );
+    files.sort((a, b) => a.mtime - b.mtime);
+    await Promise.all(
+      files.slice(0, files.length - MAX_SNAPSHOTS).map(f => fs.unlink(f.path))
+    );
+  } catch {
+    // ignore prune errors
+  }
+}