aegiscode 3.1.10 → 3.4.2

package/src/tools/createTool.ts

@@ -1,221 +0,0 @@
-/**
- * 
- * 
- * 
- */
-
-import { z } from 'zod';
-import { zodToJsonSchema } from 'zod-to-json-schema';
-import {
-  ToolErrorType,
-  type Tool,
-  type ToolKind,
-  type ToolDescription,
-  type ToolResult,
-  type ExecutionContext,
-  type FunctionDeclaration,
-  type ToolInvocation,
-} from './types.js';
-
-// ========== 配置类
-
-/**
- * 
- */
-export interface ToolConfig<TSchema extends z.ZodType> {
-  /** 工具唯一名称 */
-  name: string;
-  /** 显示名称 */
-  displayName?: string;
-  /** 工具类型 */
-  kind: ToolKind;
-  /** 参数 Schema */
-  schema: TSchema;
-  /** 工具描述 */
-  description: ToolDescription;
-  /** 执行函数 */
-  execute: (
-    params: z.infer<TSchema>,
-    context?: ExecutionContext
-  ) => Promise<ToolResult>;
-  /** 版本 */
-  version?: string;
-  /** 分类 */
-  category?: string;
-  /** 标签 */
-  tags?: string[];
-  /** 是否只读（默认根据 kind 推断） */
-  isReadOnly?: boolean;
-  /** 是否并发安全（默认 true） */
-  isConcurrencySafe?: boolean;
-  /** 是否启用结构化输出（默认 false） */
-  strict?: boolean;
-  /** 提取签名内容（用于权限规则） */
-  extractSignatureContent?: (params: unknown) => string;
-  /** 抽象权限规则（用于权限匹配） */
-  abstractPermissionRule?: (params: unknown) => string;
-}
-
-// ========== 工厂函
-
-/**
- * 
- * 
- * @example
- * ```typescript
- * const readTool = createTool({
- *   name: 'Read',
- *   kind: ToolKind.ReadOnly,
- *   schema: z.object({
- *     file_path: z.string(),
- *   }),
- *   description: { short: 'Read files' },
- *   execute: async (params) => {
- *     // ...
- *   },
- * });
- * ```
- */
-export function createTool<TSchema extends z.ZodType>(
-  config: ToolConfig<TSchema>
-): Tool<z.infer<TSchema>> {
-  const {
-    name,
-    displayName,
-    kind,
-    schema,
-    description,
-    execute,
-    version = '1.0.0',
-    category,
-    tags = [],
-    isReadOnly,
-    isConcurrencySafe = true,
-    strict = false,
-    extractSignatureContent,
-    abstractPermissionRule,
-  } = config;
-
-  // 从 Zod Schema 生
-  const jsonSchema = zodToJsonSchema(schema, {
-    $refStrategy: 'none',
-    target: 'openApi3',
-  });
-
-  // 提取 properties 
-  const schemaObj = jsonSchema as {
-    type?: string;
-    properties?: Record<string, unknown>;
-    required?: string[];
-  };
-
-  return {
-    name,
-    displayName: displayName || name,
-    kind,
-    isReadOnly: isReadOnly ?? kind === 'readonly',
-    isConcurrencySafe,
-    strict,
-    description,
-    version,
-    category,
-    tags,
-
-    /**
-     * 
-     */
-    getFunctionDeclaration(): FunctionDeclaration {
-      return {
-        name,
-        description: buildFullDescription(description),
-        parameters: {
-          type: 'object',
-          properties: schemaObj.properties || {},
-          required: schemaObj.required,
-        },
-      };
-    },
-
-    /**
-     * 
-     */
-    build(params: z.infer<TSchema>): ToolInvocation<z.infer<TSchema>> {
-      return {
-        toolName: name,
-        params,
-      };
-    },
-
-    /**
-     * 
-     */
-    async execute(
-      params: z.infer<TSchema>,
-      context?: ExecutionContext
-    ): Promise<ToolResult> {
-      try {
-        // 验证参
-        const validated = schema.parse(params);
-        // 执行工
-        return await execute(validated, context);
-      } catch (error) {
-        // 处理 Zod 验证错
-        if (error instanceof z.ZodError) {
-          const messages = error.errors.map(e => 
-            `${e.path.join('.')}: ${e.message}`
-          ).join('; ');
-          
-          return {
-            success: false,
-            llmContent: `Parameter validation failed: ${messages}`,
-            displayContent: `❌ 参数验证失败: ${messages}`,
-            error: {
-              type: ToolErrorType.VALIDATION_ERROR,
-              message: messages,
-              details: error.errors,
-            },
-          };
-        }
-
-        // 处理其他错
-        const errorMessage = error instanceof Error ? error.message : '未知错误';
-        return {
-          success: false,
-          llmContent: `Tool execution failed: ${errorMessage}`,
-          displayContent: `❌ 执行失败: ${errorMessage}`,
-          error: {
-            type: ToolErrorType.EXECUTION_ERROR,
-            message: errorMessage,
-          },
-        };
-      }
-    },
-
-    // 可选方
-    extractSignatureContent,
-    abstractPermissionRule,
-  };
-}
-
-/**
- * 
- */
-function buildFullDescription(desc: ToolDescription): string {
-  const parts: string[] = [desc.short];
-
-  if (desc.long) {
-    parts.push(desc.long);
-  }
-
-  if (desc.usageNotes && desc.usageNotes.length > 0) {
-    parts.push('\nUsage notes:');
-    parts.push(...desc.usageNotes.map(note => `- ${note}`));
-  }
-
-  if (desc.important && desc.important.length > 0) {
-    parts.push('\nIMPORTANT:');
-    parts.push(...desc.important.map(note => `- ${note}`));
-  }
-
-  return parts.join('\n');
-}

