aegiscode 3.1.10 → 3.2.0

package/src/tools/builtin/memory.ts

@@ -1,66 +0,0 @@
-/**
- * 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

@@ -1,168 +0,0 @@
-/**
- * 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

@@ -1,97 +0,0 @@
-/**
- * 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

@@ -1,40 +0,0 @@
-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
-  }
-}

package/src/tools/builtin/task.ts

@@ -1,106 +0,0 @@
-/**
- * Task tool — lets the running agent delegate read-only investigation
- * work to parallel sub-agents, mid-conversation, without the user typing
- * a slash command. Same machinery as /multi, restricted to Read/Grep/Glob
- * (see plan: no confirmationHandler reaches a tool's execute(), so only
- * ReadOnly-kind work is safe to trigger from inside a tool call).
- */
-
-import { z } from 'zod';
-import { createTool } from '../createTool.js';
-import { ToolKind } from '../types.js';
-import { OrchestratorAgent, type SubAgentConfig } from '../../agent/orchestrator/OrchestratorAgent.js';
-import { requireModelConfig, buildSourceContext } from '../../agent/orchestrator/utils.js';
-
-const TaskSchema = z.object({
-  tasks: z.array(z.object({
-    description: z.string().describe('Short label for this investigation, e.g. "find auth bugs"'),
-    prompt: z.string().describe('Detailed instructions for the sub-agent'),
-  })).min(1).max(5).describe('One or more independent investigations to run in parallel'),
-});
-
-export const taskTool = createTool({
-  name: 'Task',
-  displayName: 'Delegate Task',
-  kind: ToolKind.ReadOnly,
-  schema: TaskSchema,
-
-  description: {
-    short: 'Delegate read-only investigation work to parallel sub-agents',
-    long: `Spin up one or more read-only sub-agents (Read/Grep/Glob only) to investigate
-the codebase in parallel, then return their findings.
-
-Use this when:
-- A question has multiple independent angles worth exploring at once
-- You want a focused sub-agent to dig into one area without cluttering the main conversation
-
-Sub-agents cannot write files or run commands — they only read and report back.
-You're responsible for synthesizing their findings into your final answer.`,
-  },
-
-  execute: async ({ tasks }, context) => {
-    let modelConfig;
-    try {
-      modelConfig = requireModelConfig();
-    } catch (e) {
-      const msg = (e as Error).message;
-      return { success: false, llmContent: msg, displayContent: msg };
-    }
-
-    const agentConfig = {
-      apiKey: modelConfig.apiKey,
-      baseURL: modelConfig.baseURL,
-      model: modelConfig.model,
-      timeout: modelConfig.timeout,
-    };
-
-    const cwd = context?.cwd || process.cwd();
-    const sourceCtx = buildSourceContext(cwd);
-    const codeContext = sourceCtx
-      ? `\n\nWorkspace context (project metadata + file tree + structure summaries + git changes):\n${sourceCtx}\n\nUse Read / Grep / Glob to examine these.`
-      : '\n\nUse Read / Grep / Glob to explore the codebase before responding.';
-
-    const orchestrator = new OrchestratorAgent(
-      'Task-Orchestrator',
-      'You coordinate read-only investigation sub-agents.',
-    );
-
-    tasks.forEach((task, i) => {
-      const agentCfg: SubAgentConfig = {
-        name: `agent-${i}`,
-        role: 'Investigator',
-        systemPrompt: `You are a focused investigation sub-agent. ${task.prompt}${codeContext}`,
-        config: agentConfig,
-        tools: ['Read', 'Grep', 'Glob'],
-      };
-      orchestrator.registerAgent(agentCfg);
-    });
-
-    try {
-      const responses = await orchestrator.delegateParallel(
-        tasks.map((task, i) => ({ agentName: `agent-${i}`, task: task.prompt })),
-        tasks.length,
-        context?.sessionId,
-      );
-
-      const lines: string[] = [];
-      responses.forEach((res, i) => {
-        lines.push(`### ${tasks[i]?.description || res.agentName}`);
-        lines.push(res.content || '*No response*');
-        lines.push('');
-      });
-
-      const formatted = lines.join('\n').trim();
-      return {
-        success: true,
-        llmContent: formatted,
-        displayContent: `✓ Ran ${tasks.length} investigation${tasks.length > 1 ? 's' : ''} in parallel`,
-      };
-    } catch (e) {
-      const msg = `Task delegation failed: ${(e as Error).message}`;
-      return { success: false, llmContent: msg, displayContent: msg };
-    }
-  },
-});
-
-export default taskTool;

