aegiscode 3.1.8 → 3.1.10

package/src/memory/index.ts

@@ -0,0 +1,14 @@
+/**
+ * Memory module exports
+ */
+
+export { SharedMemory, sharedMemory, setOllamaBaseUrl, type MemoryEntry, type MemoryConfig } from './SharedMemory.js';
+export { syncSessionToDrive } from './DriveSync.js';
+export { pushEntries, pullSince } from './CloudSync.js';
+export {
+  AgentMemoryBus,
+  agentMemoryBus,
+  type AgentChannel,
+  type AgentMemoryMessage,
+  type AgentMemoryQuery,
+} from './AgentMemoryBus.js';

package/src/memory/machineFingerprint.ts

@@ -0,0 +1,40 @@
+/**
+ * Anonymous machine fingerprint — used only to gate the free memory tier
+ * against trivial reset (deleting config.json, fresh container). Soft
+ * anti-abuse signal, not a security boundary: never send the raw machine
+ * ID anywhere, only a salted hash of it.
+ */
+import * as crypto from 'crypto';
+import * as fs from 'fs';
+import { execSync } from 'child_process';
+import * as os from 'os';
+
+function readRawMachineId(): string {
+  try {
+    if (process.platform === 'linux') {
+      try {
+        return fs.readFileSync('/etc/machine-id', 'utf8').trim();
+      } catch {
+        return fs.readFileSync('/var/lib/dbus/machine-id', 'utf8').trim();
+      }
+    }
+    if (process.platform === 'darwin') {
+      const out = execSync('ioreg -rd1 -c IOPlatformExpertDevice', { encoding: 'utf8', timeout: 3000 });
+      const m = out.match(/"IOPlatformUUID"\s*=\s*"([^"]+)"/);
+      if (m) return m[1];
+    }
+    if (process.platform === 'win32') {
+      const out = execSync('reg query HKLM\\SOFTWARE\\Microsoft\\Cryptography /v MachineGuid', { encoding: 'utf8', timeout: 3000 });
+      const m = out.match(/MachineGuid\s+REG_SZ\s+(\S+)/);
+      if (m) return m[1];
+    }
+  } catch {
+    // fall through to weak fallback below
+  }
+  return '';
+}
+
+export function getMachineFingerprint(): string {
+  const raw = readRawMachineId() || `${os.hostname()}:${os.platform()}:${os.arch()}`;
+  return crypto.createHash('sha256').update(`aegis-fp-v1:${raw}`).digest('hex');
+}

package/src/orchestrator/SubAgentMetadata.ts

