@skillkit/cli 1.6.0 → 1.6.2

package/dist/index.d.ts

@@ -693,6 +693,58 @@ declare class AuditCommand extends Command {
     private buildQuery;
 }
 
+declare class AgentCommand extends Command {
+    static paths: string[][];
+    static usage: clipanion.Usage;
+    execute(): Promise<number>;
+}
+declare class AgentListCommand extends Command {
+    static paths: string[][];
+    static usage: clipanion.Usage;
+    json: boolean;
+    project: boolean;
+    global: boolean;
+    execute(): Promise<number>;
+}
+declare class AgentShowCommand extends Command {
+    static paths: string[][];
+    static usage: clipanion.Usage;
+    name: string;
+    execute(): Promise<number>;
+}
+declare class AgentCreateCommand extends Command {
+    static paths: string[][];
+    static usage: clipanion.Usage;
+    name: string;
+    model: string | undefined;
+    description: string | undefined;
+    global: boolean;
+    execute(): Promise<number>;
+}
+declare class AgentTranslateCommand extends Command {
+    static paths: string[][];
+    static usage: clipanion.Usage;
+    name: string | undefined;
+    to: string;
+    output: string | undefined;
+    dryRun: boolean;
+    all: boolean;
+    execute(): Promise<number>;
+}
+declare class AgentSyncCommand extends Command {
+    static paths: string[][];
+    static usage: clipanion.Usage;
+    agent: string | undefined;
+    execute(): Promise<number>;
+}
+declare class AgentValidateCommand extends Command {
+    static paths: string[][];
+    static usage: clipanion.Usage;
+    agentPath: string | undefined;
+    all: boolean;
+    execute(): Promise<number>;
+}
+
 declare const loadSkillMetadata: typeof loadSkillMetadata$1;
 declare const saveSkillMetadata: typeof saveSkillMetadata$1;
 declare function getSearchDirs(agentType?: AgentType): string[];
@@ -700,4 +752,4 @@ declare function getInstallDir(global?: boolean, agentType?: AgentType): string;
 declare function getAgentConfigPath(agentType?: AgentType): string;
 declare function initProject(agentType?: AgentType): Promise<void>;
 
-export { AICommand, AuditCommand, CICDCommand, CommandCmd, ContextCommand, CreateCommand, DisableCommand, EnableCommand, HookCommand, InitCommand, InstallCommand, ListCommand, MarketplaceCommand, MemoryCommand, MethodologyCommand, PauseCommand, PlanCommand, PluginCommand, ReadCommand, RecommendCommand, RemoveCommand, ResumeCommand, RunCommand, SettingsCommand, StatusCommand, SyncCommand, TeamCommand, TestCommand, TranslateCommand, UICommand, UpdateCommand, ValidateCommand, WorkflowCreateCommand, WorkflowListCommand, WorkflowRunCommand, getAgentConfigPath, getInstallDir, getSearchDirs, initProject, loadSkillMetadata, saveSkillMetadata };
+export { AICommand, AgentCommand, AgentCreateCommand, AgentListCommand, AgentShowCommand, AgentSyncCommand, AgentTranslateCommand, AgentValidateCommand, AuditCommand, CICDCommand, CommandCmd, ContextCommand, CreateCommand, DisableCommand, EnableCommand, HookCommand, InitCommand, InstallCommand, ListCommand, MarketplaceCommand, MemoryCommand, MethodologyCommand, PauseCommand, PlanCommand, PluginCommand, ReadCommand, RecommendCommand, RemoveCommand, ResumeCommand, RunCommand, SettingsCommand, StatusCommand, SyncCommand, TeamCommand, TestCommand, TranslateCommand, UICommand, UpdateCommand, ValidateCommand, WorkflowCreateCommand, WorkflowListCommand, WorkflowRunCommand, getAgentConfigPath, getInstallDir, getSearchDirs, initProject, loadSkillMetadata, saveSkillMetadata };

package/dist/index.js

@@ -3803,12 +3803,12 @@ ${learning.title}
     }
     const outputPath = this.output || `.skillkit/exports/${skillName}/SKILL.md`;
     const { dirname: dirname5 } = await import("path");
-    const { existsSync: existsSync14, mkdirSync: mkdirSync7, writeFileSync: writeFileSync6 } = await import("fs");
+    const { existsSync: existsSync15, mkdirSync: mkdirSync8, writeFileSync: writeFileSync7 } = await import("fs");
     const outputDir = dirname5(outputPath);
