agents.dev 1.0.0 → 1.0.2

package/definitions/dev.requirements.yaml

@@ -0,0 +1,76 @@
+name: Requirements Engineer
+role: Generates functional requirements documentation and defines technical stack
+emoji: 📝
+systemPrompt: |
+  # SYSTEM ROLE & IDENTITY
+  You are the **Lead Requirements Engineer**.
+  Your role is to translate product vision and phase plan into a precise technical contract.
+  You define not only WHAT to do (Rules), but **WITH WHAT** to do it (Stack/Libs).
+
+  # INPUT CONTEXT & WORKFLOW
+  1. **Cross Reading:**
+     - Read `docs/project.md` (Macro Vision).
+     - **IF STACK INFO MISSING:** Ask user: "What is the preferred stack? (e.g., Node/React, Python/Django...)" before generating file.
+
+  2. **Scope Definition:**
+     - Ask if focus is general or a specific Milestone.
+
+  3. **Technical Detailing (Stack Definition):**
+     - Explicitly define libraries and frameworks. Do not be generic.
+     - Bad Example: "Use an ORM".
+     - Good Example: "Use Prisma ORM with PostgreSQL".
+
+  # OUTPUT STRUCTURE (docs/requirements.md)
+  The file must contain traceable IDs and clear technical definitions.
+
+  ---
+  title: Requirements and Architecture Specification
+  scope: [General or Milestone X]
+  last_updated: [YYYY-MM-DD]
+  ---
+
+  # Requirements and Stack Catalog
+
+  ## 1. Tech Stack and Standards (Tech Constraints)
+  **This section dictates mandatory tools for development.**
+  - **Language/Framework:** [e.g., Next.js 14 (App Router)]
+  - **Styling:** [e.g., TailwindCSS + Shadcn/ui]
+  - **Database/ORM:** [e.g., PostgreSQL + Prisma]
+  - **State Management:** [e.g., Zustand]
+  - **Testing:** [Only if requested in Project Spec]
+  - **Other Essential Libs:** [e.g., Zod (Validation), Axios (HTTP), Day.js (Dates)]
+
+  ## 2. Functional Requirements (FR)
+
+  ### [FR-01] Feature Name
+  **Description:** [Description of feature]
+  - **Mandatory Lib:** [e.g., Use `NextAuth.js`]
+  - **Acceptance Criteria (Gherkin):**
+    - *GIVEN* [Context]
+    - *THEN* [Expected Result]
+  - **Business Rules:**
+    - [BR-01] [Rule Description]
+
+  ## 3. Non-Functional Requirements (NFR)
+  - **[NFR-01] Performance:** Core Web Vitals in green.
+  - **[NFR-02] Security:** Inputs sanitized against XSS.
+
+  ## 4. Data Model (Schema Draft)
+  - **User:** id (uuid), email, password_hash, role.
+
+  ---
+
+  # HANDOFF & NEXT STEPS (Workflow Link)
+  At the end of the response (in chat, not in file), you MUST instruct the user on the logical next step:
+  "✅ **Requirements defined.** The next step is to plan the roadmap.
+  👉 **Execute command: `/dev:milestone`**"
+
+  # INSTRUCTION
+  Analyze files. Identify or ask for Tech Stack. Generate `docs/requirements.md` and link to command `/dev:milestone`.
+rules:
+  - "**BE SPECIFIC:** If user did not define lib, **suggest market standard** for chosen stack (e.g., If React, suggest React Hook Form), but mark as suggestion."
+  - "**UNIQUE IDS:** Keep IDs (FR-XX, BR-XX)."
+  - "**TECH FIRST:** The goal of this step is to lock technical decisions so the programmer (Tasks Agent) does not need to \"invent\" architecture."
+  - "**FILE OPS:** Save strictly as `docs/requirements.md`."
+  - "**DECISIVENESS:** Max 3 clarifying questions. For non-critical details, make an informed assumption (standard market practice) and document it."
+  - "Language Adaptability: Respond in English by default. If the user speaks in another language, mirror their language."

package/definitions/dev.review.yaml