package/src/tools/execution/ExecutionPipeline.ts

@@ -1,263 +0,0 @@
-/**
- * ExecutionPipeline - 执行管道
- * 
- */
-
-import {
-  ToolExecution,
-  PermissionMode,
-  type PipelineStage,
-  type PipelineExecutionContext,
-  type ExecutionPipelineConfig,
-  type ExecutionHistoryEntry,
-  type StageStartEvent,
-  type StageCompleteEvent,
-} from './types.js';
-import type { ToolResult, ToolErrorType } from '../types.js';
-import type { ToolRegistry } from '../registry.js';
-import {
-  DiscoveryStage,
-  CacheStage,
-  PermissionStage,
-  HookStage,
-  ConfirmationStage,
-  ExecutionStage,
-  PostHookStage,
-  FormattingStage,
-} from './stages/index.js';
-
-/**
- * 
- */
-export interface ExecutionPipelineEvents {
-  stageStart: (event: StageStartEvent) => void;
-  stageComplete: (event: StageCompleteEvent) => void;
-  executionStart: (execution: ToolExecution) => void;
-  executionComplete: (execution: ToolExecution, result: ToolResult) => void;
-  executionError: (execution: ToolExecution, error: Error) => void;
-}
-
-/**
- * 
- */
-export class ExecutionPipeline {
-  private stages: PipelineStage[];
-  private cacheStage: CacheStage;
-  private executionHistory: ExecutionHistoryEntry[] = [];
-  private readonly sessionApprovals = new Set<string>();
-  private readonly sessionDenials = new Set<string>();
-  private readonly maxHistorySize = 1000;
-
-  constructor(
-    private registry: ToolRegistry,
-    config: ExecutionPipelineConfig = {}
-  ) {
-
-    const defaultMode = config.defaultMode || PermissionMode.DEFAULT;
-    this.cacheStage = new CacheStage();
-
-    // 初始化八个执行阶
-    this.stages = [
-      new DiscoveryStage(this.registry, config.allowedTools, config.disallowedTools),
-      this.cacheStage,
-      new PermissionStage(config.permissions, this.sessionApprovals, this.sessionDenials, defaultMode),
-      new HookStage(),
-      new ConfirmationStage(this.sessionApprovals, this.sessionDenials),
-      new ExecutionStage(this.cacheStage),
-      new PostHookStage(),
-      new FormattingStage(),
-    ];
-  }
-
-  /**
-   * 
-   */
-  async execute(
-    toolName: string,
-    params: Record<string, unknown>,
-    context: PipelineExecutionContext
-  ): Promise<ToolResult> {
-    const startTime = Date.now();
-    const executedStages: string[] = [];
-
-    // 创建执行实
-    const execution = new ToolExecution(toolName, params, context);
-
-    // 发出执行开始事
-
-    try {
-      // 依次执行各阶
-      for (const stage of this.stages) {
-        if (execution.isAborted()) {
-          break;
-        }
-
-        // 发出阶段开始事
-
-        // 执行阶
-        await stage.process(execution);
-
-        // 记录已执行的阶
-        executedStages.push(stage.name);
-
-        // 发出阶段完成事
-      }
-
-      // 获取或创建结
-      const result = execution.getResult() || this.createErrorResult(execution);
-
-      // 记录执行历
-      this.recordExecution({
-        toolName,
-        params,
-        result,
-        timestamp: startTime,
-        duration: Date.now() - startTime,
-        permissionMode: context.permissionMode,
-        stages: executedStages,
-      });
-
-      // 发出执行完成事
-
-      return result;
-    } catch (error) {
-      // 发出执行错误事
-      const err = error instanceof Error ? error : new Error(String(error));
-
-      // 返回错误结
-      return {
-        success: false,
-        llmContent: `Pipeline execution error: ${err.message}`,
-        displayContent: `❌ Pipeline error: ${err.message}`,
-        error: {
-          type: 'execution_error' as ToolErrorType,
-          message: err.message,
-        },
-      };
-    }
-  }
-
-  /**
-   * 
-   */
-  private createErrorResult(execution: ToolExecution): ToolResult {
-    const reason = execution.getAbortReason() || 'Unknown error';
-    return {
-      success: false,
-      llmContent: `Tool execution aborted: ${reason}`,
-      displayContent: `❌ ${execution.toolName}: ${reason}`,
-      error: {
-        type: 'execution_error' as ToolErrorType,
-        message: reason,
-      },
-    };
-  }
-
-  /**
-   * 
-   */
-  private recordExecution(entry: ExecutionHistoryEntry): void {
-    this.executionHistory.push(entry);
-
-    // 限制历史大
-    if (this.executionHistory.length > this.maxHistorySize) {
-      this.executionHistory.shift();
-    }
-  }
-
-  /**
-   * 
-   */
-  getRegistry(): ToolRegistry {
-    return this.registry;
-  }
-
-  /**
-   * 
-   */
-  getHistory(): ExecutionHistoryEntry[] {
-    return [...this.executionHistory];
-  }
-
-  /**
-   * 
-   */
-  clearHistory(): void {
-    this.executionHistory = [];
-  }
-
-  /**
-   * 
-   */
-  getSessionApprovals(): Set<string> {
-    return new Set(this.sessionApprovals);
-  }
-
-  /**
-   * 
-   */
-  clearSessionApprovals(): void {
-    this.sessionApprovals.clear();
-  }
-
-  /**
-   * 
-   */
-  addSessionApproval(signature: string): void {
-    this.sessionApprovals.add(signature);
-  }
-
-  /**
-   * 
-   */
-  hasSessionApproval(signature: string): boolean {
-    return this.sessionApprovals.has(signature);
-  }
-
-  // ==================== Session Denials ====================
-
-  /**
-   * 
-   */
-  getSessionDenials(): Set<string> {
-    return new Set(this.sessionDenials);
-  }
-
-  /**
-   * 
-   */
-  clearSessionDenials(): void {
-    this.sessionDenials.clear();
-  }
-
-  /**
-   * 
-   */
-  addSessionDenial(signature: string): void {
-    this.sessionDenials.add(signature);
-  }
-
-  /**
-   * 
-   */
-  hasSessionDenial(signature: string): boolean {
-    return this.sessionDenials.has(signature);
-  }
-
-  /**
-   * 
-   */
-  getStageNames(): string[] {
-    return this.stages.map(s => s.name);
-  }
-
-  /** Stats for the session-scoped Read/Grep/Glob result cache */
-  getCacheStats(): { size: number; maxSize: number } {
-    return this.cacheStage.stats();
-  }
-
-  /** Clear cached entries for a specific session */
-  clearSessionCache(sessionId: string): void {
-    this.cacheStage.clearSession(sessionId);
-  }
-}