package/src/tools/builtin/write.ts

@@ -1,134 +0,0 @@
-/**
- * Write 工具
- * 
- * 
- */
-
-import fs from 'fs/promises';
-import path from 'path';
-import { z } from 'zod';
-import { createTool } from '../createTool.js';
-import { ToolKind, ToolErrorType } from '../types.js';
-import { createSnapshot } from './snapshot.js';
-
-// ========== Schema 定
-
-const WriteSchema = z.object({
-  file_path: z.string()
-    .min(1, '文件路径不能为空')
-    .describe('The absolute path to the file to write'),
-  contents: z.string()
-    .describe('The contents to write to the file'),
-});
-
-// ========== Write 工
-
-export const writeTool = createTool({
-  name: 'Write',
-  displayName: 'File Write',
-  kind: ToolKind.Write,
-  schema: WriteSchema,
-  
-  description: {
-    short: 'Writes a file to the local filesystem',
-    long: 'Creates a new file or overwrites an existing file with the specified contents.',
-    usageNotes: [
-      'This tool will overwrite the existing file if there is one at the provided path',
-      'ALWAYS prefer editing existing files in the codebase using Edit tool',
-      'NEVER write new files unless explicitly required',
-      'NEVER proactively create documentation files (*.md) or README files',
-      'Parent directories will be created automatically if they do not exist',
-    ],
-    examples: [
-      {
-        description: 'Create a new TypeScript file',
-        params: {
-          file_path: '/path/to/new-file.ts',
-          contents: 'export const hello = "world";',
-        },
-      },
-    ],
-    important: [
-      'Only create files that are absolutely necessary',
-      'Do not create README or documentation files unless explicitly requested',
-    ],
-  },
-
-  category: '文件操作',
-  tags: ['file', 'io', 'write', 'create'],
-
-  // 提取签名内容（用于权限规
-  extractSignatureContent: (params: unknown) => {
-    const p = params as { file_path: string };
-    return p.file_path;
-  },
-
-  // 抽象权限规
-  abstractPermissionRule: (params: unknown) => {
-    const p = params as { file_path: string };
-    const dir = path.dirname(p.file_path);
-    return `Write:${dir}/*`;
-  },
-
-  async execute(params, context) {
-    const { file_path, contents } = params;
-
-    try {
-      // 1. 检查目标是否是目
-      try {
-        const stat = await fs.stat(file_path);
-        if (stat.isDirectory()) {
-          return {
-            success: false,
-            llmContent: `Error: ${file_path} is a directory, cannot write to it`,
-            displayContent: `error: ${file_path} is a directory`,
-            error: {
-              type: ToolErrorType.VALIDATION_ERROR,
-              message: 'Path is a directory',
-            },
-          };
-        }
-      } catch {
-        // 文件不存在，这是允许
-      }
-
-      // 2. 确保父目录存
-      const dir = path.dirname(file_path);
-      await fs.mkdir(dir, { recursive: true });
-
-      // 3. 快照原始文件（如果已存在）
-      let snapshotPath: string | null = null;
-      try { await fs.access(file_path); snapshotPath = await createSnapshot(file_path); } catch { /* new file */ }
-
-      // 4. 写入文
-      await fs.writeFile(file_path, contents, 'utf8');
-
-      // 5. 计算写入信
-      const lines = contents.split('\n').length;
-      const bytes = Buffer.byteLength(contents, 'utf8');
-
-      return {
-        success: true,
-        llmContent: `Successfully wrote to ${file_path} (${lines} lines, ${bytes} bytes)`,
-        displayContent: `${path.basename(file_path)}  ${lines} lines`,
-        metadata: {
-          file_path,
-          lines,
-          bytes,
-          snapshot: snapshotPath,
-        },
-      };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : 'unknown error';
-      return {
-        success: false,
-        llmContent: `Error writing file: ${errorMessage}`,
-        displayContent: `error: ${errorMessage}`,
-        error: {
-          type: ToolErrorType.EXECUTION_ERROR,
-          message: errorMessage,
-        },
-      };
-    }
-  },
-});