@within-7/minto 0.1.6 → 0.2.0

package/dist/services/sandbox/types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/services/sandbox/types.ts"],
+  "sourcesContent": ["/**\n * Sandbox System Types\n *\n * Type definitions for the sandbox execution system that provides\n * OS-level isolation for Bash commands.\n */\n\n/**\n * Filesystem access policy\n */\nexport interface FilesystemPolicy {\n  /** Directories/files allowed for writing (glob patterns) */\n  writeAllowed: string[]\n  /** Directories/files allowed for reading (glob patterns) */\n  readAllowed: string[]\n  /** Directories/files explicitly denied (glob patterns) - highest priority */\n  denied: string[]\n}\n\n/**\n * Network access policy\n */\nexport interface NetworkPolicy {\n  /** Domains allowed for network access */\n  allowedDomains: string[]\n  /** Whether to prompt user for new domains */\n  promptForNewDomains: boolean\n  /** Whether to block all network access */\n  blockAll: boolean\n}\n\n/**\n * Process isolation policy\n */\nexport interface ProcessPolicy {\n  /** Commands excluded from sandboxing (e.g., 'docker', 'git') */\n  excludedCommands: string[]\n  /** Maximum execution time in milliseconds */\n  maxExecutionTime: number\n  /** Maximum memory usage in bytes (0 = unlimited) */\n  maxMemory: number\n  /** Maximum number of processes (0 = unlimited) */\n  maxProcesses: number\n}\n\n/**\n * Complete sandbox configuration\n */\nexport interface SandboxConfig {\n  /** Whether sandboxing is enabled */\n  enabled: boolean\n  /** Filesystem access policy */\n  filesystem: FilesystemPolicy\n  /** Network access policy */\n  network: NetworkPolicy\n  /** Process isolation policy */\n  process: ProcessPolicy\n}\n\n/**\n * Sandbox execution result\n */\nexport interface SandboxExecutionResult {\n  /** Standard output */\n  stdout: string\n  /** Standard error */\n  stderr: string\n  /** Exit code */\n  exitCode: number\n  /** Whether execution was interrupted */\n  interrupted: boolean\n  /** Whether execution was blocked by sandbox */\n  blocked: boolean\n  /** Reason for blocking (if blocked) */\n  blockReason?: string\n  /** Execution duration in milliseconds */\n  duration: number\n}\n\n/**\n * Sandbox violation types\n */\nexport type SandboxViolationType =\n  | 'filesystem_write_denied'\n  | 'filesystem_read_denied'\n  | 'filesystem_path_denied'\n  | 'network_domain_denied'\n  | 'network_blocked'\n  | 'process_limit_exceeded'\n  | 'memory_limit_exceeded'\n  | 'execution_time_exceeded'\n  | 'command_excluded'\n\n/**\n * Sandbox violation record\n */\nexport interface SandboxViolation {\n  type: SandboxViolationType\n  timestamp: number\n  command: string\n  details: string\n  path?: string\n  domain?: string\n}\n\n/**\n * OS-specific sandbox implementation type\n */\nexport type SandboxImplementation =\n  | 'seatbelt'\n  | 'bubblewrap'\n  | 'docker'\n  | 'none'\n\n/**\n * Sandbox controller interface\n */\nexport interface ISandboxController {\n  /** Check if sandbox is available on this system */\n  isAvailable(): Promise<boolean>\n\n  /** Get the implementation type */\n  getImplementationType(): SandboxImplementation\n\n  /** Initialize the sandbox */\n  initialize(config: SandboxConfig): Promise<void>\n\n  /** Execute a command in the sandbox */\n  execute(\n    command: string,\n    workingDir: string,\n    signal?: AbortSignal,\n    timeout?: number,\n  ): Promise<SandboxExecutionResult>\n\n  /** Pre-validate a command against policies */\n  validateCommand(command: string): Promise<{\n    valid: boolean\n    violations: SandboxViolation[]\n  }>\n\n  /** Get current configuration */\n  getConfig(): SandboxConfig\n\n  /** Update configuration */\n  updateConfig(config: Partial<SandboxConfig>): void\n\n  /** Get violation history */\n  getViolations(): SandboxViolation[]\n\n  /** Clear violation history */\n  clearViolations(): void\n}\n\n/**\n * Default sandbox configuration\n */\nexport const DEFAULT_SANDBOX_CONFIG: SandboxConfig = {\n  enabled: false, // Disabled by default for backward compatibility\n  filesystem: {\n    writeAllowed: ['./'], // Current working directory\n    readAllowed: ['*'], // Allow reading everything by default\n    denied: [\n      '.env*',\n      '.env',\n      '.env.local',\n      '.env.*.local',\n      'secrets/**',\n      '.ssh/**',\n      '.gnupg/**',\n      '.aws/credentials',\n      '.config/gcloud/**',\n      '**/*.pem',\n      '**/*.key',\n      '**/id_rsa',\n      '**/id_ed25519',\n    ],\n  },\n  network: {\n    allowedDomains: [\n      'api.anthropic.com',\n      'api.openai.com',\n      'github.com',\n      'api.github.com',\n      'registry.npmjs.org',\n      'pypi.org',\n    ],\n    promptForNewDomains: true,\n    blockAll: false,\n  },\n  process: {\n    excludedCommands: ['docker', 'git', 'node', 'npm', 'bun', 'pnpm', 'yarn'],\n    maxExecutionTime: 600000, // 10 minutes\n    maxMemory: 0, // Unlimited\n    maxProcesses: 0, // Unlimited\n  },\n}\n"],
+  "mappings": "AA6JO,MAAM,yBAAwC;AAAA,EACnD,SAAS;AAAA;AAAA,EACT,YAAY;AAAA,IACV,cAAc,CAAC,IAAI;AAAA;AAAA,IACnB,aAAa,CAAC,GAAG;AAAA;AAAA,IACjB,QAAQ;AAAA,MACN;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAAA,EACA,SAAS;AAAA,IACP,gBAAgB;AAAA,MACd;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,IACA,qBAAqB;AAAA,IACrB,UAAU;AAAA,EACZ;AAAA,EACA,SAAS;AAAA,IACP,kBAAkB,CAAC,UAAU,OAAO,QAAQ,OAAO,OAAO,QAAQ,MAAM;AAAA,IACxE,kBAAkB;AAAA;AAAA,IAClB,WAAW;AAAA;AAAA,IACX,cAAc;AAAA;AAAA,EAChB;AACF;",
+  "names": []
+}