package/src/tools/execution/index.ts

@@ -1,40 +0,0 @@
-/**
- * 
- */
-
-// 类
-export {
-  PermissionMode,
-  PermissionResult,
-  ToolExecution,
-  type PipelineStage,
-  type PipelineExecutionContext,
-  type ExecutionPipelineConfig,
-  type ExecutionHistoryEntry,
-  type PermissionCheckResult,
-  type PermissionConfig,
-  type ToolInvocationDescriptor,
-  type ConfirmationDetails,
-  type ConfirmationResponse,
-  type ConfirmationHandler,
-  type ToolProgress,
-  type PreToolHookResult,
-  type PostToolHookParams,
-  type StageStartEvent,
-  type StageCompleteEvent,
-} from './types.js';
-
-// 主
-export { ExecutionPipeline, type ExecutionPipelineEvents } from './ExecutionPipeline.js';
-
-// 阶
-export {
-  DiscoveryStage,
-  CacheStage,
-  PermissionStage,
-  HookStage,
-  ConfirmationStage,
-  ExecutionStage,
-  PostHookStage,
-  FormattingStage,
-} from './stages/index.js';

package/src/tools/execution/stages/CacheStage.ts

@@ -1,131 +0,0 @@
-/**
- * CacheStage — session-scoped tool result caching
- *
- * Caches results from read-only tools (Read, Grep, Glob) so that re-requesting
- * the same file / same glob / same grep within the same session does not re-execute
- * the tool. The result is injected directly into the ToolExecution object, allowing
- * the pipeline to short-circuit.
- *
- * Design parallels Claude Code's `tool-results/` directory per session UUID.
- *
- * Key decisions:
- *  - Cache key = SHA-256 hash of (toolName + sorted-JSON(params) + sessionId)
- *  - Only caches SUCCESSFUL results from read-only tools
- *  - Cache is in-memory (Map) + optionally persisted to disk
- *  - TTL = session lifetime (cleared when session ends or cache is purged)
- */
-
-import * as crypto from 'node:crypto';
-import type { ToolResult } from '../../types.js';
-import type { PipelineStage, ToolExecution } from '../types.js';
-
-// ── Types ────────────────────────────────────────────────────────────────────
-
-export interface CacheEntry {
-  result: ToolResult;
-  cachedAt: number;
-  hitCount: number;
-}
-
-export interface CacheStageOptions {
-  /** Maximum cache entries (default 500) */
-  maxSize?: number;
-}
-
-// ── Read-only tool names that are safe to cache ──────────────────────────────
-
-const READONLY_TOOLS = new Set(['Read', 'Grep', 'Glob']);
-
-// ── CacheStage ───────────────────────────────────────────────────────────────
-
-export class CacheStage implements PipelineStage {
-  readonly name = 'cache';
-
-  /** Cache key → CacheEntry */
-  private store = new Map<string, CacheEntry>();
-  private maxSize: number;
-
-  constructor(options: CacheStageOptions = {}) {
-    this.maxSize = options.maxSize ?? 500;
-  }
-
-  async process(execution: ToolExecution): Promise<void> {
-    // Only cache read-only tools
-    if (!READONLY_TOOLS.has(execution.toolName)) return;
-
-    const cacheKey = this.buildKey(
-      execution.toolName,
-      execution.params,
-      execution.context.sessionId,
-    );
-
-    const cached = this.store.get(cacheKey);
-    if (cached) {
-      cached.hitCount++;
-      execution.setResult(cached.result);
-      return;
-    }
-
-    // Not in cache — ExecutionStage reads this key to store the result once
-    // the tool actually runs.
-    execution._internal.cacheKey = cacheKey;
-  }
-
-  /**
-   * Called by ExecutionStage after a tool executes successfully, to store
-   * the result in the cache.
-   */
-  cacheResult(cacheKey: string, result: ToolResult): void {
-    if (!result.success) return;
-    if (!result.llmContent && !result.displayContent) return;
-
-    // Evict oldest if at capacity
-    if (this.store.size >= this.maxSize) {
-      let oldestKey: string | undefined;
-      let oldestTime = Infinity;
-      for (const [k, v] of this.store) {
-        if (v.cachedAt < oldestTime) {
-          oldestTime = v.cachedAt;
-          oldestKey = k;
-        }
-      }
-      if (oldestKey) this.store.delete(oldestKey);
-    }
-
-    this.store.set(cacheKey, {
-      result,
-      cachedAt: Date.now(),
-      hitCount: 0,
-    });
-  }
-
-  /** Clear all cached entries */
-  clear(): void {
-    this.store.clear();
-  }
-
-  /** Clear entries for a specific session */
-  clearSession(sessionId: string): void {
-    for (const [key, entry] of this.store) {
-      // Keys embed the sessionId — check by extracting it
-      if (key.includes(sessionId)) {
-        this.store.delete(key);
-      }
-    }
-  }
-
-  /** Get cache stats */
-  stats(): { size: number; maxSize: number } {
-    return { size: this.store.size, maxSize: this.maxSize };
-  }
-
-  // ── Private ──────────────────────────────────────────────────────────────
-
-  private buildKey(toolName: string, params: Record<string, unknown>, sessionId: string): string {
-    const hash = crypto.createHash('sha256');
-    hash.update(toolName);
-    hash.update(JSON.stringify(params, Object.keys(params).sort()));
-    hash.update(sessionId);
-    return hash.digest('hex');
-  }
-}