-    if (!existsSync14(outputDir)) {
-      mkdirSync7(outputDir, { recursive: true });
+    if (!existsSync15(outputDir)) {
+      mkdirSync8(outputDir, { recursive: true });
     }
-    writeFileSync6(outputPath, skillContent, "utf-8");
+    writeFileSync7(outputPath, skillContent, "utf-8");
     console.log(chalk23.green(`\u2713 Exported learning as skill: ${skillName}`));
     console.log(chalk23.gray(`  Path: ${outputPath}`));
     return 0;
@@ -3823,10 +3823,10 @@ ${learning.title}
       console.log(chalk23.gray("Usage: skillkit memory import --input <path>"));
       return 1;
     }
-    const { existsSync: existsSync14, readFileSync: readFileSync7 } = await import("fs");
+    const { existsSync: existsSync15, readFileSync: readFileSync7 } = await import("fs");
     const { resolve: resolve16 } = await import("path");
     const fullPath = resolve16(inputPath);
-    if (!existsSync14(fullPath)) {
+    if (!existsSync15(fullPath)) {
       console.error(chalk23.red(`File not found: ${fullPath}`));
       return 1;
     }
@@ -4905,14 +4905,14 @@ var TeamCommand = class extends Command27 {
     }
     const projectPath = process.cwd();
     const bundlePath = join9(projectPath, ".skillkit", "bundles", `${this.name}.json`);
-    const { existsSync: existsSync14, readFileSync: readFileSync7, writeFileSync: writeFileSync6 } = await import("fs");
-    if (!existsSync14(bundlePath)) {
+    const { existsSync: existsSync15, readFileSync: readFileSync7, writeFileSync: writeFileSync7 } = await import("fs");
+    if (!existsSync15(bundlePath)) {
       this.context.stderr.write(chalk26.red(`Bundle "${this.name}" not found. Create it first with bundle-create.
 `));
       return 1;
     }
     const content = readFileSync7(bundlePath, "utf-8");
-    writeFileSync6(this.output, content, "utf-8");
+    writeFileSync7(this.output, content, "utf-8");
     this.context.stdout.write(chalk26.green(`\u2713 Bundle exported to: ${this.output}
 `));
     return 0;
@@ -4922,8 +4922,8 @@ var TeamCommand = class extends Command27 {
       this.context.stderr.write(chalk26.red("--source <path> is required for bundle-import\n"));
       return 1;
     }
-    const { existsSync: existsSync14 } = await import("fs");
-    if (!existsSync14(this.source)) {
+    const { existsSync: existsSync15 } = await import("fs");
+    if (!existsSync15(this.source)) {
       this.context.stderr.write(chalk26.red(`Bundle file not found: ${this.source}
 `));
       return 1;
@@ -7196,8 +7196,491 @@ Recent Errors (${stats.recentErrors.length}):`));
     return query;
   }
 };
+
+// src/commands/agent.ts
+import chalk32 from "chalk";
+import { Command as Command35, Option as Option34 } from "clipanion";
+import { existsSync as existsSync14, mkdirSync as mkdirSync7, writeFileSync as writeFileSync6 } from "fs";
+import { join as join13 } from "path";
+import { homedir as homedir2 } from "os";
+import {
+  findAllAgents,
+  findAgent,
+  discoverAgents,
+  validateAgent,
+  translateAgent,
+  getAgentTargetDirectory
+} from "@skillkit/core";
+var AgentCommand = class extends Command35 {
+  static paths = [["agent"]];
+  static usage = Command35.Usage({
+    description: "Manage custom AI sub-agents",
+    details: `
+      This command manages custom AI sub-agents that can be used with
+      Claude Code, Cursor, and other AI coding agents.
+
+      Agents are specialized personas (like architects, testers, reviewers)
+      that can be invoked with @mentions or the --agent flag.
+
+      Sub-commands:
+        agent list      - List all installed agents
+        agent show      - Show agent details
+        agent create    - Create a new agent
+        agent translate - Translate agents between formats
+        agent sync      - Sync agents to target AI agent
+        agent validate  - Validate agent definitions
+    `,
+    examples: [
+      ["List all agents", "$0 agent list"],
+      ["Show agent details", "$0 agent show architect"],
+      ["Create new agent", "$0 agent create security-reviewer"],
+      ["Translate to Cursor format", "$0 agent translate --to cursor"],
+      ["Sync agents", "$0 agent sync --agent claude-code"]
+    ]
+  });
+  async execute() {
+    console.log(chalk32.cyan("Agent management commands:\n"));
+    console.log("  agent list              List all installed agents");
+    console.log("  agent show <name>       Show agent details");
+    console.log("  agent create <name>     Create a new agent");
+    console.log("  agent translate         Translate agents between formats");
+    console.log("  agent sync              Sync agents to target AI agent");
+    console.log("  agent validate [path]   Validate agent definitions");
+    console.log();
+    console.log(chalk32.dim("Run `skillkit agent <subcommand> --help` for more info"));
+    return 0;
+  }
+};
+var AgentListCommand = class extends Command35 {
+  static paths = [["agent", "list"], ["agent", "ls"]];
+  static usage = Command35.Usage({
+    description: "List all installed agents",
+    examples: [
+      ["List all agents", "$0 agent list"],
+      ["Show JSON output", "$0 agent list --json"],
+      ["Show only project agents", "$0 agent list --project"]
+    ]
+  });
+  json = Option34.Boolean("--json,-j", false, {
+    description: "Output as JSON"
+  });
+  project = Option34.Boolean("--project,-p", false, {
+    description: "Show only project agents"
+  });
+  global = Option34.Boolean("--global,-g", false, {
+    description: "Show only global agents"
+  });
+  async execute() {
+    const searchDirs = [process.cwd()];
+    let agents = findAllAgents(searchDirs);
+    if (this.project) {
+      agents = agents.filter((a) => a.location === "project");
+    } else if (this.global) {
+      agents = agents.filter((a) => a.location === "global");
+    }
+    agents.sort((a, b) => {
+      if (a.location !== b.location) {
+        return a.location === "project" ? -1 : 1;
+      }
+      return a.name.localeCompare(b.name);
+    });
+    if (this.json) {
+      console.log(JSON.stringify(agents.map((a) => ({
+        name: a.name,
+        description: a.description,
+        path: a.path,
+        location: a.location,
+        enabled: a.enabled,
+        model: a.frontmatter.model,
+        permissionMode: a.frontmatter.permissionMode
+      })), null, 2));
+      return 0;
+    }
+    if (agents.length === 0) {
+      console.log(chalk32.yellow("No agents found"));
+      console.log(chalk32.dim("Create an agent with: skillkit agent create <name>"));
+      return 0;
+    }
+    console.log(chalk32.cyan(`Installed agents (${agents.length}):
+`));
+    const projectAgents = agents.filter((a) => a.location === "project");
+    const globalAgents = agents.filter((a) => a.location === "global");
+    if (projectAgents.length > 0) {
+      console.log(chalk32.blue("Project agents:"));
+      for (const agent of projectAgents) {
+        printAgent(agent);
+      }
+      console.log();
+    }
+    if (globalAgents.length > 0) {
+      console.log(chalk32.dim("Global agents:"));
+      for (const agent of globalAgents) {
+        printAgent(agent);
+      }
+      console.log();
+    }
+    console.log(
+      chalk32.dim(`${projectAgents.length} project, ${globalAgents.length} global`)
+    );
+    return 0;
+  }
+};
+var AgentShowCommand = class extends Command35 {
+  static paths = [["agent", "show"], ["agent", "info"]];
+  static usage = Command35.Usage({
+    description: "Show details for a specific agent",
+    examples: [
+      ["Show agent details", "$0 agent show architect"]
+    ]
+  });
+  name = Option34.String({ required: true });
+  async execute() {
+    const searchDirs = [process.cwd()];
+    const agent = findAgent(this.name, searchDirs);
+    if (!agent) {
+      console.log(chalk32.red(`Agent not found: ${this.name}`));
+      return 1;
+    }
+    console.log(chalk32.cyan(`Agent: ${agent.name}
+`));
+    console.log(`${chalk32.dim("Description:")} ${agent.description}`);
+    console.log(`${chalk32.dim("Location:")} ${agent.location} (${agent.path})`);
+    console.log(`${chalk32.dim("Enabled:")} ${agent.enabled ? chalk32.green("yes") : chalk32.red("no")}`);
+    const fm = agent.frontmatter;
+    if (fm.model) {
+      console.log(`${chalk32.dim("Model:")} ${fm.model}`);
+    }
+    if (fm.permissionMode) {
+      console.log(`${chalk32.dim("Permission Mode:")} ${fm.permissionMode}`);
+    }
+    if (fm.context) {
+      console.log(`${chalk32.dim("Context:")} ${fm.context}`);
+    }
+    if (fm.disallowedTools && fm.disallowedTools.length > 0) {
+      console.log(`${chalk32.dim("Disallowed Tools:")} ${fm.disallowedTools.join(", ")}`);
+    }
+    if (fm.skills && fm.skills.length > 0) {
+      console.log(`${chalk32.dim("Skills:")} ${fm.skills.join(", ")}`);
+    }
+    if (fm.hooks && fm.hooks.length > 0) {
+      console.log(`${chalk32.dim("Hooks:")} ${fm.hooks.length} defined`);
+    }
+    if (fm.tags && fm.tags.length > 0) {
+      console.log(`${chalk32.dim("Tags:")} ${fm.tags.join(", ")}`);
+    }
+    if (fm.author) {
+      console.log(`${chalk32.dim("Author:")} ${fm.author}`);
+    }
+    if (fm.version) {
+      console.log(`${chalk32.dim("Version:")} ${fm.version}`);
+    }
+    console.log();
+    console.log(chalk32.dim("Content preview:"));
+    console.log(chalk32.dim("\u2500".repeat(40)));
+    const preview = agent.content.slice(0, 500);
+    console.log(preview + (agent.content.length > 500 ? "\n..." : ""));
+    return 0;
+  }
+};
+var AgentCreateCommand = class extends Command35 {
+  static paths = [["agent", "create"], ["agent", "new"]];
+  static usage = Command35.Usage({
+    description: "Create a new agent",
+    examples: [
+      ["Create an agent", "$0 agent create security-reviewer"],
+      ["Create with model", "$0 agent create architect --model opus"],
+      ["Create globally", "$0 agent create my-agent --global"]
+    ]
+  });
+  name = Option34.String({ required: true });
+  model = Option34.String("--model,-m", {
+    description: "Model to use (opus, sonnet, haiku)"
+  });
+  description = Option34.String("--description,-d", {
+    description: "Agent description"
+  });
+  global = Option34.Boolean("--global,-g", false, {
+    description: "Create in global agents directory"
+  });
+  async execute() {
+    const namePattern = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+    if (!namePattern.test(this.name)) {
+      console.log(chalk32.red("Invalid agent name: must be lowercase alphanumeric with hyphens"));
+      console.log(chalk32.dim("Examples: my-agent, code-reviewer, security-expert"));
+      return 1;
+    }
+    let targetDir;
+    if (this.global) {
+      targetDir = join13(homedir2(), ".claude", "agents");
+    } else {
+      targetDir = join13(process.cwd(), ".claude", "agents");
+    }
+    if (!existsSync14(targetDir)) {
+      mkdirSync7(targetDir, { recursive: true });
+    }
+    const agentPath = join13(targetDir, `${this.name}.md`);
+    if (existsSync14(agentPath)) {
+      console.log(chalk32.red(`Agent already exists: ${agentPath}`));
+      return 1;
+    }
+    const description = this.description || `${this.name} agent`;
+    const content = generateAgentTemplate(this.name, description, this.model);
+    writeFileSync6(agentPath, content);
+    console.log(chalk32.green(`Created agent: ${agentPath}`));
+    console.log();
+    console.log(chalk32.dim("Edit the file to customize the agent system prompt."));
+    console.log(chalk32.dim(`Invoke with: @${this.name}`));
+    return 0;
+  }
+};
+var AgentTranslateCommand = class extends Command35 {
+  static paths = [["agent", "translate"]];
+  static usage = Command35.Usage({
+    description: "Translate agents between AI coding agent formats",
+    examples: [
+      ["Translate all to Cursor", "$0 agent translate --to cursor"],
+      ["Translate specific agent", "$0 agent translate architect --to cursor"],
+      ["Dry run", "$0 agent translate --to cursor --dry-run"]
+    ]
+  });
+  name = Option34.String({ required: false });
+  to = Option34.String("--to,-t", {
+    description: "Target AI agent (claude-code, cursor, codex, etc.)",
+    required: true
+  });
+  output = Option34.String("--output,-o", {
+    description: "Output directory"
+  });
+  dryRun = Option34.Boolean("--dry-run,-n", false, {
+    description: "Show what would be done without writing files"
+  });
+  all = Option34.Boolean("--all,-a", false, {
+    description: "Translate all agents"
+  });
+  async execute() {
+    const searchDirs = [process.cwd()];
+    const targetAgent = this.to;
+    let agents;
+    if (this.name) {
+      const agent = findAgent(this.name, searchDirs);
+      if (!agent) {
+        console.log(chalk32.red(`Agent not found: ${this.name}`));
+        return 1;
+      }
+      agents = [agent];
+    } else if (this.all) {
+      agents = findAllAgents(searchDirs);
+    } else {
+      agents = discoverAgents(process.cwd());
+    }
+    if (agents.length === 0) {
+      console.log(chalk32.yellow("No agents found to translate"));
+      return 0;
+    }
+    const outputDir = this.output || getAgentTargetDirectory(process.cwd(), targetAgent);
+    console.log(chalk32.cyan(`Translating ${agents.length} agent(s) to ${targetAgent} format...
+`));
+    let successCount = 0;
+    let errorCount = 0;
+    for (const agent of agents) {
+      try {
+        const result = translateAgent(agent, targetAgent, { addMetadata: true });
+        if (!result.success) {
+          console.log(chalk32.red(`\u2717 ${agent.name}: Translation failed`));
+          errorCount++;
+          continue;
+        }
+        const outputPath = join13(outputDir, result.filename);
+        if (this.dryRun) {
+          console.log(chalk32.blue(`Would write: ${outputPath}`));
+          if (result.warnings.length > 0) {
+            for (const warning of result.warnings) {
+              console.log(chalk32.yellow(`  \u26A0 ${warning}`));
+            }
+          }
+          if (result.incompatible.length > 0) {
+            for (const incompat of result.incompatible) {
+              console.log(chalk32.dim(`  \u25CB ${incompat}`));
+            }
+          }
+        } else {
+          if (!existsSync14(outputDir)) {
+            mkdirSync7(outputDir, { recursive: true });
+          }
+          writeFileSync6(outputPath, result.content);
+          console.log(chalk32.green(`\u2713 ${agent.name} \u2192 ${outputPath}`));
+        }
+        successCount++;
+      } catch (error) {
+        console.log(chalk32.red(`\u2717 ${agent.name}: ${error instanceof Error ? error.message : "Unknown error"}`));
+        errorCount++;
+      }
+    }
+    console.log();
+    if (this.dryRun) {
+      console.log(chalk32.dim(`Would translate ${successCount} agent(s)`));
+    } else {
+      console.log(chalk32.dim(`Translated ${successCount} agent(s)${errorCount > 0 ? `, ${errorCount} failed` : ""}`));
+    }
+    return errorCount > 0 ? 1 : 0;
+  }
+};
+var AgentSyncCommand = class extends Command35 {
+  static paths = [["agent", "sync"]];
+  static usage = Command35.Usage({
+    description: "Sync agents to target AI coding agent",
+    examples: [
+      ["Sync to Claude Code", "$0 agent sync --agent claude-code"],
+      ["Sync to multiple agents", "$0 agent sync --agent claude-code,cursor"]
+    ]
+  });
+  agent = Option34.String("--agent,-a", {
+    description: "Target AI agent(s) (comma-separated)"
+  });
+  async execute() {
+    const searchDirs = [process.cwd()];
+    const agents = findAllAgents(searchDirs);
+    if (agents.length === 0) {
+      console.log(chalk32.yellow("No agents found to sync"));
+      return 0;
+    }
+    const targetAgents = this.agent ? this.agent.split(",").map((a) => a.trim()) : ["claude-code"];
+    console.log(chalk32.cyan(`Syncing ${agents.length} agent(s)...
+`));
+    for (const targetAgent of targetAgents) {
+      const outputDir = getAgentTargetDirectory(process.cwd(), targetAgent);
+      console.log(chalk32.blue(`\u2192 ${targetAgent} (${outputDir})`));
+      if (!existsSync14(outputDir)) {
+        mkdirSync7(outputDir, { recursive: true });
+      }
+      for (const agent of agents) {
+        const result = translateAgent(agent, targetAgent);
+        if (result.success) {
+          const outputPath = join13(outputDir, result.filename);
+          writeFileSync6(outputPath, result.content);
+          console.log(chalk32.green(`  \u2713 ${agent.name}`));
+        } else {
+          console.log(chalk32.red(`  \u2717 ${agent.name}`));
+        }
+      }
+    }
+    console.log();
+    console.log(chalk32.dim("Sync complete"));
+    return 0;
+  }
+};
+var AgentValidateCommand = class extends Command35 {
+  static paths = [["agent", "validate"]];
+  static usage = Command35.Usage({
+    description: "Validate agent definitions",
+    examples: [
+      ["Validate specific agent", "$0 agent validate ./my-agent.md"],
+      ["Validate all agents", "$0 agent validate --all"]
+    ]
+  });
+  agentPath = Option34.String({ required: false });
+  all = Option34.Boolean("--all,-a", false, {
+    description: "Validate all discovered agents"
+  });
+  async execute() {
+    let hasErrors = false;
+    if (this.agentPath) {
+      const result = validateAgent(this.agentPath);
+      printValidationResult(this.agentPath, result);
+      hasErrors = !result.valid;
+    } else if (this.all) {
+      const searchDirs = [process.cwd()];
+      const agents = findAllAgents(searchDirs);
+      if (agents.length === 0) {
+        console.log(chalk32.yellow("No agents found"));
+        return 0;
+      }
+      console.log(chalk32.cyan(`Validating ${agents.length} agent(s)...
+`));
+      for (const agent of agents) {
+        const result = validateAgent(agent.path);
+        printValidationResult(agent.name, result);
+        if (!result.valid) hasErrors = true;
+      }
+    } else {
+      console.log(chalk32.yellow("Specify a path or use --all to validate all agents"));
+      return 1;
+    }
+    return hasErrors ? 1 : 0;
+  }
+};
+function printAgent(agent) {
+  const status = agent.enabled ? chalk32.green("\u2713") : chalk32.red("\u25CB");
+  const name = agent.enabled ? agent.name : chalk32.dim(agent.name);
+  const model = agent.frontmatter.model ? chalk32.blue(`[${agent.frontmatter.model}]`) : "";
+  const desc = chalk32.dim(truncate3(agent.description, 40));
+  console.log(`  ${status} ${name} ${model}`);
+  if (agent.description) {
+    console.log(`    ${desc}`);
+  }
+}
+function printValidationResult(name, result) {
+  if (result.valid) {
+    console.log(chalk32.green(`\u2713 ${name}`));
+    for (const warning of result.warnings) {
+      console.log(chalk32.yellow(`  \u26A0 ${warning}`));
+    }
+  } else {
+    console.log(chalk32.red(`\u2717 ${name}`));
+    for (const error of result.errors) {
+      console.log(chalk32.red(`  \u2022 ${error}`));
+    }
+    for (const warning of result.warnings) {
+      console.log(chalk32.yellow(`  \u26A0 ${warning}`));
+    }
+  }
+}
+function truncate3(str, maxLen) {
+  if (str.length <= maxLen) return str;
+  return str.slice(0, maxLen - 3) + "...";
+}
+function generateAgentTemplate(name, description, model) {
+  const lines = [];
+  lines.push("---");
+  lines.push(`name: ${name}`);
+  lines.push(`description: ${description}`);
+  if (model) {
+    lines.push(`model: ${model}`);
+  }
+  lines.push("# permissionMode: default");
+  lines.push("# disallowedTools: []");
+  lines.push("# skills: []");
+  lines.push("# context: fork");
+  lines.push("---");
+  lines.push("");
+  lines.push(`# ${formatAgentName(name)}`);
+  lines.push("");
+  lines.push("You are a specialized AI assistant.");
+  lines.push("");
+  lines.push("## Responsibilities");
+  lines.push("");
+  lines.push("- TODO: Define what this agent is responsible for");
+  lines.push("- TODO: Add specific tasks and behaviors");
+  lines.push("");
+  lines.push("## Guidelines");
+  lines.push("");
+  lines.push("- TODO: Add guidelines for how this agent should behave");
+  lines.push("- TODO: Define any constraints or preferences");
+  lines.push("");
+  return lines.join("\n");
+}
+function formatAgentName(name) {
+  return name.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
 export {
   AICommand,
+  AgentCommand,
+  AgentCreateCommand,
+  AgentListCommand,
+  AgentShowCommand,
+  AgentSyncCommand,
+  AgentTranslateCommand,
+  AgentValidateCommand,
   AuditCommand,
   CICDCommand,
   CommandCmd,