package/dist/services/sessionMemory.js

@@ -0,0 +1,266 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  readdirSync,
+  unlinkSync,
+  rmdirSync
+} from "fs";
+import { join, resolve } from "path";
+import { homedir } from "os";
+import crypto from "crypto";
+class SessionMemoryManager {
+  baseDir;
+  projectHash;
+  sessionId;
+  constructor(projectPath, sessionId) {
+    this.baseDir = join(homedir(), ".minto", "projects");
+    this.projectHash = this.hashPath(projectPath);
+    this.sessionId = sessionId || crypto.randomUUID();
+    this.ensureDirectories();
+  }
+  /**
+   * Get the session ID
+   */
+  getSessionId() {
+    return this.sessionId;
+  }
+  /**
+   * Get the project hash
+   */
+  getProjectHash() {
+    return this.projectHash;
+  }
+  /**
+   * Save session memory
+   */
+  saveMemory(memory, metadata) {
+    const sessionDir = this.getSessionDir();
+    const fullMetadata = {
+      sessionId: this.sessionId,
+      projectPath: "",
+      // Will be set by caller
+      projectHash: this.projectHash,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      messageCount: 0,
+      ...this.loadMetadata(),
+      ...metadata
+    };
+    writeFileSync(
+      join(sessionDir, "session_memory.json"),
+      JSON.stringify(memory, null, 2)
+    );
+    writeFileSync(
+      join(sessionDir, "metadata.json"),
+      JSON.stringify(fullMetadata, null, 2)
+    );
+    if (memory.decisions.length > 0) {
+      writeFileSync(
+        join(sessionDir, "decisions.json"),
+        JSON.stringify(memory.decisions, null, 2)
+      );
+    }
+  }
+  /**
+   * Save full conversation (optional, for debugging/recovery)
+   */
+  saveConversation(messages) {
+    const sessionDir = this.getSessionDir();
+    writeFileSync(
+      join(sessionDir, "conversation.json"),
+      JSON.stringify(messages, null, 2)
+    );
+    const metadata = this.loadMetadata();
+    if (metadata) {
+      metadata.messageCount = messages.length;
+      metadata.updatedAt = Date.now();
+      writeFileSync(
+        join(sessionDir, "metadata.json"),
+        JSON.stringify(metadata, null, 2)
+      );
+    }
+  }
+  /**
+   * Load session memory
+   */
+  loadMemory() {
+    const memoryPath = join(this.getSessionDir(), "session_memory.json");
+    if (!existsSync(memoryPath)) return null;
+    try {
+      const content = readFileSync(memoryPath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Load session metadata
+   */
+  loadMetadata() {
+    const metadataPath = join(this.getSessionDir(), "metadata.json");
+    if (!existsSync(metadataPath)) return null;
+    try {
+      const content = readFileSync(metadataPath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Load conversation history
+   */
+  loadConversation() {
+    const convoPath = join(this.getSessionDir(), "conversation.json");
+    if (!existsSync(convoPath)) return null;
+    try {
+      const content = readFileSync(convoPath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Load decisions from current or previous session
+   */
+  loadDecisions() {
+    const decisionsPath = join(this.getSessionDir(), "decisions.json");
+    if (!existsSync(decisionsPath)) return [];
+    try {
+      const content = readFileSync(decisionsPath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * List all sessions for current project
+   */
+  listSessions() {
+    const projectDir = this.getProjectDir();
+    if (!existsSync(projectDir)) return [];
+    const sessions = [];
+    try {
+      const entries = readdirSync(projectDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory() && entry.name.startsWith("session-")) {
+          const metadataPath = join(projectDir, entry.name, "metadata.json");
+          if (existsSync(metadataPath)) {
+            try {
+              const content = readFileSync(metadataPath, "utf-8");
+              sessions.push(JSON.parse(content));
+            } catch {
+            }
+          }
+        }
+      }
+    } catch {
+    }
+    return sessions.sort((a, b) => b.updatedAt - a.updatedAt);
+  }
+  /**
+   * Get the most recent session for current project
+   */
+  getMostRecentSession() {
+    const sessions = this.listSessions();
+    if (sessions.length === 0) return null;
+    const mostRecent = sessions[0];
+    if (!mostRecent) return null;
+    const tempManager = new SessionMemoryManager("", mostRecent.sessionId);
+    Object.assign(tempManager, { projectHash: this.projectHash });
+    return {
+      metadata: mostRecent,
+      memory: tempManager.loadMemory() || {
+        summary: "",
+        decisions: [],
+        codeChanges: [],
+        toolUsageSummary: {},
+        focusAreas: [],
+        preservedContext: []
+      },
+      messages: tempManager.loadConversation() || void 0
+    };
+  }
+  /**
+   * Clean up old sessions (keep only N most recent)
+   */
+  cleanupOldSessions(keepCount = 5) {
+    const sessions = this.listSessions();
+    let cleaned = 0;
+    if (sessions.length <= keepCount) return 0;
+    const toDelete = sessions.slice(keepCount);
+    for (const session of toDelete) {
+      try {
+        const sessionDir = join(
+          this.getProjectDir(),
+          "session-" + session.sessionId
+        );
+        if (existsSync(sessionDir)) {
+          this.deleteDirectory(sessionDir);
+          cleaned++;
+        }
+      } catch {
+      }
+    }
+    return cleaned;
+  }
+  /**
+   * Check if a session exists
+   */
+  sessionExists() {
+    return existsSync(this.getSessionDir());
+  }
+  /**
+   * Get session directory path
+   */
+  getSessionDir() {
+    return join(this.getProjectDir(), "session-" + this.sessionId);
+  }
+  /**
+   * Get project directory path
+   */
+  getProjectDir() {
+    return join(this.baseDir, this.projectHash);
+  }
+  /**
+   * Ensure required directories exist
+   */
+  ensureDirectories() {
+    const sessionDir = this.getSessionDir();
+    if (!existsSync(sessionDir)) {
+      mkdirSync(sessionDir, { recursive: true });
+    }
+  }
+  /**
+   * Hash a path to create a safe directory name
+   */
+  hashPath(path) {
+    const normalized = resolve(path).toLowerCase();
+    return crypto.createHash("sha256").update(normalized).digest("hex").slice(0, 16);
+  }
+  /**
+   * Recursively delete a directory
+   */
+  deleteDirectory(dirPath) {
+    if (!existsSync(dirPath)) return;
+    const entries = readdirSync(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(dirPath, entry.name);
+      if (entry.isDirectory()) {
+        this.deleteDirectory(fullPath);
+      } else {
+        unlinkSync(fullPath);
+      }
+    }
+    rmdirSync(dirPath);
+  }
+}
+function createSessionMemory(projectPath, sessionId) {
+  return new SessionMemoryManager(projectPath, sessionId);
+}
+export {
+  SessionMemoryManager,
+  createSessionMemory
+};
+//# sourceMappingURL=sessionMemory.js.map

package/dist/services/sessionMemory.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/services/sessionMemory.ts"],
+  "sourcesContent": ["/**\n * Session Memory Service\n *\n * Provides persistent session memory for context compression.\n * Stores compressed contexts, decisions, and session metadata.\n *\n * Storage structure:\n * ~/.minto/projects/\n *   <project-hash>/\n *     session-<uuid>/\n *       session_memory.json    # Compressed context\n *       conversation.json      # Full conversation (optional)\n *       decisions.json         # Key decisions\n *       metadata.json          # Session metadata\n */\n\nimport {\n  existsSync,\n  mkdirSync,\n  readFileSync,\n  writeFileSync,\n  readdirSync,\n  unlinkSync,\n  rmdirSync,\n} from 'fs'\nimport { join, resolve } from 'path'\nimport { homedir } from 'os'\nimport crypto from 'crypto'\nimport type { Message } from '@query'\nimport type {\n  ExtractedDecision,\n  ExtractedCodeChange,\n} from './intelligentCompactor'\n\n/**\n * Session metadata\n */\nexport interface SessionMetadata {\n  sessionId: string\n  projectPath: string\n  projectHash: string\n  createdAt: number\n  updatedAt: number\n  messageCount: number\n  compressedAt?: number\n  compressionRatio?: number\n  focusArea?: string\n}\n\n/**\n * Session memory data\n */\nexport interface SessionMemoryData {\n  summary: string\n  decisions: ExtractedDecision[]\n  codeChanges: ExtractedCodeChange[]\n  toolUsageSummary: Record<string, number>\n  focusAreas: string[]\n  preservedContext: string[]\n}\n\n/**\n * Full session record\n */\nexport interface SessionRecord {\n  metadata: SessionMetadata\n  memory: SessionMemoryData\n  messages?: Message[]\n}\n\n/**\n * Session Memory Manager\n */\nexport class SessionMemoryManager {\n  private baseDir: string\n  private projectHash: string\n  private sessionId: string\n\n  constructor(projectPath: string, sessionId?: string) {\n    this.baseDir = join(homedir(), '.minto', 'projects')\n    this.projectHash = this.hashPath(projectPath)\n    this.sessionId = sessionId || crypto.randomUUID()\n    this.ensureDirectories()\n  }\n\n  /**\n   * Get the session ID\n   */\n  getSessionId(): string {\n    return this.sessionId\n  }\n\n  /**\n   * Get the project hash\n   */\n  getProjectHash(): string {\n    return this.projectHash\n  }\n\n  /**\n   * Save session memory\n   */\n  saveMemory(\n    memory: SessionMemoryData,\n    metadata?: Partial<SessionMetadata>,\n  ): void {\n    const sessionDir = this.getSessionDir()\n\n    const fullMetadata: SessionMetadata = {\n      sessionId: this.sessionId,\n      projectPath: '', // Will be set by caller\n      projectHash: this.projectHash,\n      createdAt: Date.now(),\n      updatedAt: Date.now(),\n      messageCount: 0,\n      ...this.loadMetadata(),\n      ...metadata,\n    }\n\n    // Save memory\n    writeFileSync(\n      join(sessionDir, 'session_memory.json'),\n      JSON.stringify(memory, null, 2),\n    )\n\n    // Save metadata\n    writeFileSync(\n      join(sessionDir, 'metadata.json'),\n      JSON.stringify(fullMetadata, null, 2),\n    )\n\n    // Save decisions separately for quick access\n    if (memory.decisions.length > 0) {\n      writeFileSync(\n        join(sessionDir, 'decisions.json'),\n        JSON.stringify(memory.decisions, null, 2),\n      )\n    }\n  }\n\n  /**\n   * Save full conversation (optional, for debugging/recovery)\n   */\n  saveConversation(messages: Message[]): void {\n    const sessionDir = this.getSessionDir()\n    writeFileSync(\n      join(sessionDir, 'conversation.json'),\n      JSON.stringify(messages, null, 2),\n    )\n\n    // Update metadata\n    const metadata = this.loadMetadata()\n    if (metadata) {\n      metadata.messageCount = messages.length\n      metadata.updatedAt = Date.now()\n      writeFileSync(\n        join(sessionDir, 'metadata.json'),\n        JSON.stringify(metadata, null, 2),\n      )\n    }\n  }\n\n  /**\n   * Load session memory\n   */\n  loadMemory(): SessionMemoryData | null {\n    const memoryPath = join(this.getSessionDir(), 'session_memory.json')\n    if (!existsSync(memoryPath)) return null\n\n    try {\n      const content = readFileSync(memoryPath, 'utf-8')\n      return JSON.parse(content) as SessionMemoryData\n    } catch {\n      return null\n    }\n  }\n\n  /**\n   * Load session metadata\n   */\n  loadMetadata(): SessionMetadata | null {\n    const metadataPath = join(this.getSessionDir(), 'metadata.json')\n    if (!existsSync(metadataPath)) return null\n\n    try {\n      const content = readFileSync(metadataPath, 'utf-8')\n      return JSON.parse(content) as SessionMetadata\n    } catch {\n      return null\n    }\n  }\n\n  /**\n   * Load conversation history\n   */\n  loadConversation(): Message[] | null {\n    const convoPath = join(this.getSessionDir(), 'conversation.json')\n    if (!existsSync(convoPath)) return null\n\n    try {\n      const content = readFileSync(convoPath, 'utf-8')\n      return JSON.parse(content) as Message[]\n    } catch {\n      return null\n    }\n  }\n\n  /**\n   * Load decisions from current or previous session\n   */\n  loadDecisions(): ExtractedDecision[] {\n    const decisionsPath = join(this.getSessionDir(), 'decisions.json')\n    if (!existsSync(decisionsPath)) return []\n\n    try {\n      const content = readFileSync(decisionsPath, 'utf-8')\n      return JSON.parse(content) as ExtractedDecision[]\n    } catch {\n      return []\n    }\n  }\n\n  /**\n   * List all sessions for current project\n   */\n  listSessions(): SessionMetadata[] {\n    const projectDir = this.getProjectDir()\n    if (!existsSync(projectDir)) return []\n\n    const sessions: SessionMetadata[] = []\n\n    try {\n      const entries = readdirSync(projectDir, { withFileTypes: true })\n      for (const entry of entries) {\n        if (entry.isDirectory() && entry.name.startsWith('session-')) {\n          const metadataPath = join(projectDir, entry.name, 'metadata.json')\n          if (existsSync(metadataPath)) {\n            try {\n              const content = readFileSync(metadataPath, 'utf-8')\n              sessions.push(JSON.parse(content) as SessionMetadata)\n            } catch {\n              // Skip invalid session\n            }\n          }\n        }\n      }\n    } catch {\n      // Return empty if directory cannot be read\n    }\n\n    return sessions.sort((a, b) => b.updatedAt - a.updatedAt)\n  }\n\n  /**\n   * Get the most recent session for current project\n   */\n  getMostRecentSession(): SessionRecord | null {\n    const sessions = this.listSessions()\n    if (sessions.length === 0) return null\n\n    const mostRecent = sessions[0]\n    if (!mostRecent) return null\n\n    const tempManager = new SessionMemoryManager('', mostRecent.sessionId)\n    // Hack to use the same project dir\n    Object.assign(tempManager, { projectHash: this.projectHash })\n\n    return {\n      metadata: mostRecent,\n      memory: tempManager.loadMemory() || {\n        summary: '',\n        decisions: [],\n        codeChanges: [],\n        toolUsageSummary: {},\n        focusAreas: [],\n        preservedContext: [],\n      },\n      messages: tempManager.loadConversation() || undefined,\n    }\n  }\n\n  /**\n   * Clean up old sessions (keep only N most recent)\n   */\n  cleanupOldSessions(keepCount: number = 5): number {\n    const sessions = this.listSessions()\n    let cleaned = 0\n\n    if (sessions.length <= keepCount) return 0\n\n    const toDelete = sessions.slice(keepCount)\n    for (const session of toDelete) {\n      try {\n        const sessionDir = join(\n          this.getProjectDir(),\n          'session-' + session.sessionId,\n        )\n        if (existsSync(sessionDir)) {\n          // Simple recursive delete using fs\n          this.deleteDirectory(sessionDir)\n          cleaned++\n        }\n      } catch {\n        // Continue with other sessions\n      }\n    }\n\n    return cleaned\n  }\n\n  /**\n   * Check if a session exists\n   */\n  sessionExists(): boolean {\n    return existsSync(this.getSessionDir())\n  }\n\n  /**\n   * Get session directory path\n   */\n  private getSessionDir(): string {\n    return join(this.getProjectDir(), 'session-' + this.sessionId)\n  }\n\n  /**\n   * Get project directory path\n   */\n  private getProjectDir(): string {\n    return join(this.baseDir, this.projectHash)\n  }\n\n  /**\n   * Ensure required directories exist\n   */\n  private ensureDirectories(): void {\n    const sessionDir = this.getSessionDir()\n    if (!existsSync(sessionDir)) {\n      mkdirSync(sessionDir, { recursive: true })\n    }\n  }\n\n  /**\n   * Hash a path to create a safe directory name\n   */\n  private hashPath(path: string): string {\n    const normalized = resolve(path).toLowerCase()\n    return crypto\n      .createHash('sha256')\n      .update(normalized)\n      .digest('hex')\n      .slice(0, 16)\n  }\n\n  /**\n   * Recursively delete a directory\n   */\n  private deleteDirectory(dirPath: string): void {\n    if (!existsSync(dirPath)) return\n\n    const entries = readdirSync(dirPath, { withFileTypes: true })\n    for (const entry of entries) {\n      const fullPath = join(dirPath, entry.name)\n      if (entry.isDirectory()) {\n        this.deleteDirectory(fullPath)\n      } else {\n        unlinkSync(fullPath)\n      }\n    }\n    rmdirSync(dirPath)\n  }\n}\n\n/**\n * Create a session memory manager for the current project\n */\nexport function createSessionMemory(\n  projectPath: string,\n  sessionId?: string,\n): SessionMemoryManager {\n  return new SessionMemoryManager(projectPath, sessionId)\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/services/taskRouter.js

@@ -0,0 +1,324 @@
+import { getModelManager } from "../utils/model.js";
+const DEFAULT_ROUTING_RULES = [
+  // Simple tasks → fast model
+  { pattern: "simple-query", model: "haiku", priority: 1 },
+  { pattern: "simple-generation", model: "haiku", priority: 1 },
+  // Moderate tasks → balanced model
+  { pattern: "moderate-query", model: "sonnet", priority: 2 },
+  { pattern: "moderate-generation", model: "sonnet", priority: 2 },
+  { pattern: "moderate-review", model: "sonnet", priority: 2 },
+  { pattern: "moderate-refactor", model: "sonnet", priority: 2 },
+  { pattern: "moderate-debug", model: "sonnet", priority: 2 },
+  // Complex tasks → powerful model
+  { pattern: "complex-reasoning", model: "opus", priority: 3 },
+  { pattern: "complex-architecture", model: "opus", priority: 3 },
+  { pattern: "complex-generation", model: "opus", priority: 3 },
+  { pattern: "complex-creative", model: "opus", priority: 3 },
+  // Specific task types
+  { pattern: "*-architecture", model: "opus", priority: 0 },
+  { pattern: "*-reasoning", model: "opus", priority: 0 },
+  { pattern: "*-review", model: "sonnet", priority: 1 },
+  { pattern: "*-debug", model: "sonnet", priority: 1 }
+];
+const ANALYSIS_PATTERNS = [
+  // Query patterns
+  {
+    name: "question",
+    patterns: [
+      /\b(what|how|why|when|where|who|which|can you explain)\b/i,
+      /\?$/,
+      /\b(tell me|show me|help me understand)\b/i
+    ],
+    type: "query",
+    complexityWeight: -0.2
+  },
+  // Generation patterns
+  {
+    name: "generation",
+    patterns: [
+      /\b(create|generate|write|build|implement|add|make)\b/i,
+      /\b(new|feature|function|class|component|module)\b/i
+    ],
+    type: "generation",
+    complexityWeight: 0.1
+  },
+  // Review patterns
+  {
+    name: "review",
+    patterns: [
+      /\b(review|check|analyze|examine|inspect|audit)\b/i,
+      /\b(code review|pull request|pr|merge)\b/i
+    ],
+    type: "review",
+    complexityWeight: 0
+  },
+  // Reasoning patterns
+  {
+    name: "reasoning",
+    patterns: [
+      /\b(think|reason|consider|evaluate|compare|decide)\b/i,
+      /\b(trade-?off|pros and cons|best approach|optimal)\b/i,
+      /\b(algorithm|complexity|performance|efficiency)\b/i
+    ],
+    type: "reasoning",
+    complexityWeight: 0.3
+  },
+  // Creative patterns
+  {
+    name: "creative",
+    patterns: [
+      /\b(creative|brainstorm|innovative|design|imagine)\b/i,
+      /\b(suggest|propose|come up with|ideas)\b/i
+    ],
+    type: "creative",
+    complexityWeight: 0.2
+  },
+  // Refactoring patterns
+  {
+    name: "refactor",
+    patterns: [
+      /\b(refactor|restructure|reorganize|clean up|improve)\b/i,
+      /\b(optimize|simplify|modularize|extract)\b/i
+    ],
+    type: "refactor",
+    complexityWeight: 0.15
+  },
+  // Debug patterns
+  {
+    name: "debug",
+    patterns: [
+      /\b(debug|fix|error|bug|issue|problem|crash)\b/i,
+      /\b(broken|doesn't work|failing|wrong)\b/i,
+      /\b(stack trace|exception|undefined|null)\b/i
+    ],
+    type: "debug",
+    complexityWeight: 0.1
+  },
+  // Architecture patterns
+  {
+    name: "architecture",
+    patterns: [
+      /\b(architect|design|system|infrastructure|scale)\b/i,
+      /\b(microservice|monolith|distributed|database)\b/i,
+      /\b(api design|schema|data model|integration)\b/i
+    ],
+    type: "architecture",
+    complexityWeight: 0.4
+  }
+];
+const COMPLEXITY_INDICATORS = {
+  simple: [
+    /\b(simple|quick|basic|easy|trivial|small)\b/i,
+    /\b(one line|single|just|only)\b/i
+  ],
+  complex: [
+    /\b(complex|difficult|challenging|advanced|comprehensive)\b/i,
+    /\b(entire|whole|all|complete|full|extensive)\b/i,
+    /\b(multiple|several|many|various)\b/i,
+    /\b(system|platform|framework|infrastructure)\b/i
+  ]
+};
+class TaskRouter {
+  routingRules = /* @__PURE__ */ new Map();
+  modelManager = getModelManager();
+  customRules = [];
+  constructor(customRules) {
+    this.loadRules(DEFAULT_ROUTING_RULES);
+    if (customRules) {
+      this.customRules = customRules;
+      this.loadRules(customRules);
+    }
+  }
+  /**
+   * Load routing rules into the map
+   */
+  loadRules(rules) {
+    const sorted = [...rules].sort((a, b) => a.priority - b.priority);
+    for (const rule of sorted) {
+      this.routingRules.set(rule.pattern, rule.model);
+    }
+  }
+  /**
+   * Analyze a task and return detailed analysis
+   */
+  analyzeTask(task) {
+    const detectedPatterns = [];
+    let complexityScore = 0.5;
+    let primaryType = "query";
+    let typeMatchCount = 0;
+    for (const pattern of ANALYSIS_PATTERNS) {
+      let matches = 0;
+      for (const regex of pattern.patterns) {
+        if (regex.test(task)) {
+          matches++;
+        }
+      }
+      if (matches > 0) {
+        detectedPatterns.push(pattern.name);
+        complexityScore += pattern.complexityWeight * (matches / pattern.patterns.length);
+        if (matches > typeMatchCount) {
+          typeMatchCount = matches;
+          primaryType = pattern.type;
+        }
+      }
+    }
+    for (const regex of COMPLEXITY_INDICATORS.simple) {
+      if (regex.test(task)) {
+        complexityScore -= 0.2;
+        detectedPatterns.push("simple-indicator");
+      }
+    }
+    for (const regex of COMPLEXITY_INDICATORS.complex) {
+      if (regex.test(task)) {
+        complexityScore += 0.2;
+        detectedPatterns.push("complex-indicator");
+      }
+    }
+    const wordCount = task.split(/\s+/).length;
+    if (wordCount < 10) {
+      complexityScore -= 0.1;
+    } else if (wordCount > 50) {
+      complexityScore += 0.1;
+    } else if (wordCount > 100) {
+      complexityScore += 0.2;
+    }
+    complexityScore = Math.max(0, Math.min(1, complexityScore));
+    let complexity;
+    if (complexityScore < 0.35) {
+      complexity = "simple";
+    } else if (complexityScore < 0.65) {
+      complexity = "moderate";
+    } else {
+      complexity = "complex";
+    }
+    const estimatedInputTokens = Math.ceil(task.length / 4);
+    const estimatedOutputTokens = this.estimateOutputTokens(
+      complexity,
+      primaryType
+    );
+    const suggestedModel = this.route(complexity, primaryType);
+    const confidence = typeMatchCount > 0 ? Math.min(
+      1,
+      0.5 + typeMatchCount * 0.15 + detectedPatterns.length * 0.05
+    ) : 0.5;
+    return {
+      complexity,
+      type: primaryType,
+      estimatedInputTokens,
+      estimatedOutputTokens,
+      suggestedModel,
+      confidence,
+      detectedPatterns: [...new Set(detectedPatterns)]
+    };
+  }
+  /**
+   * Route a task to the appropriate model
+   */
+  route(complexity, type) {
+    const exactKey = `${complexity}-${type}`;
+    if (this.routingRules.has(exactKey)) {
+      return this.routingRules.get(exactKey);
+    }
+    const wildcardKey = `*-${type}`;
+    if (this.routingRules.has(wildcardKey)) {
+      return this.routingRules.get(wildcardKey);
+    }
+    switch (complexity) {
+      case "simple":
+        return "haiku";
+      case "moderate":
+        return "sonnet";
+      case "complex":
+        return "opus";
+    }
+  }
+  /**
+   * Route a task directly from task text
+   */
+  routeTask(task) {
+    const analysis = this.analyzeTask(task);
+    return analysis.suggestedModel;
+  }
+  /**
+   * Estimate output tokens based on task type and complexity
+   */
+  estimateOutputTokens(complexity, type) {
+    const baseTokens = {
+      query: 200,
+      generation: 500,
+      review: 400,
+      reasoning: 600,
+      creative: 400,
+      refactor: 800,
+      debug: 500,
+      architecture: 1e3
+    };
+    const multipliers = {
+      simple: 0.5,
+      moderate: 1,
+      complex: 2
+    };
+    return Math.ceil(baseTokens[type] * multipliers[complexity]);
+  }
+  /**
+   * Add a custom routing rule
+   */
+  addRule(rule) {
+    this.customRules.push(rule);
+    this.routingRules.set(rule.pattern, rule.model);
+  }
+  /**
+   * Remove a routing rule
+   */
+  removeRule(pattern) {
+    const index = this.customRules.findIndex((r) => r.pattern === pattern);
+    if (index >= 0) {
+      this.customRules.splice(index, 1);
+      this.routingRules.delete(pattern);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Get all current routing rules
+   */
+  getRules() {
+    return [...DEFAULT_ROUTING_RULES, ...this.customRules];
+  }
+  /**
+   * Get cost estimate for a task
+   */
+  estimateCost(task) {
+    const analysis = this.analyzeTask(task);
+    return {
+      model: analysis.suggestedModel,
+      estimatedInputTokens: analysis.estimatedInputTokens,
+      estimatedOutputTokens: analysis.estimatedOutputTokens,
+      estimatedTotalTokens: analysis.estimatedInputTokens + analysis.estimatedOutputTokens
+    };
+  }
+}
+let routerInstance = null;
+function getTaskRouter() {
+  if (!routerInstance) {
+    routerInstance = new TaskRouter();
+  }
+  return routerInstance;
+}
+function resetTaskRouter() {
+  routerInstance = null;
+}
+function routeTask(task) {
+  return getTaskRouter().routeTask(task);
+}
+function analyzeTask(task) {
+  return getTaskRouter().analyzeTask(task);
+}
+export {
+  TaskRouter,
+  analyzeTask,
+  getTaskRouter,
+  resetTaskRouter,
+  routeTask
+};
+//# sourceMappingURL=taskRouter.js.map