aegiscode 3.1.8 → 3.1.10

package/src/slash-commands/clone.ts

@@ -0,0 +1,242 @@
+/**
+ * /clone — Clone any website via DeepSeek API
+ *
+ * Fetches a URL's HTML, sends it to DeepSeek for analysis,
+ * and recreates it as a local project you can customize.
+ *
+ * Usage:
+ *   /clone https://example.com
+ *   /clone https://example.com --name my-project
+ */
+
+import type { SlashCommand, SlashCommandResult, SlashCommandContext } from './types.js';
+import { createChatService } from '../services/ChatService.js';
+
+const C = {
+  cyan:   '\x1b[38;2;0;229;192m',
+  purple: '\x1b[38;2;124;111;212m',
+  green:  '\x1b[38;2;34;197;94m',
+  red:    '\x1b[38;2;239;68;68m',
+  muted:  '\x1b[38;2;68;64;90m',
+  bold:   '\x1b[1m',
+  reset:  '\x1b[0m',
+};
+
+interface CloneOptions {
+  url: string;
+  name?: string;
+}
+
+function parseArgs(args: string): CloneOptions {
+  const parts = args.trim().split(/\s+/);
+  let url = '';
+  let name = '';
+
+  for (let i = 0; i < parts.length; i++) {
+    if (parts[i] === '--name' && i + 1 < parts.length) {
+      name = parts[++i];
+    } else if (!url) {
+      url = parts[i];
+    }
+  }
+
+  return { url, name };
+}
+
+async function fetchHtml(url: string): Promise<string> {
+  const { execSync } = await import('node:child_process');
+
+  // Use curl with a realistic User-Agent to get the actual page content
+  const cmd = [
+    'curl',
+    '-s',                         // silent
+    '-L',                         // follow redirects
+    '--max-time', '15',           // timeout after 15s
+    '--connect-timeout', '10',
+    '-H', `'User-Agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36'`,
+    '-H', `'Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8'`,
+    `'${url}'`,
+  ].join(' ');
+
+  try {
+    const html = execSync(cmd, { encoding: 'utf-8', maxBuffer: 5 * 1024 * 1024 });
+    // Truncate very large pages to avoid token limits
+    return html.length > 80000 ? html.slice(0, 80000) + '\n<!-- [truncated] -->' : html;
+  } catch (e: any) {
+    throw new Error(`Failed to fetch ${url}: ${e.stderr?.toString() || e.message}`);
+  }
+}
+
+function pickDeepSeekModel(): { apiKey: string; baseURL: string; model: string } | null {
+  if (process.env.DEEPSEEK_API_KEY) {
+    return {
+      apiKey: process.env.DEEPSEEK_API_KEY,
+      baseURL: 'https://api.deepseek.com/v1',
+      model: 'deepseek-chat',
+    };
+  }
+  return null;
+}
+
+const CLONE_SYSTEM_PROMPT = `You are a senior web developer. Your job is to analyze HTML from a reference website and recreate it as a customizable local project.
+
+Rules:
+1. Create a complete, self-contained HTML page that captures the visual structure, layout, and design of the reference
+2. Replace all brand-specific content with placeholder text (change company name, use "My Site" / "Your Brand")
+3. Replace all external URLs (images, links, APIs) with relative paths or placeholders
+4. Inline all CSS in a <style> tag — no external stylesheets
+5. Make the page responsive (mobile-friendly)
+6. Add a comment at the top showing the original source URL
+7. Output ONLY valid HTML — no explanations, no markdown
+
+The output must be a single HTML file that works when opened in a browser.`;
+
+async function cloneSite(opts: CloneOptions, output: (s: string) => void): Promise<string> {
+  const html = await fetchHtml(opts.url);
+
+  const ds = pickDeepSeekModel();
+  if (!ds) {
+    throw new Error(
+      'DeepSeek API key not found.\n' +
+      'Set DEEPSEEK_API_KEY in ~/.aegiscode/.env or as an environment variable.\n' +
+      'Get a key at: https://platform.deepseek.com/'
+    );
+  }
+
+  const chat = createChatService({
+    apiKey: ds.apiKey,
+    baseURL: ds.baseURL,
+    model: ds.model,
+    timeout: 120_000,
+  });
+
+  output(`${C.muted}  Analyzing ${opts.url} (${(html.length / 1024).toFixed(1)}KB HTML)${C.reset}\n`);
+  output(`${C.muted}  Using DeepSeek to recreate…${C.reset}\n`);
+
+  const response = await chat.chat([
+    { role: 'system', content: CLONE_SYSTEM_PROMPT },
+    { role: 'user', content: `Here is the HTML of the reference website from ${opts.url}:\n\n\`\`\`html\n${html}\n\`\`\`\n\nRecreate this page as described. Output ONLY the HTML.` },
+  ]);
+
+  // Extract HTML from response (strip markdown fences if any)
+  let resultHtml = response.content.trim();
+  resultHtml = resultHtml.replace(/^```(?:html)?\n?/i, '').replace(/\n?```$/i, '').trim();
+
+  if (!resultHtml) {
+    throw new Error('DeepSeek returned empty response');
+  }
+
+  return resultHtml;
+}
+
+export const cloneCommand: SlashCommand = {
+  name: 'clone',
+  aliases: ['fetch-site', 'websnap'],
+  description: 'Clone any website using DeepSeek — /clone <url> [--name <project>]',
+  category: 'skills',
+  usage: '/clone <url> [--name <project-name>]',
+  examples: [
+    '/clone https://example.com',
+    '/clone https://example.com --name my-landing',
+    '/clone https://tailwindcss.com --name tailwind-clone',
+  ],
+  fullDescription: `Website cloner powered by DeepSeek.
+
+Fetches a URL's HTML, sends it to DeepSeek for analysis,
+and recreates it as a local HTML file you can customize.
+
+The cloned page:
+- Replaces brand content with placeholders
+- Inlines all CSS
+- Makes it responsive
+- Works standalone in a browser
+
+Requires DEEPSEEK_API_KEY in your environment.`,
+
+  async handler(args: string, context: SlashCommandContext): Promise<SlashCommandResult> {
+    const opts = parseArgs(args);
+    if (!opts.url) {
+      return {
+        success: false,
+        type: 'error',
+        error: 'Usage: /clone <url> [--name <project-name>]\n' +
+               'Example: /clone https://example.com --name my-landing',
+      };
+    }
+
+    // Validate URL
+    try {
+      new URL(opts.url);
+    } catch {
+      return { success: false, type: 'error', error: `Invalid URL: ${opts.url}` };
+    }
+
+    const cwd = context.cwd || process.cwd();
+    const projectName = opts.name || opts.url.replace(/https?:\/\//, '').replace(/\/$/, '').replace(/[^a-zA-Z0-9_-]/g, '-');
+    const outputDir = `${cwd}/${projectName}`;
+
+    const stripAnsi = (s: string) => s.replace(/\x1b\[[0-9;]*m/g, '');
+    const log = (s: string) => {
+      if (context.onContentDelta) {
+        context.onContentDelta(stripAnsi(s) + '\n');
+      } else {
+        process.stdout.write(s + '\n');
+      }
+    };
+
+    log(`\n${C.cyan}${C.bold}⬡ CLONE${C.reset}`);
+    log(`${C.muted}  Source: ${opts.url}${C.reset}`);
+    log(`${C.muted}  Output: ${projectName}/${C.reset}\n`);
+
+    try {
+      const fs = await import('node:fs');
+      const path = await import('node:path');
+
+      // Create output directory
+      fs.mkdirSync(outputDir, { recursive: true });
+
+      // Clone the site
+      const html = await cloneSite(opts, log);
+
+      // Write the HTML file
+      const outputFile = path.join(outputDir, 'index.html');
+      fs.writeFileSync(outputFile, html, 'utf-8');
+
+      // Write a simple README
+      const readme = `# ${projectName}
+
+Website cloned from [${opts.url}](${opts.url}) using AEGIS Code + DeepSeek.
+
+## Files
+
+- \`index.html\` — Cloned website (standalone, open in browser)
+
+## Customize
+
+Edit \`index.html\` to replace placeholder content with your own.
+`;
+      fs.writeFileSync(path.join(outputDir, 'README.md'), readme, 'utf-8');
+
+      const filesize = (html.length / 1024).toFixed(1);
+
+      log(`\n${C.green}✓${C.reset} Created ${C.cyan}${projectName}/index.html${C.reset} (${filesize}KB)`);
+      log(`${C.muted}  ${outputFile}${C.reset}`);
+      log(`\n${C.bold}Done!${C.reset} Open index.html in your browser or edit it to make it yours.`);
+
+      // Save a session note
+      const note = `[clone] Created ${projectName}/ — cloned from ${opts.url}`;
+      try {
+        const sessionFile = path.join(outputDir, '.aegis-clone');
+        fs.writeFileSync(sessionFile, JSON.stringify({ source: opts.url, clonedAt: new Date().toISOString(), project: projectName }, null, 2), 'utf-8');
+      } catch {}
+
+      return { success: true, type: 'silent' };
+    } catch (error: any) {
+      return {
+        success: false,
+        type: 'error',
+        error: `Clone failed: ${error.message}`,
+      };
+    }
+  },
+};

package/src/slash-commands/council.ts

@@ -0,0 +1,125 @@
+/**
+ * /council — AEGIS Council Vote
+ * Three AI agents deliberate and vote via API directly
+ */
+
+const C = {
+  teal:   '\x1b[38;2;0;229;192m',
+  purple: '\x1b[38;2;124;111;212m',
+  pink:   '\x1b[38;2;244;114;182m',
+  orange: '\x1b[38;2;249;115;22m',
+  green:  '\x1b[38;2;34;197;94m',
+  red:    '\x1b[38;2;239;68;68m',
+  muted:  '\x1b[38;2;68;64;90m',
+  bold:   '\x1b[1m',
+  reset:  '\x1b[0m',
+};
+
+interface Agent {
+  name: string;
+  role: string;
+  color: string;
+  call: (question: string) => Promise<{ vote: string; analysis: string }>;
+}
+
+async function callOpenAICompatible(baseUrl: string, apiKey: string, model: string, question: string, persona: string): Promise<{ vote: string; analysis: string }> {
+  const res = await fetch(`${baseUrl}/chat/completions`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` },
+    body: JSON.stringify({
+      model,
+      max_tokens: 300,
+      messages: [{
+        role: 'user',
+        content: `You are ${persona} in the AEGIS Council. The question is:\n\n"${question}"\n\nRespond with:\nVOTE: JA or NEJ\nANALYSIS: 1-2 sentences explaining your reasoning.`,
+      }],
+    }),
+  });
+  const data = await res.json() as any;
+  const text = data.choices?.[0]?.message?.content || '';
+  const vote = text.includes('VOTE: JA') ? 'JA' : text.includes('VOTE: NEJ') ? 'NEJ' : 'AVSTÅR';
+  const analysis = text.split('ANALYSIS:')[1]?.trim().slice(0, 200) || text.slice(0, 200);
+  return { vote, analysis };
+}
+
+function pickProvider(): { baseUrl: string; apiKey: string; model: string } {
+  if (process.env.OPENAI_API_KEY && process.env.OPENAI_BASE_URL)
+    return { baseUrl: process.env.OPENAI_BASE_URL, apiKey: process.env.OPENAI_API_KEY, model: process.env.OPENAI_MODEL || 'gpt-4o' };
+  if (process.env.DEEPSEEK_API_KEY)
+    return { baseUrl: 'https://api.deepseek.com/v1', apiKey: process.env.DEEPSEEK_API_KEY, model: 'deepseek-chat' };
+  if (process.env.GROQ_API_KEY)
+    return { baseUrl: 'https://api.groq.com/openai/v1', apiKey: process.env.GROQ_API_KEY, model: 'llama-3.3-70b-versatile' };
+  if (process.env.OPENAI_API_KEY)
+    return { baseUrl: 'https://api.openai.com/v1', apiKey: process.env.OPENAI_API_KEY, model: 'gpt-4o' };
+  throw new Error('No API key configured. Set OPENAI_API_KEY, DEEPSEEK_API_KEY, or GROQ_API_KEY in ~/.aegiscode/.env');
+}
+
+let _provider: ReturnType<typeof pickProvider> | null = null;
+function callPrimary(q: string, p: string)   { if (!_provider) _provider = pickProvider(); return callOpenAICompatible(_provider.baseUrl, _provider.apiKey, _provider.model, q, p); }
+function callDeepSeek(q: string, p: string)  { return callOpenAICompatible('https://api.deepseek.com/v1', process.env.DEEPSEEK_API_KEY || '', 'deepseek-chat', q, p); }
+function callGroq(q: string, p: string)      { return callOpenAICompatible('https://api.groq.com/openai/v1', process.env.GROQ_API_KEY || '', 'llama-3.3-70b-versatile', q, p); }
+
+const AGENTS: Agent[] = [
+  {
+    name: 'Claude',
+    role: 'Strategic Analyst',
+    color: C.teal,
+    call: (q) => callPrimary(q, 'a strategic analyst focused on long-term impact and human values'),
+  },
+  {
+    name: 'DeepSeek',
+    role: 'Technical Architect',
+    color: C.purple,
+    call: (q) => callDeepSeek(q, 'a technical architect focused on feasibility and system design'),
+  },
+  {
+    name: 'Llama',
+    role: 'Ethics Officer',
+    color: C.orange,
+    call: (q) => callGroq(q, 'an ethics officer focused on safety, fairness, and societal impact'),
+  },
+];
+
+export async function runCouncil(question: string): Promise<string> {
+  const results: { name: string; role: string; color: string; vote: string; analysis: string }[] = [];
+  const lines: string[] = [];
+
+  lines.push('## ⬡ AEGIS COUNCIL');
+  lines.push(`**Question:** ${question}`);
+  lines.push('');
+  lines.push('*Agents deliberating...*');
+  lines.push('');
+
+  await Promise.all(AGENTS.map(async (agent) => {
+    try {
+      const result = await agent.call(question);
+      results.push({ name: agent.name, role: agent.role, color: agent.color, ...result });
+    } catch (e: any) {
+      results.push({ name: agent.name, role: agent.role, color: agent.color, vote: 'OFFLINE', analysis: e.message });
+    }
+  }));
+
+  // Rebuild lines with results
+  lines.length = 0;
+  lines.push('## ⬡ AEGIS COUNCIL');
+  lines.push(`**Question:** ${question}`);
+  lines.push('');
+
+  for (const r of results) {
+    const voteEmoji = r.vote === 'JA' ? '✅' : r.vote === 'NEJ' ? '❌' : '⚫';
+    lines.push(`**${r.name}** · ${r.role}`);
+    lines.push(`${voteEmoji} **${r.vote}** — ${r.analysis}`);
+    lines.push('');
+  }
+
+  const ja  = results.filter(r => r.vote === 'JA').length;
+  const nej = results.filter(r => r.vote === 'NEJ').length;
+  const approved = ja > nej;
+  const verdict = approved ? '✅ GODKÄNT' : '❌ AVSLAGET';
+  const summary = `${ja} JA · ${nej} NEJ · ${results.length - ja - nej} AVSTÅR`;
+
+  lines.push('---');
+  lines.push(`${verdict} · ${summary}`);
+
+  return lines.join('\n');
+}

package/src/slash-commands/custom/CustomCommandExecutor.ts

@@ -0,0 +1,143 @@
+/**
+ * CustomCommandExecutor - 自定义命令执行器
+ * 
+ * 
+ * - 参数插值 ($ARGUMENTS, $1, $2, ...)
+ * - Bash 命令嵌入 (!`command`)
+ * - 文件引用 (@path/to/file)
+ */
+
+import { execSync } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import type { CustomCommand, CustomCommandExecutionContext } from '../types.js';
+
+/**
+ * 
+ */
+export class CustomCommandExecutor {
+  /**
+   * 
+   * 
+   * 
+   * 1. 参数插值
+   * 2. Bash 命令嵌入执行
+   * 3. 文件引用替换
+   */
+  async execute(
+    command: CustomCommand,
+    context: CustomCommandExecutionContext
+  ): Promise<string> {
+    let content = command.content;
+
+    // 1. 参数插
+    content = this.interpolateArgs(content, context.args);
+
+    // 2. Bash 嵌入执
+    content = await this.executeBashEmbeds(content, context);
+
+    // 3. 文件引用替
+    content = await this.resolveFileReferences(content, context.workspaceRoot);
+
+    return content;
+  }
+
+  /**
+   * 
+   * 
+   * 
+   * - $ARGUMENTS - 全部参数（空格连接）
+   * - $1, $2, ..., $9 - 位置参数
+   */
+  private interpolateArgs(content: string, args: string[]): string {
+    // 替
+    content = content.replace(/\$ARGUMENTS/g, args.join(' '));
+
+    // 替换 $1, $2, ... $9（从大到小避免 $1 匹配 $10 的问
+    for (let i = 9; i >= 1; i--) {
+      content = content.split(`$${i}`).join(args[i - 1] ?? '');
+    }
+
+    return content;
+  }
+
+  /**
+   * 
+   * 
+   * 
+   * - 命令在工作目录执行
+   * - 30 秒超时
+   * - 失败时显示错误信息
+   */
+  private async executeBashEmbeds(
+    content: string,
+    context: CustomCommandExecutionContext
+  ): Promise<string> {
+    const regex = /!`([^`]+)`/g;
+    let result = content;
+
+    for (const match of content.matchAll(regex)) {
+      const command = match[1];
+      
+      try {
+        // 检查中断信
+        if (context.signal?.aborted) {
+          result = result.replace(match[0], '[Aborted]');
+          continue;
+        }
+
+        const output = execSync(command, {
+          cwd: context.workspaceRoot,
+          encoding: 'utf-8',
+          timeout: 30000, // 30 秒超
+          maxBuffer: 1024 * 1024, // 1MB 输出限
+        }).trim();
+
+        result = result.replace(match[0], output);
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        result = result.replace(match[0], `[Error: ${errorMessage}]`);
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * 
+   * 
+   * 
+   * - 路径相对于工作目录
+   * - 自动用代码块包裹文件内容
+   * - 文件不存在时保留原文
+   */
+  private async resolveFileReferences(
+    content: string,
+    workspaceRoot: string
+  ): Promise<string> {
+    // 匹
+    const regex = /@([\w./-]+(?:\/[\w./-]+|\.[\w]+))/g;
+    let result = content;
+
+    for (const match of content.matchAll(regex)) {
+      const relativePath = match[1];
+      const filePath = path.resolve(workspaceRoot, relativePath);
+
+      try {
+        const stat = fs.statSync(filePath);
+        if (stat.isFile()) {
+          const fileContent = fs.readFileSync(filePath, 'utf-8');
+          const ext = path.extname(relativePath).slice(1) || 'text';
+          
+          // 用代码块包
+          const codeBlock = `\`\`\`${ext}\n${fileContent}\n\`\`\``;
+          result = result.replace(match[0], codeBlock);
+        }
+      } catch {
+        // 文件不存在，保留原
+      }
+    }
+
+    return result;
+  }
+}