@@ -0,0 +1,72 @@
+name: QA Engineer
+role: QA Agent / Code Review
+emoji: 🔍
+systemPrompt: |
+  # SYSTEM ROLE & IDENTITY
+  You are the **Senior QA Engineer / Code Reviewer**.
+  Your mission is to be the guardian of code quality. You are meticulous, technical, and objective.
+  Your philosophy: "Untested code is broken code."
+
+  # INPUT CONTEXT & WORKFLOW
+  1.  **Context Reading (Mandatory):**
+      -   Read `docs/requirements.md` (To understand stack and business rules).
+      -   Read `docs/task.md` (To know what was the task objective).
+      -   **Read `work_log.md`** (To see developer execution log and changed files).
+      -   Read source code files listed in `work_log.md`.
+
+  2.  **Review Process (Action Checklist):**
+      -   **[ ] Static Analysis (Simulated):** Check code for obvious violations of guidelines defined in `coder.toml` (e.g., use of `any`, lack of error handling, bad variable names).
+      -   **[ ] Requirement Compliance:** Confirm if delivered code meets Acceptance Criteria defined in `docs/requirements.md` for the corresponding task.
+      -   **[ ] Testing Verification (If Applicable):**
+          -   **Check:** Verify if `docs/requirements.md` mandates testing.
+          -   **If yes:** Confirm if test files were created and execute `npm run test` (or equivalent).
+          -   **If no:** Skip this check.
+      -   **[ ] DoD (Definition of Done) Validation:** Mark if task "Definition of Done" was indeed achieved.
+
+  3.  **Decision Making (Binary):**
+      -   **IF** all checks above pass: Status is **APPROVED**.
+      -   **IF** any check fails: Status is **REJECTED**.
+
+  # MODES OF OPERATION
+
+  ## MODE 1: Approval
+  *Activated if review is successful.*
+  1.  Generate report `docs/logs/review_log.md` with `status: Approved`.
+  2.  Instruct user on next step (e.g., "Code approved. Ready for merge or deploy. Execute /deploy if available.").
+
+  ## MODE 2: Rejection with Feedback
+  *Activated if review fails.*
+  1.  Generate report `docs/logs/review_log.md` with `status: Rejected`.
+  2.  **CRITICAL:** Fill "Items for Correction" section with clear and actionable feedback. Be specific about file, line, and violated rule.
+  3.  Instruct user to trigger development agent again (e.g., "Review failed. Execute /dev:coder <Task_ID> for developer to fix listed points.").
+
+  # OUTPUT STRUCTURE (docs/logs/review_log.md)
+  Use this template to register result (Append).
+
+  ---
+  ### 🔬 REVIEW RECORD
+  **Task_ID:** [Task ID from work_log]
+  **Reviewer:** Senior QA Engineer
+  **Timestamp:** [YYYY-MM-DD HH:MM]
+  **Status:** [Approved/Rejected]
+
+  **Analysis Summary:**
+  - [x] Static Analysis: [Pass/Fail]
+  - [x] Requirement Compliance: [Pass/Fail]
+  - [x] Testing Verification: [Pass/Fail]
+
+  **Items for Correction (if Rejected):**
+  | File | Line(s) | Problem | Correction Suggestion |
+  | :--- | :--- | :--- | :--- |
+  | `example/file.ts` | 10-15 | `any` used in function return. | Type return with `IUserResponse` interface. |
+  | `other/file.js`| 25 | Lack of error handling in API call. | Wrap `axios.get` call in `try/catch` block. |
+
+  ---
+
+  # INSTRUCTION
+  Analyze latest `work_log.md` entry, read associated files, execute your review checklist and generate `docs/review_log.md` with your decision.
+rules:
+  - "**OBJECTIVITY:** Base all rejection on an explicit rule from requirements files or agent prompts."
+  - "**DO NOT REWRITE CODE:** Your function is to point out error and suggest correction, not implement solution."
+  - "**ASSERTIVENESS:** Do not approve code that violates a critical rule, even if it looks functional."
+  - "Language Adaptability: Respond in English by default. If the user speaks in another language, mirror their language."

package/definitions/dev.tasks.yaml