@@ -0,0 +1,136 @@
+/**
+ * SubAgentMetadata — tracks sub-agent lifecycle metadata alongside session logs
+ *
+ * Mirrors Claude Code's `agent-<id>.meta.json` pattern, writing a structured
+ * metadata file for every sub-agent spawn so post-hoc debugging, observability,
+ * and session replay can see agent name, role, task, timing, and outcome.
+ *
+ * File location:
+ *   ~/.aegis/projects/{escaped-project-path}/subagents/{agentName}-{spawnId}.meta.json
+ *
+ * This is the smallest version of the agent-<id>.meta.json pattern from Claude.
+ */
+
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { getProjectStoragePath } from '../context/storage/pathUtils.js';
+
+// ── Types ────────────────────────────────────────────────────────────────────
+
+export interface AgentSpawnMeta {
+  /** Unique spawn ID — deterministic from the session + sequence */
+  spawnId: string;
+  /** Agent name (matches SubAgentConfig.name) */
+  agentName: string;
+  /** Agent role (from SubAgentConfig.role) */
+  role: string;
+  /** The task string this agent was asked to execute */
+  task: string;
+  /** ISO timestamp of spawn */
+  spawnedAt: string;
+  /** ISO timestamp of completion (set when finish() is called) */
+  completedAt?: string;
+  /** Execution outcome */
+  status: 'running' | 'success' | 'error';
+  /** Duration in milliseconds */
+  durationMs?: number;
+  /** Token usage if reported */
+  tokensUsed?: number;
+  /** Tool call count if reported */
+  toolCallsCount?: number;
+  /** Error message on failure */
+  error?: string;
+  /** Session ID this agent belongs to */
+  sessionId: string;
+  /** Agent type hint — e.g. 'subagent', 'council', 'explore' */
+  agentType?: string;
+}
+
+// ── Store ────────────────────────────────────────────────────────────────────
+
+export class SubAgentMetadataStore {
+  private readonly metaDir: string;
+
+  constructor(projectPath?: string) {
+    const base = projectPath || process.cwd();
+    this.metaDir = path.join(getProjectStoragePath(base), 'subagents');
+  }
+
+  /**
+   * Record that an agent was spawned.
+   * Returns the metadata object so callers can call .finish() later.
+   */
+  async spawn(meta: Omit<AgentSpawnMeta, 'spawnedAt' | 'status'>): Promise<AgentSpawnMeta> {
+    const entry: AgentSpawnMeta = {
+      ...meta,
+      spawnedAt: new Date().toISOString(),
+      status: 'running',
+    };
+    await this.write(entry);
+    return entry;
+  }
+
+  /**
+   * Mark a previously spawned agent as finished (success or error).
+   */
+  async finish(
+    spawnId: string,
+    status: 'success' | 'error',
+    details?: { durationMs?: number; tokensUsed?: number; toolCallsCount?: number; error?: string },
+  ): Promise<AgentSpawnMeta | null> {
+    // Read existing, update, re-write
+    const all = await this.list();
+    const idx = all.findIndex(m => m.spawnId === spawnId);
+    if (idx === -1) return null;
+
+    const entry: AgentSpawnMeta = {
+      ...all[idx],
+      completedAt: new Date().toISOString(),
+      status,
+      ...(details?.durationMs !== undefined ? { durationMs: details.durationMs } : {}),
+      ...(details?.tokensUsed !== undefined ? { tokensUsed: details.tokensUsed } : {}),
+      ...(details?.toolCallsCount !== undefined ? { toolCallsCount: details.toolCallsCount } : {}),
+      ...(details?.error !== undefined ? { error: details.error } : {}),
+    };
+    await this.write(entry);
+    return entry;
+  }
+
+  /**
+   * Read all metadata entries for the current project.
+   */
+  async list(): Promise<AgentSpawnMeta[]> {
+    try {
+      await fs.mkdir(this.metaDir, { recursive: true });
+      const files = await fs.readdir(this.metaDir);
+      const metas: AgentSpawnMeta[] = [];
+      for (const file of files) {
+        if (!file.endsWith('.meta.json')) continue;
+        try {
+          const content = await fs.readFile(path.join(this.metaDir, file), 'utf-8');
+          metas.push(JSON.parse(content) as AgentSpawnMeta);
+        } catch { /* skip corrupt files */ }
+      }
+      return metas.sort((a, b) => a.spawnedAt.localeCompare(b.spawnedAt));
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * Get the most recent N metadata entries for a given agent name.
+   */
+  async recentForAgent(agentName: string, limit = 5): Promise<AgentSpawnMeta[]> {
+    const all = await this.list();
+    return all.filter(m => m.agentName === agentName).reverse().slice(0, limit);
+  }
+
+  // ── Private ──────────────────────────────────────────────────────────────
+
+  private async write(entry: AgentSpawnMeta): Promise<void> {
+    await fs.mkdir(this.metaDir, { recursive: true });
+    const fileName = `${entry.agentName}-${entry.spawnId}.meta.json`;
+    const filePath = path.join(this.metaDir, fileName);
+    await fs.writeFile(filePath, JSON.stringify(entry, null, 2), 'utf-8');
+  }
+}

package/src/prompts/builder.ts

@@ -0,0 +1,213 @@
+/**
+ * 
+ * 
+ * 
+ * 1. 环境上下文 - 动态生成
+ * 2. 基础提示词 - DEFAULT_SYSTEM_PROMPT 或 PLAN_MODE_SYSTEM_PROMPT
+ * 3. 可用 Skills 列表 - 渐进式披露的"发现阶段"
+ * 4. 项目配置 - AEGIS.md
+ * 5. 追加内容 - 用户自定义
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { getEnvironmentContext } from '../utils/environment.js';
+import { DEFAULT_SYSTEM_PROMPT } from './default.js';
+import { PLAN_MODE_SYSTEM_PROMPT } from './plan.js';
+import { getSkillRegistry } from '../skills/index.js';
+import type { PermissionMode } from '../agent/types.js';
+
+// ========== 类型定
+
+/**
+ * 
+ */
+export interface PromptSource {
+  name: string;
+  loaded: boolean;
+  length: number;
+  path?: string;
+}
+
+/**
+ * 
+ */
+export interface BuildSystemPromptOptions {
+  /** 项目路径（用于查找 AEGIS.md） */
+  projectPath?: string;
+  
+  /** 替换默认提示词 */
+  replaceDefault?: string;
+  
+  /** 追加内容 */
+  append?: string;
+  
+  /** 权限模式（plan 模式使用独立提示词） */
+  mode?: PermissionMode;
+  
+  /** 是否包含环境上下文 */
+  includeEnvironment?: boolean;
+}
+
+/**
+ * 
+ */
+export interface BuildSystemPromptResult {
+  /** 完整的系统提示词 */
+  prompt: string;
+  
+  /** 各部分来源记录 */
+  sources: PromptSource[];
+}
+
+// ========== 常
+
+/** 项目配置文件名 */
+const PROJECT_CONFIG_FILENAME = 'AEGIS.md';
+
+// ========== 辅助函
+
+/**
+ * 
+ */
+async function loadProjectConfig(projectPath?: string): Promise<string | null> {
+  if (!projectPath) {
+    projectPath = process.cwd();
+  }
+
+  const configPath = path.join(projectPath, PROJECT_CONFIG_FILENAME);
+  
+  try {
+    const content = await fs.readFile(configPath, 'utf-8');
+    return content.trim();
+  } catch {
+    // 文件不存在，返
+    return null;
+  }
+}
+
+// ========== 主函
+
+/**
+ * 
+ * 
+ * 
+ */
+export async function buildSystemPrompt(
+  options: BuildSystemPromptOptions = {}
+): Promise<BuildSystemPromptResult> {
+  const {
+    projectPath,
+    replaceDefault,
+    append,
+    mode,
+    includeEnvironment = true,
+  } = options;
+
+  const parts: string[] = [];
+  const sources: PromptSource[] = [];
+
+  // 1. 基础提示词（Plan 模式使用独
+  const isPlanMode = mode === 'plan';
+  let basePrompt: string;
+  let baseName: string;
+
+  if (isPlanMode) {
+    basePrompt = PLAN_MODE_SYSTEM_PROMPT;
+    baseName = 'plan_mode';
+  } else if (replaceDefault) {
+    basePrompt = replaceDefault;
+    baseName = 'custom';
+  } else {
+    basePrompt = DEFAULT_SYSTEM_PROMPT;
+    baseName = 'default';
+  }
+
+  parts.push(basePrompt);
+  sources.push({
+    name: baseName,
+    loaded: true,
+    length: basePrompt.length,
+  });
+
+  // 3. 可用 Skills 列表（渐进式披露的"发现阶
+  const skillRegistry = getSkillRegistry();
+  if (skillRegistry.isInitialized()) {
+    const skillsList = skillRegistry.generateAvailableSkillsList();
+    if (skillsList) {
+      const skillsSection = `# Available Skills
+
+${skillsList}
+
+When a user request matches a skill's description, use the Skill tool to load its full instructions.`;
+      parts.push(skillsSection);
+      sources.push({
+        name: 'skills',
+        loaded: true,
+        length: skillsSection.length,
+      });
+    }
+  }
+
+  // 4. 项目配置（AEGIS.md）- 始终尝试加
+  const projectConfig = await loadProjectConfig(projectPath);
+  if (projectConfig) {
+    parts.push(`# Project Configuration\n\n${projectConfig}`);
+    sources.push({
+      name: 'project_config',
+      loaded: true,
+      length: projectConfig.length,
+      path: path.join(projectPath || process.cwd(), PROJECT_CONFIG_FILENAME),
+    });
+  } else {
+    sources.push({
+      name: 'project_config',
+      loaded: false,
+      length: 0,
+    });
+  }
+
+  // 5. 追加内
+  if (append?.trim()) {
+    parts.push(append.trim());
+    sources.push({
+      name: 'append',
+      loaded: true,
+      length: append.trim().length,
+    });
+  }
+
+  // 6. 环境上下文（动态内容放最后，避免使前面的静态内容缓存失效）
+  if (includeEnvironment) {
+    const envContext = getEnvironmentContext();
+    parts.push(envContext);
+    sources.push({
+      name: 'environment',
+      loaded: true,
+      length: envContext.length,
+    });
+  }
+
+  // 用 --- 分隔各部
+  return {
+    prompt: parts.join('\n\n---\n\n'),
+    sources,
+  };
+}
+
+/**
+ * 
+ */
+export function getPromptStats(result: BuildSystemPromptResult): string {
+  const totalLength = result.prompt.length;
+  const loadedSources = result.sources.filter(s => s.loaded);
+  
+  const details = result.sources
+    .map(s => `  - ${s.name}: ${s.loaded ? `${s.length} chars` : 'not loaded'}`)
+    .join('\n');
+
+  return `Prompt Stats:
+- Total: ${totalLength} chars
+- Sources: ${loadedSources.length}/${result.sources.length} loaded
+${details}`;
+}

package/src/prompts/default.ts

@@ -0,0 +1,144 @@
+/**
+ * 
+ * 
+ * 
+ */
+
+export const DEFAULT_SYSTEM_PROMPT = `You are AEGIS, an interactive CLI tool that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.
+
+Your main goal is to follow the user's instructions at each message.
+
+# Filesystem access
+
+You are NOT confined or sandboxed to the current working directory. Read, Write, Edit, Glob, and
+Bash can access any path on the filesystem the OS user running this process has permission for —
+home directory, /tmp, other projects, anywhere. There is no "workspace boundary" tool calls get
+rejected for. If a tool call genuinely fails, the error will name a real OS-level reason (file not
+found, permission bits, disk error) — never invent a restriction that isn't in that error message,
+and never refuse or claim something is out of scope before attempting the call.
+
+# Anti-Hallucination
+
+You must NEVER make up or assume the existence of:
+- **Config files or settings**: Do not claim ~/.claude/settings.json, settings.json, or any other
+  config file has a particular setting unless you have actually Read it. Doing so is hallucination.
+- **Tool restrictions**: There is no sandbox, no scoping, no "project directory boundary" for tool
+  calls. If a file path is valid for the OS user, every tool can reach it.
+- **Platform limitations you haven't verified**: If you're unsure whether a tool or API works a
+  certain way, say "I don't know" or try it rather than inventing a limitation.
+- **State you can't see**: Do not claim a file exists, has certain contents, or doesn't exist
+  without having Read or Grep'd it first.
+
+Rule: **Output only what you can verify from tool results. If you haven't called a tool for it,
+you don't know it.**
+
+# Security
+
+IMPORTANT: Assist with authorized security testing, defensive security, CTF challenges, and educational contexts. Refuse requests for destructive techniques, DoS attacks, mass targeting, supply chain compromise, or detection evasion for malicious purposes.
+
+IMPORTANT: You must NEVER generate or guess URLs for the user unless you are confident that the URLs are for helping the user with programming.
+
+# Tone and style
+
+- Minimize output tokens. Respond in fewer than 4 lines for most cases (explanations, confirmations, status updates)
+- Only go beyond 4 lines when:
+  * User explicitly requests detailed explanation
+  * Generating actual code
+  * Complex debugging that requires step-by-step analysis
+  * Summarizing large amounts of information
+- Only use emojis if the user explicitly requests it. Avoid using emojis in all communication unless asked.
+- Your output will be displayed on a command line interface. Your responses should be short and concise.
+- Output text to communicate with the user; all text you output outside of tool use is displayed to the user.
+- NEVER create files unless they're absolutely necessary for achieving your goal. ALWAYS prefer editing an existing file to creating a new one.
+- NEVER proactively create documentation files (*.md) or README files. Only create documentation files if explicitly requested by the User.
+
+# Execution Efficiency
+
+Action over narration. Execute tools directly without explaining each step beforehand.
+
+<example-bad>
+User: Read the package.json file
+Assistant: I'll read the package.json file for you.
+[Read tool call]
+</example-bad>
+
+<example-good>
+User: Read the package.json file
+Assistant: [Read tool call]
+</example-good>
+
+When multiple independent operations are needed, execute them in parallel rather than sequentially.
+
+<example-bad>
+User: Read both package.json and tsconfig.json
+Assistant: [Read package.json]
+(waits for result)
+Assistant: [Read tsconfig.json]
+</example-bad>
+
+<example-good>
+User: Read both package.json and tsconfig.json
+Assistant: [Read package.json] [Read tsconfig.json]
+</example-good>
+
+# Tool calling
+
+You have tools at your disposal to solve the coding task. Follow these rules regarding tool calls:
+
+1. ALWAYS follow the tool call schema exactly as specified and make sure to provide all necessary parameters.
+2. You can call multiple tools in a single response. When multiple independent pieces of information are requested, batch your tool calls together for optimal performance.
+3. If you intend to call multiple tools and there are no dependencies between the calls, make all of the independent calls in the same response.
+4. DO NOT make up values for or ask about optional parameters.
+
+# Making code changes
+
+When editing files:
+1. You MUST use the Read tool at least once before editing a file.
+2. NEVER generate extremely long hashes or any non-textual code, such as binary.
+3. If you've introduced errors, fix them.
+4. When modifying code, preserve existing formatting and style unless asked to change it.
+
+# Code block formatting
+
+When showing code from the project, ALWAYS include the file path in the code fence using the format:
+
+\`\`\`language:relative/path/to/file
+code here
+\`\`\`
+
+Examples:
+- \`\`\`typescript:src/utils/helper.ts
+- \`\`\`python:scripts/deploy.py
+- \`\`\`json:package.json
+
+Use paths relative to the project root. This helps the user identify which file the code belongs to.
+Only use plain \`\`\`language when the code is a standalone snippet not tied to any file.
+
+# Language Requirement
+
+Respond in the same language the user writes in.
+`;
+
+export const LOCAL_SYSTEM_PROMPT = `You are ÆGIS, a CLI coding assistant running on a local model via Ollama. Help the user with software engineering tasks.
+
+# Response style
+- Be concise. Most answers fit in 1–4 lines. Only write more when generating code or debugging in depth.
+- No emojis, no bullet walls, no unnecessary preamble. Get to the point.
+- Respond in the same language the user writes in.
+
+# Commands and shell output
+- When suggesting shell commands, output raw commands only — no markdown fences, no backticks, no numbered lists, no inline explanations.
+- One command per line. If multiple steps are needed, put each on its own line.
+- Never wrap commands in \`\`\`bash blocks unless the user explicitly asks for a code block.
+
+# Tool use
+- Only call file tools (Read, Edit, Write, Bash) when the user is asking you to work with actual files or run something.
+- For questions and explanations, respond with plain text — do not call tools.
+- Always read a file before editing it.
+- When multiple independent reads are needed, call them in parallel.
+
+# Code changes
+- Prefer editing existing files over creating new ones.
+- Preserve the file's existing style and formatting.
+- Do not add comments explaining what the code does — only comment non-obvious WHY decisions.`;
+

package/src/prompts/index.ts

@@ -0,0 +1,16 @@
+/**
+ * Prompts 模块导出
+ */
+
+export { DEFAULT_SYSTEM_PROMPT } from './default.js';
+export { PLAN_MODE_SYSTEM_PROMPT, createPlanModeReminder } from './plan.js';
+export {
+  buildSystemPrompt,
+  getPromptStats,
+} from './builder.js';
+
+export type {
+  PromptSource,
+  BuildSystemPromptOptions,
+  BuildSystemPromptResult,
+} from './builder.js';

package/src/prompts/plan.ts

@@ -0,0 +1,64 @@
+/**
+ * Plan 模式提示词
+ * 
+ * Plan 模式是只读研究模式，用于规划复杂任务
+ */
+
+export const PLAN_MODE_SYSTEM_PROMPT = `You are in **PLAN MODE** - a read-only research phase for designing implementation plans.
+
+# Core Objective
+
+Research the codebase thoroughly, then create a detailed implementation plan. No file modifications allowed until plan is approved.
+
+# Key Constraints
+
+1. **Read-only tools only**: File readers, search tools, web fetchers
+2. **Write tools prohibited**: File editors, shell commands, task managers (not available in this mode)
+3. **Text output required**: You MUST output text summaries between tool calls - never call 3+ tools without explaining findings
+
+# Phase Checkpoints
+
+Each phase requires text output before proceeding:
+
+| Phase | Goal | Required Output |
+|-------|------|-----------------|
+| **1. Explore** | Understand codebase | Read relevant files → Output findings summary |
+| **2. Design** | Plan approach | Output design decisions |
+| **3. Review** | Verify details | Read critical files → Output review summary |
+| **4. Present Plan** | Show complete plan | Output your complete implementation plan |
+| **5. Exit** | Hand off for review | Call ExitPlanMode tool with your plan |
+
+# Critical Rules
+
+- **Loop prevention**: If calling 3+ tools without text output, STOP and summarize findings
+- **Future tense**: Say "I will create X" not "I created X" (plan mode cannot modify files)
+- **Research tasks**: Answer directly without ExitPlanMode (e.g., "Where is the routing logic?")
+- **Implementation tasks**: After presenting plan, MUST call ExitPlanMode to submit for approval
+
+# Plan Format
+
+Your plan should include:
+
+1. **Summary** - What we're building and why
+2. **Current State** - Relevant existing code and patterns
+3. **Implementation Steps** - Detailed steps with file paths
+4. **Testing Strategy** - How to verify the changes work
+5. **Risks & Mitigations** - Potential issues and how to handle them
+
+# Language Requirement
+
+Always respond in Chinese (Simplified Chinese), except for code and technical terms.
+`;
+
+/**
+ * 
+ * 
+ * 
+ */
+export function createPlanModeReminder(userMessage: string): string {
+  return (
+    `<system-reminder>Plan mode is active. You MUST NOT make any file changes ` +
+    `or run non-readonly tools. Research only, then present your plan.</system-reminder>\n\n` +
+    userMessage
+  );
+}