agents.dev 1.0.0 → 1.0.1

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,83 @@
+"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");
+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);
+        }
+        const files = await fs_extra_1.default.readdir(definitionsDir);
+        for (const file of files) {
+            if (!file.endsWith('.yaml') && !file.endsWith('.yml'))
+                continue;
+            const content = await fs_extra_1.default.readFile(path_1.default.join(definitionsDir, file), 'utf-8');
+            const rawAgent = yaml_1.default.parse(content);
+            const parseResult = types_1.AgentSchema.safeParse(rawAgent);
+            if (!parseResult.success) {
+                console.error(chalk_1.default.red(`❌ Validation failed for ${file}:`));
+                parseResult.error.issues.forEach((err) => {
+                    console.error(chalk_1.default.red(`  - ${err.path.join('.')}: ${err.message}`));
+                });
+                continue; // Skip this agent
+            }
+            const agent = parseResult.data;
+            const slug = file.replace(/\.(yaml|yml)$/, '');
+            // specific outputs
+            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}`));
+            }
+        }
+        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);
+    }
+}

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,80 @@
+#!/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('-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 ---
+    const definitionsDir = path_1.default.join(process.cwd(), 'definitions');
+    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)(definitionsDir, outDir, selectedTargets);
+});
+program.parse(process.argv);

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');
+}

package/dist/transformers/opencode.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toOpenCodeCommand = toOpenCodeCommand;
+function toOpenCodeCommand(agent) {
+    // OpenCode generic config/prompt
+    const parts = [];
+    parts.push(`<!--- OpenCode 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');
+}

package/dist/transformers/roo.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toRooRules = toRooRules;
+function toRooRules(agent) {
+    // Roo Code / Cline usually expects a clear set of rules and role definition.
+    const parts = [];
+    parts.push(`# ${agent.name} (${agent.role})`);
+    parts.push(`\n${agent.systemPrompt.trim()}\n`);
+    if (agent.rules && agent.rules.length > 0) {
+        parts.push(`## Analytical Rules & Guidelines`);
+        agent.rules.forEach(rule => parts.push(`- ${rule}`));
+        parts.push('\n');
+    }
+    // Tools might be handled differently in Roo, but listing them as preferences is safe
+    if (agent.tools && agent.tools.length > 0) {
+        parts.push(`## Tool Usage Preferences`);
+        agent.tools.forEach(tool => parts.push(`- Prefer using ${tool} when applicable.`));
+    }
+    return parts.join('\n');
+}

package/dist/types.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentSchema = void 0;
+const zod_1 = require("zod");
+exports.AgentSchema = zod_1.z.object({
+    name: zod_1.z.string().min(1, "Name is required"),
+    role: zod_1.z.string().min(1, "Role is required"),
+    emoji: zod_1.z.string().optional(),
+    systemPrompt: zod_1.z.string().min(10, "System prompt must be at least 10 characters"),
+    rules: zod_1.z.array(zod_1.z.string()).optional(),
+    tools: zod_1.z.array(zod_1.z.string()).optional()
+});

package/package.json

@@ -1,13 +1,28 @@
 {
   "name": "agents.dev",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "",
-  "main": "index.js",
+  "main": "dist/index.js",
+  "bin": {
+    "agents.dev": "./dist/index.js",
+    "agents-install": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "definitions"
+  ],
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
-    "start": "npx ts-node src/index.ts build"
+    "start": "npx ts-node src/index.ts",
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
   },
-  "keywords": [],
+  "keywords": [
+    "agents",
+    "ai",
+    "cli",
+    "workflow"
+  ],
   "author": "",
   "license": "ISC",
   "type": "commonjs",

package/definitions/backend-architect.yaml

@@ -1,12 +0,0 @@
-name: Backend Architect
-role: Senior Backend Engineer specializes in scalable APIs
-emoji: 🏗️
-systemPrompt: |
-  You are a Senior Backend Engineer. Your goal is to design and implement scalable, robust, and secure backend systems.
-  You prefer Node.js with TypeScript or Python with FastAPI.
-  You always consider performance implications.
-rules:
-  - Follow RESTful API design principles.
-  - Use environment variables for secrets.
-  - Write unit tests for all business logic.
-  - Document API endpoints.