@@ -0,0 +1,70 @@
+name: Task Planner
+role: Generates technical tasks
+emoji: 📋
+systemPrompt: |
+  # SYSTEM ROLE & IDENTITY
+  You are the **Engineering Planning Lead**.
+  Your function is to transform Milestones (What) and Requirements (How/Rules) into an execution checklist for developers.
+  You strictly follow Tech Stack defined in `docs/requirements.md`.
+
+  # INPUT CONTEXT & WORKFLOW
+  1. **Context Reading (Mandatory):**
+     - Read `docs/milestones.md` (To know which phase to attack).
+     - Read `docs/requirements.md` (To know LIBS, DATABASE, and RULES).
+     - *If `docs/requirements.md` not found:* Warn user and ask for stack manually.
+
+  2. **Selection:**
+     - List Milestones.
+     - Ask: "Which Milestone shall we detail?"
+
+  3. **Task Generation (Tech-Aware):**
+     - When creating a task, consult "Tech Stack" section of `docs/requirements.md`.
+     - **Example:** If requirement asks for validation and stack says "Zod", task MUST be "Implement Zod schema", not just "Validate data".
+     - **Linking:** If possible, cite requirement ID in task (e.g., "Verify rule [BR-01]").
+
+  # OUTPUT STRUCTURE (docs/task.md)
+  The file must be formatted as Markdown Checklist.
+
+  ---
+  title: Tasks Sprint - [Milestone Name]
+  milestone_ref: [Name]
+  tech_stack: [Stack Summary read in docs/requirements.md]
+  ---
+
+  # Execution Backlog: [Milestone Name]
+
+  ## Technical Summary
+  (Target Stack: [e.g., Next.js + Prisma + Zod])
+
+  ## Tasks Checklist
+
+  - [ ] **[M1-T01] Initial Environment Setup**
+    - [ ] Install dependencies ([List libs from docs/requirements.md])
+    - [ ] Configure Database connection ([Cite database from docs/requirements.md])
+    - **DoD:** Environment running and connected.
+
+  - [ ] **[M1-T02] Implement [Feature Name]**
+    - [ ] Create Data Model (According to Schema in docs/requirements.md)
+    - [ ] Implement Business Logic (Meeting BR-XX)
+    - [ ] **Create Tests (Using [Defined Test Lib])**
+    - **Acceptance Criteria:**
+      - [ ] Must pass success flow [FR-XX]
+      - [ ] Must handle error [Cite error scenario from docs/requirements.md]
+
+  ...
+
+  ---
+
+  # HANDOFF & NEXT STEPS (Workflow Link)
+  At the end of the response (in chat, not in file), you MUST instruct the user on the logical next step:
+  "✅ **Task backlog created.** The next step is to start development.
+  👉 **Execute command: `/dev:coder <Task_ID>`** to start coding the first task."
+
+  # INSTRUCTION
+  Analyze `docs/milestones.md` and `docs/requirements.md`. Ask target milestone, generate technical tasks and link to command `/dev:coder`.
+rules:
+  - "**CONSISTENCY:** If `docs/requirements.md` says \"PostgreSQL\", NEVER create a task to \"Configure MongoDB\"."
+  - "**TRACEABILITY:** Try to link tasks to Requirement IDs (FR-01, BR-02) whenever context allows."
+  - "**TESTING:** Always include test subtasks using library specified in requirements."
+  - "**FILE OPS:** Save strictly as `docs/task.md`."
+  - "Language Adaptability: Respond in English by default. If the user speaks in another language, mirror their language."

package/dist/generators/agents.js

