aiframe-agent-cli 1.0.0

package/dist/chunk-7NQAVI47.js

@@ -0,0 +1,1240 @@
+// src/commands/init.ts
+import fs from "fs-extra";
+import path from "path";
+import picocolors from "picocolors";
+async function initCommand() {
+  const cwd = process.cwd();
+  const aiframeDir = path.join(cwd, ".aiframe");
+  if (fs.existsSync(aiframeDir)) {
+    console.log(picocolors.yellow("\u26A0\uFE0F .aiframe directory already exists. Skipping bootstrap."));
+    return;
+  }
+  try {
+    console.log(picocolors.blue("\u{1F680} Bootstrapping .aiframe project structure..."));
+    const dirs = ["agents", "tools", "workflows", "instructions", "skills", "state", "output"];
+    for (const dir of dirs) {
+      await fs.ensureDir(path.join(aiframeDir, dir));
+    }
+    const configContent = `
+# Global AI Frame Configuration
+default_model: gemini-1.5-flash
+openai_api_key: env.OPENAI_API_KEY
+google_api_key: env.GOOGLE_API_KEY
+system:
+  max_loop_limit: 3
+  save_checkpoint: true
+`;
+    await fs.writeFile(path.join(aiframeDir, "config.yaml"), configContent.trim());
+    const agentContent = `
+name: coder
+model: gemini-1.5-flash
+role: "L\u1EADp tr\xECnh vi\xEAn chuy\xEAn nghi\u1EC7p, nh\u1EADn \u0111\u1EB7c t\u1EA3 thi\u1EBFt k\u1EBF v\xE0 vi\u1EBFt code ch\u1EA5t l\u01B0\u1EE3ng cao."
+tools:
+  - tool/read_file
+  - tool/write_file
+`;
+    await fs.writeFile(path.join(aiframeDir, "agents", "coder.yaml"), agentContent.trim());
+    const workflowContent = `
+name: sample_tdd_workflow
+description: Chu tr\xECnh vi\u1EBFt code v\xE0 t\u1EF1 \u0111\u1ED9ng ch\u1EA1y test ki\u1EC3m th\u1EED ch\u1EA5t l\u01B0\u1EE3ng.
+
+settings:
+  max_loop_limit: 3
+  save_checkpoint: true
+
+steps:
+  - step: 1
+    name: implement_code
+    use: agent/coder
+    instruction: "\u0110\u1ECDc file docs/design_spec.md, vi\u1EBFt class Calculator c\xF3 ph\u01B0\u01A1ng th\u1EE9c add(a, b) v\xE0o src/Calculator.js"
+    validation:
+      command: "node test/Calculator.test.js"
+      expect_exit_code: 0
+    max_retries: 3
+`;
+    await fs.writeFile(path.join(aiframeDir, "workflows", "sample-workflow.yaml"), workflowContent.trim());
+    const skillContent = `---
+name: write-docs
+description: Vi\u1EBFt t\xE0i li\u1EC7u h\u01B0\u1EDBng d\u1EABn k\u1EF9 thu\u1EADt chi ti\u1EBFt
+model: gemini-1.5-flash
+---
+
+# K\u1EF9 n\u0103ng vi\u1EBFt t\xE0i li\u1EC7u h\u01B0\u1EDBng d\u1EABn k\u1EF9 thu\u1EADt
+
+Khi th\u1EF1c hi\u1EC7n k\u1EF9 n\u0103ng n\xE0y, h\xE3y tu\xE2n th\u1EE7 c\xE1c quy t\u1EAFc sau:
+1. Lu\xF4n s\u1EED d\u1EE5ng ng\xF4n ng\u1EEF r\xF5 r\xE0ng, m\u1EA1ch l\u1EA1c, d\u1EC5 hi\u1EC3u.
+2. Cung c\u1EA5p v\xED d\u1EE5 th\u1EF1c t\u1EBF cho m\u1ED7i t\xEDnh n\u0103ng.
+3. S\u1EED d\u1EE5ng \u0111\u1ECBnh d\u1EA1ng b\u1EA3ng bi\u1EC3u \u0111\u1EC3 so s\xE1nh n\u1EBFu c\xF3 nhi\u1EC1u t\xF9y ch\u1ECDn.
+`;
+    await fs.writeFile(path.join(aiframeDir, "skills", "write-docs.md"), skillContent.trim());
+    const semgrepContent = `
+name: semgrep
+commands:
+  scan:
+    args:
+      - flag: "--config"
+        param: "config"
+      - flag: "--error"
+        param: "error"
+        type: "boolean"
+`;
+    await fs.writeFile(path.join(aiframeDir, "tools", "semgrep.yaml"), semgrepContent.trim());
+    const sonarContent = `
+name: sonar_scanner
+commands:
+  scan:
+    args:
+      - flag: "-Dsonar.host.url"
+        param: "host"
+      - flag: "-Dsonar.token"
+        param: "token"
+`;
+    await fs.writeFile(path.join(aiframeDir, "tools", "sonar_scanner.yaml"), sonarContent.trim());
+    const aiRulesContent = `
+# AI Rules for this Workspace
+
+Khi l\xE0m vi\u1EC7c trong workspace n\xE0y, Agent ph\u1EA3i tu\xE2n th\u1EE7 nghi\xEAm ng\u1EB7t c\xE1c quy \u0111\u1ECBnh:
+- T\u1EA5t c\u1EA3 m\xE3 ngu\u1ED3n vi\u1EBFt ra ph\u1EA3i tu\xE2n th\u1EE7 chu\u1EA9n ES Modules (ESM).
+- Kh\xF4ng t\u1EF1 \xFD th\xEAm package v\xE0o package.json m\xE0 ch\u01B0a \u0111\u01B0\u1EE3c s\u1EF1 \u0111\u1ED3ng \xFD c\u1EE7a con ng\u01B0\u1EDDi.
+- Lu\xF4n vi\u1EBFt unit test bao ph\u1EE7 cho c\xE1c h\xE0m nghi\u1EC7p v\u1EE5 m\u1EDBi.
+`;
+    await fs.writeFile(path.join(cwd, ".ai-rules.md"), aiRulesContent.trim());
+    const guidelineContent = `
+# AI Frame CLI Guideline
+
+Ch\xE0o m\u1EEBng b\u1EA1n \u0111\u1EBFn v\u1EDBi **AI Frame CLI** - N\u1EC1n t\u1EA3ng x\xE2y d\u1EF1ng AI Agent Framework!
+D\u01B0\u1EDBi \u0111\xE2y l\xE0 c\u1EA5u tr\xFAc th\u01B0 m\u1EE5c \`.aiframe\` v\u1EEBa \u0111\u01B0\u1EE3c kh\u1EDFi t\u1EA1o v\xE0 c\xE1ch b\u1EA1n s\u1EED d\u1EE5ng ch\xFAng:
+
+## C\u1EA5u tr\xFAc th\u01B0 m\u1EE5c
+
+- \`.aiframe/agents/\`: Ch\u1EE9a c\xE1c file YAML \u0111\u1ECBnh ngh\u0129a t\xE1c nh\xE2n AI (vai tr\xF2, model, c\xF4ng c\u1EE5).
+- \`.aiframe/workflows/\`: Ch\u1EE9a file YAML \u0111\u1ECBnh ngh\u0129a lu\u1ED3ng l\xE0m vi\u1EC7c (steps, logic, retry).
+- \`.aiframe/tools/\`: \u0110\u1ECBnh ngh\u0129a mapping c\xF4ng c\u1EE5 CLI \u0111\u1EC3 Agent c\xF3 th\u1EC3 g\u1ECDi an to\xE0n.
+- \`.aiframe/skills/\`: N\u01A1i ch\u1EE9a t\xE0i li\u1EC7u k\u1EF9 n\u0103ng (.md) \u0111\u1EC3 chia s\u1EBB ki\u1EBFn th\u1EE9c cho Agent.
+- \`.aiframe/output/\`: Th\u01B0 m\u1EE5c ch\u1EE9a c\xE1c file sinh ra t\u1EEB AI (\u0111\u01B0\u1EE3c ph\xE2n c\xE1ch theo m\xE3 Execution ID c\u1EE7a m\u1ED7i lu\u1ED3ng ch\u1EA1y).
+- \`.aiframe/state/\`: (N\u1ED9i b\u1ED9) Ch\u1EE9a l\u1ECBch s\u1EED ch\u1EA1y v\xE0 checkpoint.
+
+## C\xE1ch s\u1EED d\u1EE5ng c\u01A1 b\u1EA3n
+
+1. **Ch\u1EA1y m\u1ED9t Workflow:**
+   \`\`\`bash
+   npx aiframe run .aiframe/workflows/sample-workflow.yaml
+   \`\`\`
+
+2. **Ch\u1EA1y giao di\u1EC7n Web (Dashboard):**
+   \`\`\`bash
+   npx aiframe ui -p 3000
+   \`\`\`
+
+## Tu\u1EF3 bi\u1EBFn LLM Provider (T\xEDch h\u1EE3p AI)
+
+H\u1EC7 th\u1ED1ng h\u1ED7 tr\u1EE3 nhi\u1EC1u ph\u01B0\u01A1ng th\u1EE9c g\u1ECDi AI kh\xE1c nhau tu\u1EF3 thu\u1ED9c v\xE0o nhu c\u1EA7u c\u1EA5u h\xECnh c\u1EE7a b\u1EA1n:
+
+### 1. S\u1EED d\u1EE5ng Cloud API (M\u1EB7c \u0111\u1ECBnh)
+\u0110\u1EC3 s\u1EED d\u1EE5ng s\u1EE9c m\u1EA1nh g\u1ED1c c\u1EE7a Framework, b\u1EA1n c\xF3 th\u1EC3 truy\u1EC1n API Key v\xE0o file \`.aiframe/config.yaml\`:
+\`\`\`yaml
+# .aiframe/config.yaml
+default_model: gemini-1.5-flash
+google_api_key: "AIzaSy..." # Ho\u1EB7c d\xF9ng env.GOOGLE_API_KEY
+openai_api_key: "sk-..."    # D\xF9ng cho c\xE1c model gpt-4
+\`\`\`
+*L\u01B0u \xFD: M\u1ECDi Agent YAML kh\xF4ng c\xF3 th\u1EBB \`provider\` s\u1EBD m\u1EB7c \u0111\u1ECBnh s\u1EED d\u1EE5ng c\u1EA5u h\xECnh n\xE0y.*
+
+### 2. S\u1EED d\u1EE5ng Local CLI Agents (Claude Code, Gemini CLI, Antigravity)
+N\u1EBFu b\u1EA1n \u0111\xE3 c\xF3 c\xF4ng c\u1EE5 AI d\u1EA1ng d\xF2ng l\u1EC7nh c\xE0i tr\xEAn m\xE1y, b\u1EA1n c\xF3 th\u1EC3 bi\u1EBFn n\xF3 th\xE0nh "\u0111\u1ED9ng c\u01A1" th\u1EF1c thi cho c\xE1c Agent b\u1EB1ng c\xE1ch khai b\xE1o thu\u1ED9c t\xEDnh \`provider: "cli"\`.
+M\u1EDF file \`.aiframe/agents/t\xEAn_agent.yaml\` v\xE0 c\u1EA5u h\xECnh nh\u01B0 sau:
+
+**V\xED d\u1EE5 c\u1EA5u h\xECnh d\xF9ng Claude Code:**
+\`\`\`yaml
+name: "Claude Code Agent"
+provider: "cli"
+cli_command: ["claude", "-p", "{{prompt}}"]
+role: "B\u1EA1n l\xE0 chuy\xEAn gia l\u1EADp tr\xECnh..."
+\`\`\`
+
+**V\xED d\u1EE5 c\u1EA5u h\xECnh d\xF9ng Antigravity (VS Code IDE Integration):**
+\`\`\`yaml
+name: "Antigravity Agent"
+provider: "cli"
+cli_command: ["antigravity", "chat", "-m", "agent", "{{prompt}}"]
+role: "B\u1EA1n l\xE0 chuy\xEAn gia thi\u1EBFt k\u1EBF h\u1EC7 th\u1ED1ng..."
+\`\`\`
+
+*(L\u01B0u \xFD: C\xE1c l\u1EC7nh CLI n\xE0y s\u1EBD l\u1EA5y \`System Prompt\` v\xE0 \`Instruction\` g\u1ED9p th\xE0nh bi\u1EBFn \`{{prompt}}\` \u0111\u1EC3 truy\u1EC1n th\u1EB3ng cho CLI. B\u1EA1n c\xF3 th\u1EC3 t\u01B0\u01A1ng t\xE1c tr\u1EF1c ti\u1EBFp v\u1EDBi UI c\u1EE7a CLI \u0111\xF3 tr\xEAn terminal c\u1EE7a m\xECnh!)*
+
+### 3. S\u1EED d\u1EE5ng Local LLM (Ollama)
+N\u1EBFu b\u1EA1n mu\u1ED1n ch\u1EA1y ho\xE0n to\xE0n offline b\u1EB1ng m\xE1y c\u1EA5u h\xECnh m\u1EA1nh, s\u1EED d\u1EE5ng Ollama:
+\`\`\`yaml
+# .aiframe/config.yaml
+default_model: ollama/llama3
+\`\`\`
+
+---
+
+## H\u01B0\u1EDBng d\u1EABn thi\u1EBFt k\u1EBF Workflow
+
+Lu\u1ED3ng c\xF4ng vi\u1EC7c (Workflow) l\xE0 tr\xE1i tim c\u1EE7a AI Frame CLI. B\u1EA1n \u0111\u1ECBnh ngh\u0129a logic v\xE0o file trong \`.aiframe/workflows/t\xEAn-lu\u1ED3ng.yaml\`.
+
+**C\u1EA5u tr\xFAc c\u01A1 b\u1EA3n:**
+\`\`\`yaml
+name: "Demo Workflow"
+description: "M\u1ED9t lu\u1ED3ng c\xF4ng vi\u1EC7c \u0111\u01A1n gi\u1EA3n"
+settings:
+  max_loop_limit: 3       # S\u1ED1 l\u1EA7n retry t\u1ED1i \u0111a n\u1EBFu b\u01B0\u1EDBc ch\u1EA1y th\u1EA5t b\u1EA1i
+  save_checkpoint: true   # T\u1EF1 \u0111\u1ED9ng l\u01B0u checkpoint \u0111\u1EC3 c\xF3 th\u1EC3 Resume
+
+steps:
+  - name: "B\u01B0\u1EDBc 1: Research"
+    use: "agent/researcher" # G\u1ECDi agent t\xEAn l\xE0 researcher.yaml
+    instruction: "H\xE3y t\xECm ki\u1EBFm... v\xE0 l\u01B0u file v\xE0o {{output_dir}}/result.md"
+  
+  - name: "B\u01B0\u1EDBc 2: X\u1EED l\xFD file"
+    command: "cat {{output_dir}}/result.md | grep 'AI'" # G\u1ECDi l\u1EC7nh bash thu\u1EA7n tu\xFD
+\`\`\`
+
+**L\u01B0u \xFD quan tr\u1ECDng:** Lu\xF4n c\u1ED1 g\u1EAFng s\u1EED d\u1EE5ng bi\u1EBFn \`{{output_dir}}\` \u0111\u1EC3 h\u1EC7 th\u1ED1ng l\u01B0u t\u1EA5t c\u1EA3 c\xE1c file t\u1EADp trung v\xE0o chung m\u1ED9t th\u01B0 m\u1EE5c \u0111\u1EA7u ra (\`.aiframe/output/\`), tr\xE1nh l\xE0m r\xE1c th\u01B0 m\u1EE5c g\u1ED1c d\u1EF1 \xE1n c\u1EE7a b\u1EA1n.
+
+---
+
+## T\xE1i s\u1EED d\u1EE5ng Agent & Skill b\xEAn ngo\xE0i
+
+N\u1EBFu b\u1EA1n c\xF3 m\u1ED9t kho Agent d\xF9ng chung (v\xED d\u1EE5 \u1EDF \`/home/user/.agents/\`), b\u1EA1n ho\xE0n to\xE0n c\xF3 th\u1EC3 g\u1ECDi ch\xFAng b\u1EB1ng **\u0111\u01B0\u1EDDng d\u1EABn tuy\u1EC7t \u0111\u1ED1i** ho\u1EB7c **\u0111\u01B0\u1EDDng d\u1EABn t\u01B0\u01A1ng \u0111\u1ED1i** thay v\xEC copy file YAML v\xE0o t\u1EEBng d\u1EF1 \xE1n.
+
+V\xED d\u1EE5:
+\`\`\`yaml
+steps:
+  - name: "G\u1ECDi bmad-agent-dev"
+    use: "agent//home/anhvu/Documents/AI/AI Brain/AI-Brain/.agents/skills/bmad-agent-dev/SKILL.md"
+    instruction: "L\xE0m..."
+\`\`\`
+*(L\u01B0u \xFD: B\u1EA1n ch\u1EC9 c\u1EA7n ch\xE8n \u0111\u01B0\u1EDDng d\u1EABn file ngay sau \`agent/\`)*
+
+---
+
+## \xC1p d\u1EE5ng TDD v\xE0 SDD v\u1EDBi AI Frame
+
+V\u1EDBi c\u01A1 ch\u1EBF **Validation Auto-Healing (V\xF2ng l\u1EB7p t\u1EF1 s\u1EEDa l\u1ED7i qua Validation)**, b\u1EA1n c\xF3 th\u1EC3 thi\u1EBFt k\u1EBF Workflow \u0111\u1EC3 \xE9p AI code theo chu\u1EA9n TDD ho\u1EB7c SDD.
+
+### 1. TDD (Test-Driven Development)
+B\u1EA1n chia lu\u1ED3ng th\xE0nh 2 b\u01B0\u1EDBc (vi\u1EBFt test -> vi\u1EBFt code \u0111\u1EC3 pass test):
+\`\`\`yaml
+name: "TDD Workflow"
+settings:
+  max_loop_limit: 5 # Cho AI t\u1EF1 s\u1EEDa sai t\u1ED1i \u0111a 5 l\u1EA7n
+
+steps:
+  - name: 'Write Tests First'
+    use: agent/tester
+    instruction: "Vi\u1EBFt Unit Test b\u1EB1ng Jest cho h\xE0m t\xEDnh thu\u1EBF v\xE0o tests/tax.test.ts"
+    
+  - name: 'Implement Code'
+    use: agent/coder
+    instruction: "\u0110\u1ECDc file tests/tax.test.ts v\xE0 vi\u1EBFt logic code v\xE0o src/tax.ts sao cho pass test."
+    validation:
+      command: "npx jest tests/tax.test.ts"
+      expect_exit_code: 0
+    max_retries: 5 # N\u1EBFu ch\u1EA1y Jest l\u1ED7i, text l\u1ED7i s\u1EBD \u0111\u01B0\u1EE3c nh\u1ED3i l\u1EA1i v\xE0o Agent \u0111\u1EC3 t\u1EF1 s\u1EEDa code!
+\`\`\`
+
+### 2. SDD (Specification-Driven Development)
+\u0110\u1EA3m b\u1EA3o AI vi\u1EBFt Spec tr\u01B0\u1EDBc r\u1ED3i code b\xE1m theo Spec:
+\`\`\`yaml
+name: "SDD Workflow"
+steps:
+  - name: 'Create Architecture Spec'
+    use: agent/architect
+    instruction: "Vi\u1EBFt System Design cho t\xEDnh n\u0103ng \u0110\u0103ng nh\u1EADp v\xE0o docs/login_spec.md"
+
+  - name: 'Coding'
+    use: agent/coder
+    instruction: "Code t\xEDnh n\u0103ng \u0110\u0103ng nh\u1EADp b\xE1m s\xE1t y\xEAu c\u1EA7u t\u1EA1i docs/login_spec.md"
+    
+  - name: 'Spec Validation (Cross-check)'
+    use: agent/reviewer
+    instruction: "\u0110\u1ED1i chi\u1EBFu m\xE3 ngu\u1ED3n v\u1EDBi docs/login_spec.md. N\u1EBFu thi\u1EBFu ti\xEAu ch\xED n\xE0o, h\xE3y b\xE1o l\u1ED7i \u0111\u1EC3 Coder s\u1EEDa."
+    validation:
+      command: "node scripts/ai-review.js" # Script tu\u1EF3 ch\u1EC9nh \u0111\u1EC3 ch\u1EA1y reviewer
+      expect_exit_code: 0
+    max_retries: 3
+\`\`\`
+`;
+    await fs.writeFile(path.join(cwd, "GUIDELINE.md"), guidelineContent.trim());
+    console.log(picocolors.green("\u{1F389} Done! Bootstrap completed successfully."));
+    console.log(picocolors.cyan("C\u1EA5u tr\xFAc th\u01B0 m\u1EE5c \u0111\u01B0\u1EE3c kh\u1EDFi t\u1EA1o t\u1EA1i: " + aiframeDir));
+  } catch (error) {
+    console.error(picocolors.red("\u274C Error bootstrapping .aiframe:"), error);
+  }
+}
+
+// src/core/executor.ts
+import { execa } from "execa";
+async function executeCommand(cmd, args, options = {}) {
+  const timeout = options.timeout ?? 6e4;
+  const cwd = options.cwd ?? process.cwd();
+  try {
+    const result = await execa(cmd, args, {
+      cwd,
+      timeout,
+      reject: false
+      // Don't throw on non-zero exit codes, return the result
+    });
+    return {
+      stdout: result.stdout,
+      stderr: result.stderr,
+      exitCode: result.exitCode,
+      success: result.exitCode === 0
+    };
+  } catch (err) {
+    return {
+      stdout: "",
+      stderr: err.message || "Unknown execution error",
+      exitCode: err.exitCode ?? -1,
+      success: false,
+      error: err
+    };
+  }
+}
+
+// src/core/llm.ts
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+import { createOpenAI } from "@ai-sdk/openai";
+import fs2 from "fs-extra";
+import path2 from "path";
+import yaml from "js-yaml";
+function getGoogleModel(modelName = "gemini-1.5-flash") {
+  let apiKey = process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY || process.env.GOOGLE_GENERATIVE_AI_API_KEY || "";
+  let provider = "google";
+  const configPath = path2.join(process.cwd(), ".aiframe", "config.yaml");
+  if (fs2.existsSync(configPath)) {
+    try {
+      const config = yaml.load(fs2.readFileSync(configPath, "utf8"));
+      if (config.google_api_key) {
+        if (config.google_api_key.startsWith("env.")) {
+          const envVar = config.google_api_key.split(".")[1];
+          apiKey = process.env[envVar] || "";
+        } else {
+          apiKey = config.google_api_key;
+        }
+      }
+      if (config.default_model?.startsWith("ollama/")) {
+        provider = "ollama";
+        modelName = config.default_model.split("/")[1];
+      }
+    } catch (e) {
+    }
+  }
+  if (provider === "ollama") {
+    const openai = createOpenAI({
+      baseURL: "http://localhost:11434/v1",
+      apiKey: "ollama"
+    });
+    return openai(modelName);
+  }
+  if (apiKey) {
+    const google = createGoogleGenerativeAI({
+      apiKey
+    });
+    return google(modelName);
+  }
+  return createMockModel();
+}
+function createMockModel() {
+  return {
+    modelId: "mock-model",
+    specificationVersion: "v1",
+    doGenerate: async (options) => {
+      const prompt = options.prompt || "";
+      let text = "Mock LLM Response";
+      if (prompt.includes("CLI command-line argument mapping helper")) {
+        if (prompt.includes("commit") || prompt.includes("message")) {
+          text = '["commit", "-m", "test commit message", "--amend"]';
+        } else {
+          text = "[]";
+        }
+      } else if (prompt.includes("tech_lead")) {
+        text = "Tech Lead: I will call the coder sub-agent to create the file.";
+      } else if (prompt.includes("coder")) {
+        text = "Coder: File written successfully.";
+      }
+      return {
+        text,
+        finishReason: "stop",
+        usage: { promptTokens: 10, completionTokens: 10 }
+      };
+    }
+  };
+}
+
+// src/core/mapper.ts
+import fs3 from "fs-extra";
+import path3 from "path";
+import yaml2 from "js-yaml";
+import { generateText } from "ai";
+async function mapArguments(toolName, subCommand, params) {
+  const cwd = process.cwd();
+  const toolYamlPath = path3.join(cwd, ".aiframe", "tools", `${toolName}.yaml`);
+  if (fs3.existsSync(toolYamlPath)) {
+    try {
+      const toolConfig = yaml2.load(fs3.readFileSync(toolYamlPath, "utf8"));
+      if (toolConfig && toolConfig.commands) {
+        const cmdKey = subCommand || "default";
+        const cmdConfig = toolConfig.commands[cmdKey];
+        if (cmdConfig && cmdConfig.args) {
+          const mappedArgs = [];
+          if (subCommand) {
+            mappedArgs.push(subCommand);
+          }
+          for (const rule of cmdConfig.args) {
+            const val = params[rule.param];
+            if (val !== void 0 && val !== null) {
+              if (rule.type === "boolean") {
+                if (val === true) {
+                  mappedArgs.push(rule.flag);
+                }
+              } else {
+                mappedArgs.push(rule.flag);
+                mappedArgs.push(String(val));
+              }
+            }
+          }
+          return mappedArgs;
+        }
+      }
+    } catch (e) {
+      console.warn(`\u26A0\uFE0F Error parsing manual mapping for tool ${toolName}:`, e);
+    }
+  }
+  console.log(`\u{1F50D} Mapping arguments for ${toolName} ${subCommand || ""} using AI...`);
+  let helpText = "";
+  const helpArgs = subCommand ? [subCommand, "--help"] : ["--help"];
+  const helpResult = await executeCommand(toolName, helpArgs);
+  if (helpResult.success) {
+    helpText = helpResult.stdout || helpResult.stderr;
+  } else {
+    const alternativeHelpArgs = subCommand ? ["help", subCommand] : ["help"];
+    const altHelpResult = await executeCommand(toolName, alternativeHelpArgs);
+    helpText = altHelpResult.stdout || altHelpResult.stderr;
+  }
+  if (!helpText) {
+    helpText = "No help output available. Use general conventions.";
+  }
+  if (helpText.length > 5e3) {
+    helpText = helpText.substring(0, 5e3) + "... [truncated]";
+  }
+  const model = getGoogleModel();
+  const prompt = `
+You are a CLI command-line argument mapping helper.
+We have the CLI executable name: "${toolName}"
+Subcommand (if any): "${subCommand || ""}"
+Here is the help documentation or description of the tool:
+\`\`\`
+${helpText}
+\`\`\`
+
+Here are the JSON parameters provided by the Agent:
+\`\`\`json
+${JSON.stringify(params, null, 2)}
+\`\`\`
+
+Based on the help docs and general CLI standards, map these parameters to the corresponding CLI flags and arguments.
+Output only a valid JSON string array of the final command arguments.
+Do NOT include the executable name "${toolName}" in the array, but DO include the subcommand "${subCommand || ""}" at the beginning of the array if it is present.
+
+Example output format:
+["commit", "-m", "initial commit", "--amend"]
+
+Return ONLY the JSON array inside markdown code block or plain text. Do not write any other explanation or text.
+`;
+  try {
+    const { text } = await generateText({
+      model,
+      prompt
+    });
+    const cleanedText = text.replace(/```json/g, "").replace(/```/g, "").trim();
+    const parsed = JSON.parse(cleanedText);
+    if (Array.isArray(parsed)) {
+      return parsed.map(String);
+    }
+  } catch (err) {
+    console.error("\u274C Failed to auto-map arguments using LLM:", err);
+  }
+  const fallbackArgs = [];
+  if (subCommand) {
+    fallbackArgs.push(subCommand);
+  }
+  for (const [key, val] of Object.entries(params)) {
+    if (val === true) {
+      fallbackArgs.push(`--${key}`);
+    } else if (val !== false && val !== null && val !== void 0) {
+      fallbackArgs.push(`--${key}`);
+      fallbackArgs.push(String(val));
+    }
+  }
+  return fallbackArgs;
+}
+
+// src/core/agent.ts
+import fs4 from "fs-extra";
+import path4 from "path";
+import yaml3 from "js-yaml";
+import picocolors2 from "picocolors";
+import { execa as execa2 } from "execa";
+import { generateText as generateText2, tool } from "ai";
+import { z } from "zod";
+async function executeAgent(agentName, instruction, depth = 0, workflowOutputDir, workingDir) {
+  if (depth > 2) {
+    return "Error: Maximum sub-agent delegation depth reached (depth limit = 2).";
+  }
+  const cwd = process.cwd();
+  const agentWorkspace = workingDir || cwd;
+  let agentYamlPath = path4.join(cwd, ".aiframe", "agents", `${agentName}.yaml`);
+  if (path4.isAbsolute(agentName)) {
+    agentYamlPath = agentName.endsWith(".yaml") ? agentName : `${agentName}.yaml`;
+  } else if (agentName.startsWith(".")) {
+    agentYamlPath = path4.resolve(cwd, agentName.endsWith(".yaml") ? agentName : `${agentName}.yaml`);
+  }
+  if (!fs4.existsSync(agentYamlPath)) {
+    throw new Error(`Agent configuration for "${agentName}" not found at ${agentYamlPath}`);
+  }
+  const fileContent = await fs4.readFile(agentYamlPath, "utf8");
+  const agentConfig = yaml3.load(fileContent);
+  const rulesPath = path4.join(cwd, ".ai-rules.md");
+  let workspaceRules = "";
+  if (fs4.existsSync(rulesPath)) {
+    workspaceRules = await fs4.readFile(rulesPath, "utf8");
+  }
+  const outputDir = workflowOutputDir || path4.join(cwd, ".aiframe", "output", "default");
+  await fs4.ensureDir(outputDir);
+  const systemPrompt = `
+You are the Agent "${agentConfig.name || agentName}".
+Your role and instructions:
+${agentConfig.role}
+
+${workspaceRules ? `Ensure you follow these workspace rules:
+${workspaceRules}` : ""}
+
+You operate on the local file system. Do not write placeholders; write actual code.
+Always focus on the user's instruction and return a clean summary when you finish.
+Output Directory: ${outputDir}
+(IMPORTANT: Please save all generated artifacts, reports, slides, and results into this Output Directory by default unless the user specifies otherwise.)
+`;
+  const resolveSafePath = (requestedPath, allowedRoot) => {
+    const resolved = path4.resolve(allowedRoot, requestedPath);
+    const relative = path4.relative(allowedRoot, resolved);
+    if (relative.startsWith("..") || path4.isAbsolute(relative)) {
+      throw new Error(`Access Denied: Path escapes allowed workspace root: ${requestedPath}`);
+    }
+    return resolved;
+  };
+  const agentTools = {
+    read_file: tool({
+      description: "Read the contents of a file in the workspace.",
+      parameters: z.object({
+        filePath: z.string().describe("The path of the file to read, relative to workspace root.")
+      }),
+      execute: async ({ filePath }) => {
+        try {
+          const allowedRoot = agentConfig.workspace?.root ? path4.resolve(agentWorkspace, agentConfig.workspace.root) : agentWorkspace;
+          const fullPath = resolveSafePath(filePath, allowedRoot);
+          if (!fs4.existsSync(fullPath)) {
+            return `Error: File not found at ${filePath}`;
+          }
+          console.log(picocolors2.gray(`      [File Read] ${filePath}`));
+          return await fs4.readFile(fullPath, "utf8");
+        } catch (e) {
+          return `Error: ${e.message}`;
+        }
+      }
+    }),
+    write_file: tool({
+      description: "Write or overwrite contents of a file in the workspace.",
+      parameters: z.object({
+        filePath: z.string().describe("The path of the file to write, relative to workspace root."),
+        content: z.string().describe("The complete file content to write.")
+      }),
+      execute: async ({ filePath, content }) => {
+        try {
+          const allowedRoot = agentConfig.workspace?.root ? path4.resolve(agentWorkspace, agentConfig.workspace.root) : agentWorkspace;
+          const fullPath = resolveSafePath(filePath, allowedRoot);
+          await fs4.ensureDir(path4.dirname(fullPath));
+          await fs4.writeFile(fullPath, content, "utf8");
+          console.log(picocolors2.gray(`      [File Write] ${filePath}`));
+          return `Success: File written successfully to ${filePath}`;
+        } catch (e) {
+          return `Error: ${e.message}`;
+        }
+      }
+    })
+  };
+  if (agentConfig.tools) {
+    for (const t of agentConfig.tools) {
+      if (t.startsWith("tool/")) {
+        const toolName = t.split("/")[1];
+        agentTools[toolName] = tool({
+          description: `Run the CLI tool "${toolName}" with custom JSON parameters.`,
+          parameters: z.object({
+            subCommand: z.string().nullable().describe('Subcommand to run, if any (e.g. "commit", "status").'),
+            params: z.record(z.any()).describe("JSON parameters corresponding to the CLI options.")
+          }),
+          execute: async ({ subCommand, params }) => {
+            const args = await mapArguments(toolName, subCommand, params);
+            console.log(picocolors2.gray(`      [CLI Exec] Running: ${toolName} ${args.join(" ")}`));
+            const result = await executeCommand(toolName, args, { cwd: agentWorkspace });
+            return JSON.stringify({
+              success: result.success,
+              exitCode: result.exitCode,
+              stdout: result.stdout,
+              stderr: result.stderr
+            });
+          }
+        });
+      }
+    }
+  }
+  if (agentConfig.allowed_sub_agents) {
+    for (const subAgent of agentConfig.allowed_sub_agents) {
+      if (subAgent.startsWith("agent/")) {
+        const subAgentName = subAgent.split("/")[1];
+        agentTools[`call_${subAgentName}`] = tool({
+          description: `Delegate a sub-task to the sub-agent "${subAgentName}".`,
+          parameters: z.object({
+            subTaskInstruction: z.string().describe("Detailed instruction for the sub-agent.")
+          }),
+          execute: async ({ subTaskInstruction }) => {
+            console.log(picocolors2.magenta(`      [Delegating -> ${subAgentName}] Instruction: "${subTaskInstruction}"`));
+            return await executeAgent(subAgentName, subTaskInstruction, depth + 1, workflowOutputDir, workingDir);
+          }
+        });
+      }
+    }
+  }
+  if (agentConfig.provider === "cli") {
+    if (!agentConfig.cli_command || !Array.isArray(agentConfig.cli_command)) {
+      throw new Error(`Agent "${agentName}" uses provider "cli" but missing or invalid "cli_command" array. Example: ["claude", "-p", "{{prompt}}"]`);
+    }
+    const fullPrompt = `${systemPrompt}
+
+Task:
+${instruction}`;
+    const args = agentConfig.cli_command.slice(1).map((arg) => {
+      return arg.replace("{{prompt}}", fullPrompt);
+    });
+    const cmd = agentConfig.cli_command[0];
+    console.log(picocolors2.yellow(`
+   \u{1F680} [CLI Delegation] U\u1EF7 quy\u1EC1n cho Agent n\u1ED9i b\u1ED9: ${cmd} ...`));
+    try {
+      await execa2(cmd, args, { stdio: "inherit", cwd: agentWorkspace });
+      return `Success: Qu\xE1 tr\xECnh u\u1EF7 quy\u1EC1n cho CLI Agent ${cmd} \u0111\xE3 ho\xE0n t\u1EA5t.`;
+    } catch (err) {
+      console.error(picocolors2.red(`\u274C Error running CLI Agent "${cmd}":`), err);
+      return `Error: CLI Agent exited with code ${err.exitCode}. ${err.message}`;
+    }
+  }
+  const model = getGoogleModel();
+  try {
+    const { text } = await generateText2({
+      model,
+      system: systemPrompt,
+      prompt: instruction,
+      tools: agentTools,
+      maxSteps: 10
+      // Max steps of tool call-and-response loops
+    });
+    return text;
+  } catch (err) {
+    console.error(picocolors2.red(`\u274C Error running Agent "${agentName}":`), err);
+    return `Error: ${err.message || err}`;
+  }
+}
+
+// src/core/workflow.ts
+import fs5 from "fs-extra";
+import path5 from "path";
+import yaml4 from "js-yaml";
+import picocolors3 from "picocolors";
+import crypto from "crypto";
+var WorkflowEngine = class {
+  workflowData;
+  workflowPath;
+  checkpointPath;
+  state;
+  constructor(workflowPath) {
+    this.workflowPath = path5.resolve(workflowPath);
+    const cwd = process.cwd();
+    const stateDir = path5.join(cwd, ".aiframe", "state");
+    fs5.ensureDirSync(stateDir);
+    const workflowFileName = path5.basename(workflowPath, path5.extname(workflowPath));
+    this.checkpointPath = path5.join(stateDir, `${workflowFileName}-checkpoint.json`);
+  }
+  async load(resume = false, inputs) {
+    if (!fs5.existsSync(this.workflowPath)) {
+      throw new Error(`Workflow file not found at ${this.workflowPath}`);
+    }
+    const fileContent = await fs5.readFile(this.workflowPath, "utf8");
+    this.workflowData = yaml4.load(fileContent);
+    if (resume && fs5.existsSync(this.checkpointPath)) {
+      console.log(picocolors3.cyan("\u{1F504} Loading checkpoint from: " + this.checkpointPath));
+      const stateContent = await fs5.readFile(this.checkpointPath, "utf8");
+      this.state = JSON.parse(stateContent);
+      this.state.workflowPath = this.workflowPath;
+      if (inputs) {
+        this.state.inputs = { ...this.state.inputs, ...inputs };
+      }
+    } else {
+      const steps = this.workflowData.steps || [];
+      const stepStatuses = {};
+      steps.forEach((_, idx) => {
+        stepStatuses[idx] = "pending";
+      });
+      this.state = {
+        workflowName: this.workflowData.name || "unnamed_workflow",
+        workflowPath: this.workflowPath,
+        currentStepIndex: 0,
+        status: "in_progress",
+        errorHistory: {},
+        rollbackHistory: {},
+        stepStatuses,
+        inputs: inputs || {},
+        execId: crypto.randomUUID()
+      };
+    }
+  }
+  async saveCheckpoint() {
+    const saveCheckpointEnabled = this.workflowData.settings?.save_checkpoint !== false;
+    if (saveCheckpointEnabled) {
+      await fs5.writeFile(this.checkpointPath, JSON.stringify(this.state, null, 2), "utf8");
+    }
+  }
+  async clearCheckpoint() {
+    this.state.status = "completed";
+    const steps = this.workflowData.steps || [];
+    if (this.state.stepStatuses) {
+      steps.forEach((_, idx) => {
+        this.state.stepStatuses[idx] = "success";
+      });
+    }
+    await this.saveCheckpoint();
+  }
+  async run() {
+    const steps = this.workflowData.steps || [];
+    const maxGlobalLoops = this.workflowData.settings?.max_loop_limit ?? 3;
+    const isolateWorkspace = this.workflowData.settings?.isolate_workspace === true;
+    let workingDir;
+    let branchName;
+    console.log(picocolors3.green(`
+\u{1F3AC} Starting Workflow: ${this.state.workflowName}`));
+    console.log(picocolors3.gray(`Steps total: ${steps.length}. Starting from Step Index: ${this.state.currentStepIndex}
+`));
+    if (isolateWorkspace) {
+      console.log(picocolors3.cyan(`   [Workspace Isolation] Setting up Git Worktree...`));
+      branchName = `aiframe/exec-${this.state.execId}`;
+      workingDir = path5.join(process.cwd(), ".aiframe", "workspaces", this.state.execId);
+      await fs5.ensureDir(path5.dirname(workingDir));
+      const gitCheck = await executeCommand("git", ["rev-parse", "--is-inside-work-tree"]);
+      if (!gitCheck.success) {
+        console.error(picocolors3.red(`\u274C Workspace isolation failed: Not a git repository. Please run 'git init' first.`));
+        return false;
+      }
+      if (!fs5.existsSync(workingDir)) {
+        const wtResult = await executeCommand("git", ["worktree", "add", workingDir, "-b", branchName]);
+        if (!wtResult.success) {
+          console.error(picocolors3.red(`\u274C Failed to create worktree: ${wtResult.stderr}`));
+          return false;
+        }
+      }
+    }
+    while (this.state.currentStepIndex < steps.length) {
+      const step = steps[this.state.currentStepIndex];
+      console.log(picocolors3.yellow(`\u{1F449} [Step ${step.step || this.state.currentStepIndex + 1}] Running: ${step.name}`));
+      if (!this.state.stepStatuses) {
+        this.state.stepStatuses = {};
+      }
+      this.state.stepStatuses[this.state.currentStepIndex] = "running";
+      await this.saveCheckpoint();
+      let success = false;
+      let retries = 0;
+      const maxRetries = step.max_retries ?? 0;
+      while (retries <= maxRetries) {
+        if (retries > 0) {
+          console.log(picocolors3.blue(`   \u{1F504} Retry attempt ${retries}/${maxRetries} for step: ${step.name}`));
+        }
+        await this.runStepAction(step, retries, workingDir);
+        if (step.validation) {
+          const validationCmd = typeof step.validation === "string" ? step.validation : step.validation.command;
+          const resolvedValCmd = this.resolveVariables(validationCmd);
+          const expectExitCode = step.validation.expect_exit_code ?? 0;
+          const timeout = step.validation.timeout ?? 6e4;
+          console.log(picocolors3.gray(`   \u{1F50D} Validating with command: "${resolvedValCmd}"`));
+          const parsed = this.parseCommand(resolvedValCmd);
+          const valResult = await executeCommand(parsed.cmd, parsed.args, { timeout, cwd: workingDir || process.cwd() });
+          if (valResult.exitCode === expectExitCode) {
+            console.log(picocolors3.green(`   \u2705 Validation passed (Exit code: ${valResult.exitCode})`));
+            success = true;
+            this.state.stepStatuses[this.state.currentStepIndex] = "success";
+            break;
+          } else {
+            const errorOutput = valResult.stderr || valResult.stdout || "Validation returned unexpected exit code";
+            console.log(picocolors3.red(`   \u274C Validation failed (Exit code: ${valResult.exitCode})`));
+            console.log(picocolors3.gray(`      Error context: ${errorOutput.trim().split("\n")[0]}`));
+            if (!this.state.errorHistory[this.state.currentStepIndex]) {
+              this.state.errorHistory[this.state.currentStepIndex] = [];
+            }
+            this.state.errorHistory[this.state.currentStepIndex].push(errorOutput);
+            const similarErrorsCount = this.state.errorHistory[this.state.currentStepIndex].filter(
+              (err) => err.trim() === errorOutput.trim()
+            ).length;
+            if (similarErrorsCount >= maxGlobalLoops) {
+              console.log(picocolors3.red(`
+\u{1F6A8} Loop-Detection Guardrail Triggered!`));
+              console.log(picocolors3.red(`   Error occurred ${similarErrorsCount} times consecutively.`));
+              this.state.status = "failed";
+              this.state.stepStatuses[this.state.currentStepIndex] = "failed";
+              await this.saveCheckpoint();
+              return false;
+            }
+            retries++;
+          }
+        } else {
+          success = true;
+          this.state.stepStatuses[this.state.currentStepIndex] = "success";
+          break;
+        }
+      }
+      if (!success) {
+        console.log(picocolors3.red(`\u274C Step failed after ${maxRetries} retries.`));
+        if (step.on_failure) {
+          const targetIndex = this.resolveTargetStepIndex(step.on_failure, steps);
+          if (targetIndex !== null && targetIndex < this.state.currentStepIndex) {
+            if (!this.state.rollbackHistory) {
+              this.state.rollbackHistory = {};
+            }
+            const currentRollbacks = this.state.rollbackHistory[this.state.currentStepIndex] || 0;
+            if (currentRollbacks >= maxGlobalLoops) {
+              console.log(picocolors3.red(`\u{1F6A8} Loop-Detection Guardrail Triggered: Max rollback limit (${maxGlobalLoops}) reached for Step ${this.state.currentStepIndex + 1}.`));
+              this.state.status = "failed";
+              this.state.stepStatuses[this.state.currentStepIndex] = "failed";
+              await this.saveCheckpoint();
+              return false;
+            }
+            this.state.rollbackHistory[this.state.currentStepIndex] = currentRollbacks + 1;
+            console.log(picocolors3.magenta(`   \u{1F504} Routing on failure: Jumping from Step ${this.state.currentStepIndex + 1} back to Step ${targetIndex + 1} ("${steps[targetIndex].name}")`));
+            this.state.stepStatuses[this.state.currentStepIndex] = "failed";
+            for (let i = targetIndex; i < steps.length; i++) {
+              this.state.stepStatuses[i] = "pending";
+              delete this.state.errorHistory[i];
+            }
+            this.state.currentStepIndex = targetIndex;
+            await this.saveCheckpoint();
+            continue;
+          } else if (step.on_failure) {
+            console.log(picocolors3.yellow(`   \u26A0\uFE0F Invalid or non-previous rollback step target: ${step.on_failure}`));
+          }
+        }
+        this.state.status = "failed";
+        this.state.stepStatuses[this.state.currentStepIndex] = "failed";
+        await this.saveCheckpoint();
+        return false;
+      }
+      this.state.currentStepIndex++;
+      await this.saveCheckpoint();
+    }
+    console.log(picocolors3.green(`
+\u{1F389} Workflow Completed Successfully: ${this.state.workflowName}`));
+    this.state.status = "completed";
+    await this.clearCheckpoint();
+    if (isolateWorkspace && workingDir && branchName) {
+      console.log(picocolors3.cyan(`   [Workspace Isolation] Committing changes to branch ${branchName}...`));
+      await executeCommand("git", ["add", "."], { cwd: workingDir });
+      await executeCommand("git", ["commit", "-m", `chore(aiframe): auto-generated workflow results for ${this.state.workflowName}`], { cwd: workingDir });
+      console.log(picocolors3.green(`   \u2705 Changes have been safely committed to branch: ${branchName}`));
+    }
+    return true;
+  }
+  resolveVariables(text) {
+    if (!text || typeof text !== "string") return text;
+    let resolved = text;
+    const inputs = this.state.inputs || {};
+    const outputDir = path5.join(process.cwd(), ".aiframe", "output", this.state.execId);
+    fs5.ensureDirSync(outputDir);
+    resolved = resolved.replace(/{{\s*output_dir\s*}}/g, outputDir);
+    for (const key of Object.keys(inputs)) {
+      const val = inputs[key] || "";
+      resolved = resolved.replace(new RegExp(`{{\\s*${key}\\s*}}`, "g"), val);
+      resolved = resolved.replace(new RegExp(`{{\\s*inputs\\.${key}\\s*}}`, "g"), val);
+    }
+    if (inputs.task_prompt) {
+      resolved = resolved.replace(/"?{{\s*task_prompt\s*}}"?/g, inputs.task_prompt);
+    }
+    return resolved;
+  }
+  resolveTargetStepIndex(onFailureVal, steps) {
+    if (typeof onFailureVal === "number") {
+      const idx = onFailureVal - 1;
+      if (idx >= 0 && idx < steps.length) return idx;
+      return null;
+    }
+    if (typeof onFailureVal === "string") {
+      let target = onFailureVal.trim();
+      const prefixes = [/^\s*goto:\s*/i, /^\s*rollback_to:\s*/i, /^\s*rollback:\s*/i, /^\s*rollback_to_step:\s*/i];
+      for (const p of prefixes) {
+        if (p.test(target)) {
+          target = target.replace(p, "").trim();
+          break;
+        }
+      }
+      if (/^\d+$/.test(target)) {
+        const idx = parseInt(target, 10) - 1;
+        if (idx >= 0 && idx < steps.length) return idx;
+        return null;
+      }
+      const targetLower = target.toLowerCase();
+      let foundIdx = steps.findIndex((s) => s.name && s.name.trim() === target);
+      if (foundIdx !== -1) return foundIdx;
+      foundIdx = steps.findIndex((s) => s.name && s.name.trim().toLowerCase() === targetLower);
+      if (foundIdx !== -1) return foundIdx;
+      foundIdx = steps.findIndex((s) => s.name && s.name.trim().toLowerCase().includes(targetLower));
+      if (foundIdx !== -1) return foundIdx;
+    }
+    return null;
+  }
+  parseCommand(cmdStr) {
+    const parts = [];
+    const regex = /[^\s"']+|"([^"]*)"|'([^']*)'/g;
+    let match;
+    while ((match = regex.exec(cmdStr)) !== null) {
+      parts.push(match[1] !== void 0 ? match[1] : match[2] !== void 0 ? match[2] : match[0]);
+    }
+    return {
+      cmd: parts[0] || "",
+      args: parts.slice(1)
+    };
+  }
+  async runStepAction(step, attempt, workingDir) {
+    try {
+      if (step.use && step.use.startsWith("agent/")) {
+        const agentName = step.use.substring("agent/".length);
+        const resolvedInstruction = this.resolveVariables(step.instruction);
+        console.log(picocolors3.blue(`   \u{1F916} [Agent: ${agentName}] Instruction: "${resolvedInstruction}"`));
+        const stepHistory = this.state.errorHistory[this.state.currentStepIndex] || [];
+        let finalInstruction = resolvedInstruction;
+        if (stepHistory.length > 0) {
+          const lastError = stepHistory[stepHistory.length - 1];
+          console.log(picocolors3.gray(`      Feeding validation error back to agent to self-heal...`));
+          finalInstruction = `${resolvedInstruction}
+
+ATTENTION: The previous validation failed with the following error:
+${lastError}
+
+Please correct the implementation to fix this error.`;
+        }
+        const outputDir = path5.join(process.cwd(), ".aiframe", "output", this.state.execId);
+        const responseText = await executeAgent(agentName, finalInstruction, 0, outputDir, workingDir);
+        console.log(picocolors3.gray(`      [Agent Response] ${responseText.trim().split("\n")[0]}...`));
+      } else if (step.use && step.use.startsWith("tool/")) {
+        const toolName = step.use.substring("tool/".length);
+        console.log(picocolors3.blue(`   \u{1F6E0}\uFE0F [Tool: ${toolName}] Executing...`));
+        const args = await mapArguments(toolName, null, step.params || {});
+        await executeCommand(toolName, args, { cwd: workingDir || process.cwd() });
+      } else if (step.command) {
+        const resolvedCmd = this.resolveVariables(step.command);
+        console.log(picocolors3.blue(`   \u{1F4BB} [Command] Executing: "${resolvedCmd}"`));
+        const parsed = this.parseCommand(resolvedCmd);
+        await executeCommand(parsed.cmd, parsed.args, { cwd: workingDir || process.cwd() });
+      }
+    } catch (error) {
+      console.error(picocolors3.red(`   \u274C Error running step action: ${error}`));
+      throw error;
+    }
+  }
+};
+
+// src/commands/run.ts
+import picocolors4 from "picocolors";
+async function runCommand(workflowPath, options) {
+  if (!workflowPath) {
+    console.error(picocolors4.red("\u274C Error: Please specify the workflow file path."));
+    process.exit(1);
+  }
+  try {
+    const engine = new WorkflowEngine(workflowPath);
+    await engine.load(!!options.resume);
+    const success = await engine.run();
+    if (!success) {
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(picocolors4.red("\u274C Error running workflow:"), error.message || error);
+    process.exit(1);
+  }
+}
+
+// src/core/server.ts
+import Fastify from "fastify";
+import fastifyStatic from "@fastify/static";
+import path6 from "path";
+import fs6 from "fs-extra";
+import yaml5 from "js-yaml";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path6.dirname(__filename);
+async function startServer(port = 3e3) {
+  const fastify = Fastify({ logger: false });
+  const cwd = process.cwd();
+  let publicPath = path6.join(__dirname, "public");
+  if (!fs6.existsSync(publicPath)) {
+    publicPath = path6.join(__dirname, "..", "public");
+  }
+  await fs6.ensureDir(publicPath);
+  fastify.register(fastifyStatic, {
+    root: publicPath,
+    prefix: "/"
+  });
+  fastify.get("/api/workflows", async () => {
+    const wfDir = path6.join(cwd, ".aiframe", "workflows");
+    if (!fs6.existsSync(wfDir)) return [];
+    const files = await fs6.readdir(wfDir);
+    const workflows = [];
+    for (const f of files) {
+      if (f.endsWith(".yaml") || f.endsWith(".yml")) {
+        const content = await fs6.readFile(path6.join(wfDir, f), "utf8");
+        try {
+          const parsed = yaml5.load(content);
+          workflows.push({ filename: f, data: parsed });
+        } catch (e) {
+          workflows.push({ filename: f, error: "Parse Error" });
+        }
+      }
+    }
+    return workflows;
+  });
+  fastify.post("/api/workflows", async (request, reply) => {
+    const { filename, workflow } = request.body;
+    if (!filename || !workflow) {
+      reply.status(400).send({ error: "Missing filename or workflow data" });
+      return;
+    }
+    const wfDir = path6.join(cwd, ".aiframe", "workflows");
+    await fs6.ensureDir(wfDir);
+    const yamlContent = yaml5.dump(workflow);
+    await fs6.writeFile(path6.join(wfDir, filename), yamlContent, "utf8");
+    return { success: true };
+  });
+  fastify.get("/api/workflows/:filename/status", async (request, reply) => {
+    const { filename } = request.params;
+    const workflowFileName = path6.basename(filename, path6.extname(filename));
+    const checkpointPath = path6.join(cwd, ".aiframe", "state", `${workflowFileName}-checkpoint.json`);
+    if (fs6.existsSync(checkpointPath)) {
+      try {
+        const stateContent = await fs6.readFile(checkpointPath, "utf8");
+        return JSON.parse(stateContent);
+      } catch (e) {
+        return { status: "idle", currentStepIndex: -1, stepStatuses: {} };
+      }
+    }
+    return { status: "idle", currentStepIndex: -1, stepStatuses: {} };
+  });
+  fastify.get("/api/skills", async () => {
+    const builtIn = [
+      { name: "read_file", type: "tool", use: "tool/read_file", description: "\u0110\u1ECDc n\u1ED9i dung t\u1EC7p tin trong workspace" },
+      { name: "write_file", type: "tool", use: "tool/write_file", description: "Ghi/\u0111\xE8 n\u1ED9i dung t\u1EC7p tin trong workspace" },
+      { name: "semgrep", type: "tool", use: "tool/semgrep", description: "Qu\xE9t b\u1EA3o m\u1EADt m\xE3 ngu\u1ED3n b\u1EB1ng Semgrep" },
+      { name: "sonar_scanner", type: "tool", use: "tool/sonar_scanner", description: "Qu\xE9t ch\u1EA5t l\u01B0\u1EE3ng m\xE3 ngu\u1ED3n b\u1EB1ng SonarQube" },
+      { name: "run_tests", type: "command", use: "npm test", description: "Ch\u1EA1y b\u1ED9 ki\u1EC3m th\u1EED t\u1EF1 \u0111\u1ED9ng c\u1EE7a d\u1EF1 \xE1n" },
+      { name: "build_project", type: "command", use: "npm run build", description: "Bi\xEAn d\u1ECBch/\u0111\xF3ng g\xF3i m\xE3 ngu\u1ED3n d\u1EF1 \xE1n" }
+    ];
+    const skillsDir = path6.join(cwd, ".aiframe", "skills");
+    if (!fs6.existsSync(skillsDir)) return builtIn;
+    try {
+      const files = await fs6.readdir(skillsDir);
+      const customSkills = [];
+      for (const f of files) {
+        if (f.endsWith(".yaml") || f.endsWith(".yml")) {
+          const content = await fs6.readFile(path6.join(skillsDir, f), "utf8");
+          try {
+            const parsed = yaml5.load(content);
+            if (parsed) {
+              customSkills.push({
+                filename: f,
+                name: parsed.name || f.replace(".yaml", ""),
+                type: parsed.type || "command",
+                use: parsed.use || parsed.command || "",
+                description: parsed.description || ""
+              });
+            }
+          } catch (e) {
+          }
+        }
+      }
+      return [...builtIn, ...customSkills];
+    } catch (e) {
+      return builtIn;
+    }
+  });
+  fastify.post("/api/skills", async (request, reply) => {
+    const { filename, skill } = request.body;
+    if (!filename || !skill) {
+      reply.status(400).send({ error: "Missing filename or skill data" });
+      return;
+    }
+    const skillsDir = path6.join(cwd, ".aiframe", "skills");
+    await fs6.ensureDir(skillsDir);
+    await fs6.writeFile(path6.join(skillsDir, filename), yaml5.dump(skill), "utf8");
+    return { success: true };
+  });
+  fastify.delete("/api/skills/:filename", async (request, reply) => {
+    const { filename } = request.params;
+    const skillPath = path6.join(cwd, ".aiframe", "skills", filename);
+    if (fs6.existsSync(skillPath)) {
+      await fs6.remove(skillPath);
+    }
+    return { success: true };
+  });
+  fastify.get("/api/agents", async () => {
+    const agentsDir = path6.join(cwd, ".aiframe", "agents");
+    if (!fs6.existsSync(agentsDir)) return [];
+    const files = await fs6.readdir(agentsDir);
+    const agents = [];
+    for (const f of files) {
+      if (f.endsWith(".yaml") || f.endsWith(".yml")) {
+        const content = await fs6.readFile(path6.join(agentsDir, f), "utf8");
+        try {
+          const parsed = yaml5.load(content);
+          agents.push({ filename: f, data: parsed });
+        } catch (e) {
+        }
+      }
+    }
+    return agents;
+  });
+  fastify.post("/api/agents", async (request, reply) => {
+    const { filename, agent } = request.body;
+    if (!filename || !agent) {
+      reply.status(400).send({ error: "Missing filename or agent data" });
+      return;
+    }
+    const agentsDir = path6.join(cwd, ".aiframe", "agents");
+    await fs6.ensureDir(agentsDir);
+    await fs6.writeFile(path6.join(agentsDir, filename), yaml5.dump(agent), "utf8");
+    return { success: true };
+  });
+  fastify.delete("/api/agents/:filename", async (request, reply) => {
+    const { filename } = request.params;
+    const agentPath = path6.join(cwd, ".aiframe", "agents", filename);
+    if (fs6.existsSync(agentPath)) {
+      await fs6.remove(agentPath);
+    }
+    return { success: true };
+  });
+  fastify.delete("/api/workflows/:filename", async (request, reply) => {
+    const { filename } = request.params;
+    const wfPath = path6.join(cwd, ".aiframe", "workflows", filename);
+    if (fs6.existsSync(wfPath)) {
+      await fs6.remove(wfPath);
+    }
+    return { success: true };
+  });
+  fastify.get("/api/history", async () => {
+    const historyPath = path6.join(cwd, ".aiframe", "state", "history.json");
+    if (!fs6.existsSync(historyPath)) return [];
+    try {
+      const content = await fs6.readFile(historyPath, "utf8");
+      return JSON.parse(content);
+    } catch (e) {
+      return [];
+    }
+  });
+  fastify.post("/api/run", async (request, reply) => {
+    const { filename, inputs } = request.body;
+    if (!filename) {
+      reply.status(400).send({ error: "Missing filename" });
+      return;
+    }
+    const workflowPath = path6.join(cwd, ".aiframe", "workflows", filename);
+    if (!fs6.existsSync(workflowPath)) {
+      reply.status(404).send({ error: "Workflow file not found" });
+      return;
+    }
+    console.log(`
+\u{1F310} [Web UI] Triggered run for: ${filename} with inputs:`, inputs);
+    const historyPath = path6.join(cwd, ".aiframe", "state", "history.json");
+    await fs6.ensureDir(path6.dirname(historyPath));
+    let history = [];
+    if (fs6.existsSync(historyPath)) {
+      try {
+        history = JSON.parse(await fs6.readFile(historyPath, "utf8"));
+      } catch (e) {
+      }
+    }
+    const newRun = {
+      id: `run-${Date.now()}`,
+      filename,
+      startTime: (/* @__PURE__ */ new Date()).toISOString(),
+      status: "in_progress",
+      stepStatuses: {},
+      inputs: inputs || {}
+    };
+    history.unshift(newRun);
+    await fs6.writeFile(historyPath, JSON.stringify(history, null, 2), "utf8");
+    const engine = new WorkflowEngine(workflowPath);
+    await engine.load(false, inputs);
+    engine.run().then(async (success) => {
+      if (fs6.existsSync(historyPath)) {
+        try {
+          const currentHistory = JSON.parse(await fs6.readFile(historyPath, "utf8"));
+          const record = currentHistory.find((h) => h.id === newRun.id);
+          if (record) {
+            record.status = success ? "completed" : "failed";
+            const checkpointFileName = path6.basename(filename, path6.extname(filename));
+            const checkpointPath = path6.join(cwd, ".aiframe", "state", `${checkpointFileName}-checkpoint.json`);
+            if (fs6.existsSync(checkpointPath)) {
+              const cpData = JSON.parse(await fs6.readFile(checkpointPath, "utf8"));
+              record.stepStatuses = cpData.stepStatuses || {};
+            }
+            await fs6.writeFile(historyPath, JSON.stringify(currentHistory, null, 2), "utf8");
+          }
+        } catch (e) {
+        }
+      }
+    }).catch(async (err) => {
+      console.error("Workflow background run failed:", err);
+      if (fs6.existsSync(historyPath)) {
+        try {
+          const currentHistory = JSON.parse(await fs6.readFile(historyPath, "utf8"));
+          const record = currentHistory.find((h) => h.id === newRun.id);
+          if (record) {
+            record.status = "failed";
+            await fs6.writeFile(historyPath, JSON.stringify(currentHistory, null, 2), "utf8");
+          }
+        } catch (e) {
+        }
+      }
+    });
+    return { success: true, status: "triggered", runId: newRun.id };
+  });
+  try {
+    const address = await fastify.listen({ port, host: "0.0.0.0" });
+    console.log(`
+\u{1F680} Web UI Server listening on: ${address}`);
+  } catch (err) {
+    console.error("Error starting Fastify server:", err);
+    process.exit(1);
+  }
+}
+
+// src/commands/ui.ts
+async function uiCommand(options) {
+  const port = options.port ?? 3e3;
+  await startServer(port);
+}
+
+export {
+  initCommand,
+  executeCommand,
+  getGoogleModel,
+  mapArguments,
+  executeAgent,
+  WorkflowEngine,
+  runCommand,
+  startServer,
+  uiCommand
+};