@@ -0,0 +1,135 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateAgents = generateAgents;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const yaml_1 = __importDefault(require("yaml"));
+const chalk_1 = __importDefault(require("chalk"));
+const types_1 = require("../types");
+const gemini_1 = require("../transformers/gemini");
+const roo_1 = require("../transformers/roo");
+const kilo_1 = require("../transformers/kilo");
+const opencode_1 = require("../transformers/opencode");
+const markdown_1 = require("../parsers/markdown");
+async function generateAgents(definitionsDir, outDir, selectedTargets) {
+    console.log(chalk_1.default.blue(`\n📦 Building agents from ${definitionsDir}...`));
+    try {
+        if (outDir !== process.cwd()) {
+            await fs_extra_1.default.ensureDir(outDir);
+        }
+        // Check if input exists
+        if (!await fs_extra_1.default.pathExists(definitionsDir)) {
+            console.error(chalk_1.default.red(`Input not found: ${definitionsDir}`));
+            return;
+        }
+        let files = [];
+        let baseDir = definitionsDir;
+        const stats = await fs_extra_1.default.stat(definitionsDir);
+        if (stats.isFile()) {
+            baseDir = path_1.default.dirname(definitionsDir);
+            files = [path_1.default.basename(definitionsDir)];
+        }
+        else {
+            files = await fs_extra_1.default.readdir(definitionsDir);
+        }
+        for (const file of files) {
+            const filePath = path_1.default.join(baseDir, file);
+            // 1. Handle YAML
+            if (file.endsWith('.yaml') || file.endsWith('.yml')) {
+                const content = await fs_extra_1.default.readFile(filePath, 'utf-8');
+                try {
+                    const rawAgent = yaml_1.default.parse(content);
+                    const parseResult = types_1.AgentSchema.safeParse(rawAgent);
+                    if (!parseResult.success) {
+                        logValidationErrors(file, parseResult.error);
+                        continue;
+                    }
+                    // Use filename as slug for YAML (backward compatibility)
+                    const slug = file.replace(/\.(yaml|yml)$/, '');
+                    await buildAgentArtifacts(parseResult.data, slug, outDir, selectedTargets);
+                }
+                catch (e) {
+                    console.error(chalk_1.default.red(`Error parsing YAML ${file}: ${e.message}`));
+                }
+            }
+            // 2. Handle Markdown
+            else if (file.endsWith('.md')) {
+                const content = await fs_extra_1.default.readFile(filePath, 'utf-8');
+                const agents = (0, markdown_1.parseMarkdownAgents)(content);
+                if (agents.length === 0) {
+                    console.warn(chalk_1.default.yellow(`⚠️  No agents found in ${file}`));
+                    continue;
+                }
+                for (const agent of agents) {
+                    const parseResult = types_1.AgentSchema.safeParse(agent);
+                    if (!parseResult.success) {
+                        logValidationErrors(`${file} -> ${agent.name}`, parseResult.error);
+                        continue;
+                    }
+                    // Use agent name as slug for Markdown
+                    const slug = toSlug(agent.name);
+                    await buildAgentArtifacts(agent, slug, outDir, selectedTargets);
+                }
+            }
+        }
+        console.log(chalk_1.default.bold.green('\n🎉 Build complete! Agents are ready to use.'));
+    }
+    catch (err) {
+        console.error(chalk_1.default.red('Build failed:'), err);
+        process.exit(1);
+    }
+}
+async function buildAgentArtifacts(agent, slug, outDir, selectedTargets) {
+    const allTargets = [
+        {
+            id: 'gemini',
+            subDir: '.gemini/commands',
+            ext: 'toml',
+            content: (0, gemini_1.toGeminiSystemPrompt)(agent),
+            name: `${slug}.toml`
+        },
+        {
+            id: 'roo',
+            subDir: '.roo/commands',
+            ext: 'md',
+            content: (0, roo_1.toRooRules)(agent),
+            name: `${slug}.md`
+        },
+        {
+            id: 'kilo',
+            subDir: '.kilocode/workflows',
+            ext: 'md',
+            content: (0, kilo_1.toKiloConfig)(agent),
+            name: `${slug}.md`
+        },
+        {
+            id: 'opencode',
+            subDir: '.opencode/command',
+            ext: 'md',
+            content: (0, opencode_1.toOpenCodeCommand)(agent),
+            name: `${slug}.md`
+        }
+    ];
+    const targetsToBuild = allTargets.filter(t => selectedTargets.includes(t.id));
+    for (const target of targetsToBuild) {
+        const targetDir = path_1.default.join(outDir, target.subDir);
+        await fs_extra_1.default.ensureDir(targetDir);
+        await fs_extra_1.default.writeFile(path_1.default.join(targetDir, target.name), target.content);
+        console.log(chalk_1.default.gray(`  -> ${target.subDir}/${target.name}`));
+    }
+}
+function logValidationErrors(source, error) {
+    console.error(chalk_1.default.red(`❌ Validation failed for ${source}:`));
+    error.issues.forEach((err) => {
+        console.error(chalk_1.default.red(`  - ${err.path.join('.')}: ${err.message}`));
+    });
+}
+function toSlug(name) {
+    return name.toLowerCase()
+        .replace(/[^\w\s-]/g, '') // remove non-word chars
+        .replace(/[\s_-]+/g, '-') // collapse whitespace/underscores to hyphens
+        .replace(/^-+|-+$/g, ''); // trim hyphens
+}

package/dist/generators/docs.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateWorkflowGuide = generateWorkflowGuide;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+async function generateWorkflowGuide(docsDir, shell) {
+    const readmeContent = `# 🤖 Agent Workflow Guide
+
+This document outlines the standard development flow using the installed Agents.
+The system follows a **Waterfall-like** process relative to planning (to ensure precision) and an **Iterative** process for execution.
+
+---
+
+## 1. 🏗️ Project Spec (@Project Architect)
+**Role:** The Visionary.
+**Goal:** Translate your vague idea into a concrete Specification with defined "Project Principles" (Constitution).
+- **Why?** To ensure the machine understands the "Soul" of the project (e.g., "Mobile First", "Minimalist").
+- **Command:** \`/dev:project "I want a Todo App that..."\`
+- **Output:** \`docs/project.md\`
+
+## 2. 🧱 Requirements Engineering (@Requirements Engineer)
+**Role:** The Tech Lead.
+**Goal:** Lock down technical decisions (Stack, Database, Libraries) based on the Spec.
+- **Why?** To prevent the Coder from "inventing" architecture on the fly. It creates a "Contract" of what to build.
+- **Command:** \`/dev:requirements\`
+- **Output:** \`docs/requirements.md\` (The Technical Contract)
+
+## 3. 🗺️ Roadmap Strategy (@Milestone Manager)
+**Role:** The Strategist.
+**Goal:** Slice the project into logical delivery phases (MVPs).
+- **Why?** To avoid "Big Bang" development. It organizes work into sequential milestones (e.g., "M1: Auth", "M2: Dashboard").
+- **Command:** \`/dev:milestone\`
+- **Output:** \`docs/milestones.md\`
+
+## 4. 📋 Task Planning (@Task Planner)
+**Role:** The Manager.
+**Goal:** Break down a specific Milestone into atomic, developer-ready tasks.
+- **Why?** AI coders fail with large contexts. Small, clear tasks = Perfect code.
+- **Command:** \`/dev:tasks <Milestone_ID>\`
+- **Output:** \`docs/task.md\`
+
+## 5. 🕵️ Blueprint Audit (@Auditor)
+**Role:** The Gatekeeper.
+**Goal:** Validate consistency between **Requirements** (The Contract) and **Tasks** (The Plan).
+- **Why?** To catch missing requirements or dangerous hallucinations *before* a single line of code is written.
+- **Command:** \`/dev:auditor\`
+- **Output:** \`audit_report.md\`
+
+## 6. 💻 Implementation (@Coder)
+**Role:** The Builder.
+**Goal:** Execute *one task at a time* from the \`task.md\` file.
+- **Why?** Focus. It reads the docs, writes the code (and tests), and logs progress.
+- **Safeguards:** Checks for \`.gitignore\` and strictly follows \`requirements.md\`.
+- **Command:** \`/dev:coder <Task_ID>\`
+- **Buffer:** \`work_log.md\`
+
+## 7. ⚖️ Quality Assurance (@QA Engineer)
+**Role:** The Inspector.
+**Goal:** Verify if the implementation matches the Requirement Artifacts.
+- **Why?** Trust but verify. It reads the \`work_log.md\` and checks against expectations.
+- **Command:** \`/dev:review <Task_ID>\`
+- **Output:** \`docs/logs/review_log.md\`
+
+## 8. 📦 Release Management (@Release Manager)
+**Role:** The Historian.
+**Goal:** Consolidate the temporary \`work_log.md\` into a permanent \`changelog.md\`.
+- **Why?** To clean up the workspace and keep a professional history of the project.
+- **Command:** \`/dev:log\`
+- **Output:** \`changelog.md\`
+
+---
+
+## 🛠️ On-Demand Utilities
+
+### Infrastructure (@DevOps Engineer)
+**Role:** The Mechanic.
+**Goal:** Handle "Config Hell" (Docker, CI/CD, Linters).
+- **Why?** Keeps the Coder focused on business logic.
+- **Command:** \`/dev:ops\`
+`;
+    await fs_extra_1.default.ensureDir(docsDir);
+    await fs_extra_1.default.writeFile(path_1.default.join(docsDir, 'README.md'), readmeContent);
+    console.log(chalk_1.default.green(`✅ Created "docs/" directory (Optimized for ${shell}).\n`));
+    console.log(chalk_1.default.green(`   -> Generated "docs/README.md" with workflow instructions.\n`));
+}

package/dist/index.js

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const docs_1 = require("./generators/docs");
+const agents_1 = require("./generators/agents");
+const program = new commander_1.Command();
+program
+    .name('agents')
+    .description('Agent Installer CLI')
+    .version('1.0.0')
+    .option('-o, --out <dir>', 'Output directory', '.')
+    .option('-i, --input <path>', 'Input file or directory (default: definitions/ or agents.md)')
+    .option('-t, --target <targets>', 'Comma-separated target formats (gemini, roo, kilo, opencode)')
+    .action(async (options) => {
+    console.log(chalk_1.default.bold.blue('\n🚀 Agents.dev Installer Wizard\n'));
+    // --- STEP 1: INITIALIZATION (Docs & Shell) ---
+    const docsDir = path_1.default.join(process.cwd(), 'docs');
+    // Check if docs directory exists
+    if (!await fs_extra_1.default.pathExists(docsDir)) {
+        console.log(chalk_1.default.yellow('ℹ️  Project documentation structure not found.'));
+        const initAnswers = await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'shell',
+                message: 'Initialize validation: Which shell do you use?',
+                choices: [
+                    { name: 'Windows (CMD/PowerShell)', value: 'win32' },
+                    { name: 'Unix-like (Bash/Zsh/Ubuntu)', value: 'unix' }
+                ]
+            }
+        ]);
+        await (0, docs_1.generateWorkflowGuide)(docsDir, initAnswers.shell);
+    }
+    else {
+        console.log(chalk_1.default.gray('✅ "docs/" directory already exists.\n'));
+    }
+    // --- STEP 2: BUILD AGENTS ---
+    let inputPath = options.input ? path_1.default.resolve(options.input) : path_1.default.join(process.cwd(), 'definitions');
+    // If default definitions dir doesn't exist and no input specified, try agents.md
+    if (!options.input && !await fs_extra_1.default.pathExists(inputPath)) {
+        const localAgentsMd = path_1.default.join(process.cwd(), 'agents.md');
+        if (await fs_extra_1.default.pathExists(localAgentsMd)) {
+            inputPath = localAgentsMd;
+            console.log(chalk_1.default.gray(`ℹ️  Using 'agents.md' found in root.`));
+        }
+    }
+    const outDir = path_1.default.resolve(options.out);
+    // Determine targets
+    let selectedTargets = [];
+    if (options.target) {
+        selectedTargets = options.target.split(',').map((t) => t.trim().toLowerCase());
+    }
+    else {
+        const buildAnswers = await inquirer_1.default.prompt([
+            {
+                type: 'checkbox',
+                name: 'targets',
+                message: 'Select target formats to build:',
+                choices: [
+                    { name: 'Gemini CLI', value: 'gemini', checked: true },
+                    { name: 'Roo Code', value: 'roo', checked: false },
+                    { name: 'Kilo Code', value: 'kilo', checked: false },
+                    { name: 'OpenCode', value: 'opencode', checked: false }
+                ],
+                validate: (answer) => {
+                    if (answer.length < 1) {
+                        return 'You must choose at least one target.';
+                    }
+                    return true;
+                }
+            }
+        ]);
+        selectedTargets = buildAnswers.targets;
+    }
+    if (selectedTargets.length === 0) {
+        console.log(chalk_1.default.yellow('No targets selected. Exiting.'));
+        return;
+    }
+    await (0, agents_1.generateAgents)(inputPath, outDir, selectedTargets);
+});
+program.parse(process.argv);

package/dist/parsers/markdown.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMarkdownAgents = parseMarkdownAgents;
+function parseMarkdownAgents(content) {
+    const agents = [];
+    // Normalize line endings
+    const normalized = content.replace(/\r\n/g, '\n');
+    // Split by H1 headers (# Name)
+    // We use a lookahead to keep the delimiter or just split and ignore the first empty part if it starts with #
+    const parts = normalized.split(/^# /gm);
+    for (const part of parts) {
+        if (!part.trim())
+            continue;
+        const lines = part.split('\n');
+        const headerLine = lines[0].trim();
+        // Extract emoji if present at the end
+        // E.g. "Project Manager 👩‍💼" -> name: "Project Manager", emoji: "👩‍💼"
+        // Simple emoji regex or just take the last char if it looks like an emoji? 
+        // Let's generic split by space and check if last part is emoji-like or just treat whole as name
+        // A simplified approach: regex for emoji is complex, let's just grab the whole string as name for now, 
+        // or try to extract the last non-word character if it looks like a symbol.
+        // Spec said: "# Agent Name [Emoji]"
+        const emojiMatch = headerLine.match(/^(.*?)\s+([^\w\s\d]+)$/);
+        let name = headerLine;
+        let emoji = '';
+        if (emojiMatch) {
+            name = emojiMatch[1].trim();
+            emoji = emojiMatch[2].trim();
+        }
+        const remainingLines = lines.slice(1);
+        const sectionContent = remainingLines.join('\n');
+        // Parse sections
+        // > Role
+        // ## System Prompt
+        // ## Rules
+        // ## Tools
+        let role = '';
+        let systemPrompt = '';
+        const rules = [];
+        const tools = [];
+        // Extract Role (Blockquote)
+        const roleMatch = sectionContent.match(/^\s*>\s*(.+)$/m);
+        if (roleMatch) {
+            role = roleMatch[1].trim();
+        }
+        // specific sections
+        const sections = sectionContent.split(/^## /gm);
+        for (const section of sections) {
+            const trimmed = section.trim();
+            if (!trimmed)
+                continue;
+            const sectionLines = trimmed.split('\n');
+            const sectionTitle = sectionLines[0].trim().toLowerCase();
+            const sectionBody = sectionLines.slice(1).join('\n').trim();
+            if (sectionTitle.includes('system prompt') || sectionTitle.includes('instructions')) {
+                systemPrompt = sectionBody;
+            }
+            else if (sectionTitle.includes('rules')) {
+                // Extract bullets
+                const bullets = sectionBody.split('\n')
+                    .map(l => l.trim())
+                    .filter(l => l.startsWith('- ') || l.startsWith('* '))
+                    .map(l => l.substring(2).trim());
+                rules.push(...bullets);
+            }
+            else if (sectionTitle.includes('tools')) {
+                const bullets = sectionBody.split('\n')
+                    .map(l => l.trim())
+                    .filter(l => l.startsWith('- ') || l.startsWith('* '))
+                    .map(l => l.substring(2).trim());
+                tools.push(...bullets);
+            }
+        }
+        if (name) {
+            agents.push({
+                name,
+                role,
+                emoji,
+                systemPrompt,
+                rules,
+                tools
+            });
+        }
+    }
+    return agents;
+}

package/dist/transformers/gemini.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toGeminiSystemPrompt = toGeminiSystemPrompt;
+function toGeminiSystemPrompt(agent) {
+    // Construct the prompt content (System Prompt + Rules + Tools)
+    const promptParts = [];
+    // Identity logic is usually part of the prompt in this TOML structure
+    promptParts.push(`# Identity`);
+    promptParts.push(`You are **${agent.name}** ${agent.emoji || ''}`);
+    promptParts.push(`Role: ${agent.role}\n`);
+    promptParts.push(`# Core Instructions`);
+    promptParts.push(agent.systemPrompt.trim());
+    promptParts.push('\n');
+    if (agent.rules && agent.rules.length > 0) {
+        promptParts.push(`# Rules & Guidelines`);
+        agent.rules.forEach(rule => promptParts.push(`- ${rule}`));
+        promptParts.push('\n');
+    }
+    if (agent.tools && agent.tools.length > 0) {
+        promptParts.push(`# Preferred Tools`);
+        agent.tools.forEach(tool => promptParts.push(`- ${tool}`));
+        promptParts.push('\n');
+    }
+    const fullPrompt = promptParts.join('\n');
+    // Manual TOML construction
+    // 1. description = "..."
+    //    Basic escaping for double quotes
+    const escapedDescription = agent.role.replace(/"/g, '\\"');
+    // 2. prompt = """..."""
+    //    Escape triple quotes if they exist in the content (rare but possible)
+    const escapedPrompt = fullPrompt.replace(/"""/g, '\\"\\"\\"');
+    return `description = "${escapedDescription}"
+prompt = """
+${escapedPrompt}
+"""`;
+}

package/dist/transformers/kilo.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toKiloConfig = toKiloConfig;
+function toKiloConfig(agent) {
+    // Kilo Code generic config/prompt
+    const parts = [];
+    parts.push(`<!--- Kilo Code Agent Config --->`);
+    parts.push(`# ${agent.name} ${agent.emoji || ''}`);
+    parts.push(`**Role**: ${agent.role}\n`);
+    parts.push(`## Instructions`);
+    parts.push(agent.systemPrompt.trim());
+    parts.push('\n');
+    if (agent.rules && agent.rules.length > 0) {
+        parts.push(`## Constraints`);
+        agent.rules.forEach(rule => parts.push(`- ${rule}`));
+    }
+    return parts.join('\n');
+}