@omnidev-ai/cli 0.3.0 → 0.5.0

package/dist/index.js

@@ -0,0 +1,1094 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/index.ts
+import { run } from "@stricli/core";
+
+// src/lib/dynamic-app.ts
+import { existsSync as existsSync7 } from "node:fs";
+import { join as join5 } from "node:path";
+import { buildApplication, buildRouteMap as buildRouteMap4 } from "@stricli/core";
+
+// ../adapters/src/claude-code/index.ts
+import { existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+var claudeCodeAdapter = {
+  id: "claude-code",
+  displayName: "Claude Code",
+  async init(ctx) {
+    const claudeMdPath = join(ctx.projectRoot, "CLAUDE.md");
+    const filesCreated = [];
+    if (!existsSync(claudeMdPath)) {
+      await Bun.write(claudeMdPath, generateClaudeTemplate());
+      filesCreated.push("CLAUDE.md");
+    }
+    return {
+      filesCreated,
+      message: filesCreated.length > 0 ? `Created ${filesCreated.join(", ")}` : "CLAUDE.md already exists"
+    };
+  },
+  async sync(bundle, ctx) {
+    const filesWritten = [];
+    const filesDeleted = [];
+    const skillsDir = join(ctx.projectRoot, ".claude", "skills");
+    mkdirSync(skillsDir, { recursive: true });
+    for (const skill of bundle.skills) {
+      const skillDir = join(skillsDir, skill.name);
+      mkdirSync(skillDir, { recursive: true });
+      const skillPath = join(skillDir, "SKILL.md");
+      const content = `---
+name: ${skill.name}
+description: "${skill.description}"
+---
+
+${skill.instructions}`;
+      await Bun.write(skillPath, content);
+      filesWritten.push(`.claude/skills/${skill.name}/SKILL.md`);
+    }
+    return {
+      filesWritten,
+      filesDeleted
+    };
+  }
+};
+function generateClaudeTemplate() {
+  return `# Project Instructions
+
+<!-- Add your project-specific instructions here -->
+
+## OmniDev
+
+@import .omni/instructions.md
+`;
+}
+// ../adapters/src/codex/index.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+var codexAdapter = {
+  id: "codex",
+  displayName: "Codex",
+  async init(ctx) {
+    const agentsMdPath = join2(ctx.projectRoot, "AGENTS.md");
+    const filesCreated = [];
+    if (!existsSync2(agentsMdPath)) {
+      await Bun.write(agentsMdPath, generateAgentsTemplate());
+      filesCreated.push("AGENTS.md");
+    }
+    return {
+      filesCreated,
+      message: filesCreated.length > 0 ? `Created ${filesCreated.join(", ")}` : "AGENTS.md already exists"
+    };
+  },
+  async sync(_bundle, _ctx) {
+    return {
+      filesWritten: [],
+      filesDeleted: []
+    };
+  }
+};
+function generateAgentsTemplate() {
+  return `# Project Instructions
+
+<!-- Add your project-specific instructions here -->
+
+## OmniDev
+
+@import .omni/instructions.md
+`;
+}
+// ../adapters/src/cursor/index.ts
+import { mkdirSync as mkdirSync2 } from "node:fs";
+import { join as join3 } from "node:path";
+var cursorAdapter = {
+  id: "cursor",
+  displayName: "Cursor",
+  async init(ctx) {
+    const rulesDir = join3(ctx.projectRoot, ".cursor", "rules");
+    mkdirSync2(rulesDir, { recursive: true });
+    return {
+      filesCreated: [".cursor/rules/"],
+      message: "Created .cursor/rules/ directory"
+    };
+  },
+  async sync(bundle, ctx) {
+    const filesWritten = [];
+    const filesDeleted = [];
+    const rulesDir = join3(ctx.projectRoot, ".cursor", "rules");
+    mkdirSync2(rulesDir, { recursive: true });
+    for (const rule of bundle.rules) {
+      const rulePath = join3(rulesDir, `omnidev-${rule.name}.mdc`);
+      await Bun.write(rulePath, rule.content);
+      filesWritten.push(`.cursor/rules/omnidev-${rule.name}.mdc`);
+    }
+    return {
+      filesWritten,
+      filesDeleted
+    };
+  }
+};
+// ../adapters/src/opencode/index.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3 } from "node:fs";
+import { join as join4 } from "node:path";
+var opencodeAdapter = {
+  id: "opencode",
+  displayName: "OpenCode",
+  async init(ctx) {
+    const opencodeDir = join4(ctx.projectRoot, ".opencode");
+    mkdirSync3(opencodeDir, { recursive: true });
+    const instructionsPath = join4(opencodeDir, "instructions.md");
+    const filesCreated = [];
+    if (!existsSync3(instructionsPath)) {
+      await Bun.write(instructionsPath, generateOpencodeTemplate());
+      filesCreated.push(".opencode/instructions.md");
+    }
+    return {
+      filesCreated,
+      message: filesCreated.length > 0 ? `Created ${filesCreated.join(", ")}` : ".opencode/instructions.md already exists"
+    };
+  },
+  async sync(_bundle, _ctx) {
+    return {
+      filesWritten: [],
+      filesDeleted: []
+    };
+  }
+};
+function generateOpencodeTemplate() {
+  return `# OpenCode Instructions
+
+<!-- Add your project-specific instructions here -->
+
+## OmniDev
+
+@import ../.omni/instructions.md
+`;
+}
+// ../adapters/src/registry.ts
+import { readEnabledProviders } from "@omnidev-ai/core";
+var builtInAdapters = [
+  claudeCodeAdapter,
+  codexAdapter,
+  cursorAdapter,
+  opencodeAdapter
+];
+var adapterMap = new Map(builtInAdapters.map((adapter) => [adapter.id, adapter]));
+function getAllAdapters() {
+  return builtInAdapters;
+}
+async function getEnabledAdapters() {
+  const enabledIds = await readEnabledProviders();
+  return enabledIds.map((id) => adapterMap.get(id)).filter((a) => a != null);
+}
+// src/commands/capability.ts
+import {
+  disableCapability,
+  discoverCapabilities,
+  enableCapability,
+  getEnabledCapabilities,
+  loadCapabilityConfig,
+  syncAgentConfiguration
+} from "@omnidev-ai/core";
+import { buildCommand, buildRouteMap } from "@stricli/core";
+async function runCapabilityList() {
+  try {
+    const enabledIds = await getEnabledCapabilities();
+    const capabilityPaths = await discoverCapabilities();
+    if (capabilityPaths.length === 0) {
+      console.log("No capabilities found.");
+      console.log("");
+      console.log("To add capabilities, create directories in omni/capabilities/");
+      console.log("Each capability must have a capability.toml file.");
+      return;
+    }
+    console.log("Capabilities:");
+    console.log("");
+    for (const path of capabilityPaths) {
+      try {
+        const capConfig = await loadCapabilityConfig(path);
+        const isEnabled = enabledIds.includes(capConfig.capability.id);
+        const status = isEnabled ? "✓ enabled" : "✗ disabled";
+        const { id, name, version } = capConfig.capability;
+        console.log(`  ${status}  ${name}`);
+        console.log(`           ID: ${id}`);
+        console.log(`           Version: ${version}`);
+        console.log("");
+      } catch (error) {
+        console.error(`  ✗ Failed to load capability at ${path}:`, error);
+        console.log("");
+      }
+    }
+  } catch (error) {
+    console.error("Error listing capabilities:", error);
+    process.exit(1);
+  }
+}
+async function runCapabilityEnable(_flags, name) {
+  try {
+    const capabilityPaths = await discoverCapabilities();
+    const capabilityExists = capabilityPaths.some(async (path) => {
+      const config = await loadCapabilityConfig(path);
+      return config.capability.id === name;
+    });
+    if (!capabilityExists) {
+      console.error(`Error: Capability '${name}' not found`);
+      console.log("");
+      console.log("Run 'dev capability list' to see available capabilities");
+      process.exit(1);
+    }
+    await enableCapability(name);
+    console.log(`✓ Enabled capability: ${name}`);
+    console.log("");
+    const adapters = await getEnabledAdapters();
+    await syncAgentConfiguration({ adapters });
+  } catch (error) {
+    console.error("Error enabling capability:", error);
+    process.exit(1);
+  }
+}
+async function runCapabilityDisable(_flags, name) {
+  try {
+    await disableCapability(name);
+    console.log(`✓ Disabled capability: ${name}`);
+    console.log("");
+    const adapters = await getEnabledAdapters();
+    await syncAgentConfiguration({ adapters });
+  } catch (error) {
+    console.error("Error disabling capability:", error);
+    process.exit(1);
+  }
+}
+var listCommand = buildCommand({
+  docs: {
+    brief: "List all discovered capabilities"
+  },
+  parameters: {},
+  async func() {
+    await runCapabilityList();
+  }
+});
+var enableCommand = buildCommand({
+  docs: {
+    brief: "Enable a capability"
+  },
+  parameters: {
+    flags: {},
+    positional: {
+      kind: "tuple",
+      parameters: [
+        {
+          brief: "Capability name to enable",
+          parse: String
+        }
+      ]
+    }
+  },
+  func: runCapabilityEnable
+});
+var disableCommand = buildCommand({
+  docs: {
+    brief: "Disable a capability"
+  },
+  parameters: {
+    flags: {},
+    positional: {
+      kind: "tuple",
+      parameters: [
+        {
+          brief: "Capability name to disable",
+          parse: String
+        }
+      ]
+    }
+  },
+  func: runCapabilityDisable
+});
+var capabilityRoutes = buildRouteMap({
+  routes: {
+    list: listCommand,
+    enable: enableCommand,
+    disable: disableCommand
+  },
+  docs: {
+    brief: "Manage capabilities"
+  }
+});
+
+// src/commands/doctor.ts
+import { existsSync as existsSync4 } from "node:fs";
+import { buildCommand as buildCommand2 } from "@stricli/core";
+var doctorCommand = buildCommand2({
+  docs: {
+    brief: "Check OmniDev setup and dependencies"
+  },
+  parameters: {},
+  async func() {
+    return await runDoctor();
+  }
+});
+async function runDoctor() {
+  console.log("OmniDev Doctor");
+  console.log("==============");
+  console.log("");
+  const checks = [
+    checkBunVersion(),
+    checkOmniLocalDir(),
+    checkConfig(),
+    checkRootGitignore(),
+    checkCapabilitiesDir()
+  ];
+  let allPassed = true;
+  for (const check of checks) {
+    const { name, passed, message, fix } = await check;
+    const icon = passed ? "✓" : "✗";
+    console.log(`${icon} ${name}: ${message}`);
+    if (!passed && fix) {
+      console.log(`  Fix: ${fix}`);
+    }
+    if (!passed)
+      allPassed = false;
+  }
+  console.log("");
+  if (allPassed) {
+    console.log("All checks passed!");
+  } else {
+    console.log("Some checks failed. Please fix the issues above.");
+    process.exit(1);
+  }
+}
+async function checkBunVersion() {
+  const version = Bun.version;
+  const parts = version.split(".");
+  const firstPart = parts[0];
+  if (!firstPart) {
+    return {
+      name: "Bun Version",
+      passed: false,
+      message: `Invalid version format: ${version}`,
+      fix: "Reinstall Bun: curl -fsSL https://bun.sh/install | bash"
+    };
+  }
+  const major = Number.parseInt(firstPart, 10);
+  if (major < 1) {
+    return {
+      name: "Bun Version",
+      passed: false,
+      message: `v${version}`,
+      fix: "Upgrade Bun: curl -fsSL https://bun.sh/install | bash"
+    };
+  }
+  return {
+    name: "Bun Version",
+    passed: true,
+    message: `v${version}`
+  };
+}
+async function checkOmniLocalDir() {
+  const exists = existsSync4(".omni");
+  if (!exists) {
+    return {
+      name: ".omni/ directory",
+      passed: false,
+      message: "Not found",
+      fix: "Run: omnidev init"
+    };
+  }
+  return {
+    name: ".omni/ directory",
+    passed: true,
+    message: "Found"
+  };
+}
+async function checkConfig() {
+  const configPath = "omni.toml";
+  if (!existsSync4(configPath)) {
+    return {
+      name: "Configuration",
+      passed: false,
+      message: "omni.toml not found",
+      fix: "Run: omnidev init"
+    };
+  }
+  try {
+    const { loadConfig } = await import("@omnidev-ai/core");
+    await loadConfig();
+    return {
+      name: "Configuration",
+      passed: true,
+      message: "Valid"
+    };
+  } catch (error) {
+    return {
+      name: "Configuration",
+      passed: false,
+      message: `Invalid: ${error instanceof Error ? error.message : String(error)}`,
+      fix: "Check omni.toml syntax"
+    };
+  }
+}
+async function checkRootGitignore() {
+  const gitignorePath = ".gitignore";
+  if (!existsSync4(gitignorePath)) {
+    return {
+      name: "Root .gitignore",
+      passed: false,
+      message: ".gitignore not found",
+      fix: "Run: omnidev init"
+    };
+  }
+  const content = await Bun.file(gitignorePath).text();
+  const lines = content.split(`
+`).map((line) => line.trim());
+  const hasOmniDir = lines.includes(".omni/");
+  const hasLocalToml = lines.includes("omni.local.toml");
+  if (!hasOmniDir || !hasLocalToml) {
+    const missing = [];
+    if (!hasOmniDir)
+      missing.push(".omni/");
+    if (!hasLocalToml)
+      missing.push("omni.local.toml");
+    return {
+      name: "Root .gitignore",
+      passed: false,
+      message: `Missing entries: ${missing.join(", ")}`,
+      fix: "Run: omnidev init"
+    };
+  }
+  return {
+    name: "Root .gitignore",
+    passed: true,
+    message: "Found with OmniDev entries"
+  };
+}
+async function checkCapabilitiesDir() {
+  const capabilitiesDirPath = ".omni/capabilities";
+  if (!existsSync4(capabilitiesDirPath)) {
+    return {
+      name: "Capabilities Directory",
+      passed: true,
+      message: "Not found (no custom capabilities)"
+    };
+  }
+  return {
+    name: "Capabilities Directory",
+    passed: true,
+    message: "Found"
+  };
+}
+
+// src/commands/init.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync4 } from "node:fs";
+import {
+  generateInstructionsTemplate,
+  loadConfig,
+  setActiveProfile,
+  syncAgentConfiguration as syncAgentConfiguration2,
+  writeConfig,
+  writeEnabledProviders
+} from "@omnidev-ai/core";
+import { buildCommand as buildCommand3 } from "@stricli/core";
+
+// src/prompts/provider.ts
+import { checkbox } from "@inquirer/prompts";
+async function promptForProviders() {
+  const answers = await checkbox({
+    message: "Select your AI provider(s):",
+    choices: [
+      { name: "Claude Code (Claude CLI)", value: "claude-code", checked: true },
+      { name: "Cursor", value: "cursor", checked: false },
+      { name: "Codex", value: "codex", checked: false },
+      { name: "OpenCode", value: "opencode", checked: false }
+    ],
+    required: true
+  });
+  return answers;
+}
+
+// src/commands/init.ts
+async function runInit(_flags, providerArg) {
+  console.log("Initializing OmniDev...");
+  mkdirSync4(".omni", { recursive: true });
+  mkdirSync4(".omni/capabilities", { recursive: true });
+  mkdirSync4(".omni/state", { recursive: true });
+  await updateRootGitignore();
+  let providerIds;
+  if (providerArg) {
+    providerIds = parseProviderArg(providerArg);
+  } else {
+    providerIds = await promptForProviders();
+  }
+  await writeEnabledProviders(providerIds);
+  if (!existsSync5("omni.toml")) {
+    await writeConfig({
+      project: "my-project",
+      profiles: {
+        default: {
+          capabilities: []
+        },
+        planning: {
+          capabilities: []
+        },
+        coding: {
+          capabilities: []
+        }
+      }
+    });
+    await setActiveProfile("default");
+  }
+  if (!existsSync5(".omni/instructions.md")) {
+    await Bun.write(".omni/instructions.md", generateInstructionsTemplate());
+  }
+  const config = await loadConfig();
+  const ctx = {
+    projectRoot: process.cwd(),
+    config
+  };
+  const allAdapters = getAllAdapters();
+  const selectedAdapters = allAdapters.filter((a) => providerIds.includes(a.id));
+  const filesCreated = [];
+  const filesExisting = [];
+  for (const adapter of selectedAdapters) {
+    if (adapter.init) {
+      const result = await adapter.init(ctx);
+      if (result.filesCreated) {
+        filesCreated.push(...result.filesCreated);
+      }
+    }
+  }
+  const enabledAdapters = await getEnabledAdapters();
+  await syncAgentConfiguration2({ silent: true, adapters: enabledAdapters });
+  console.log("");
+  console.log(`✓ OmniDev initialized for ${selectedAdapters.map((a) => a.displayName).join(" and ")}!`);
+  console.log("");
+  if (filesCreated.length > 0) {
+    console.log("\uD83D\uDCDD Don't forget to add your project description to:");
+    console.log("   • .omni/instructions.md");
+  }
+  if (filesExisting.length > 0) {
+    console.log("\uD83D\uDCDD Add this line to your existing file(s):");
+    for (const file of filesExisting) {
+      console.log(`   • ${file}: @import .omni/instructions.md`);
+    }
+  }
+  console.log("");
+  console.log("\uD83D\uDCA1 Recommendation:");
+  console.log("   Add provider-specific files to .gitignore:");
+  console.log("   CLAUDE.md, .claude/, AGENTS.md, .cursor/, .mcp.json");
+  console.log("");
+  console.log("   Run 'omnidev capability list' to see available capabilities.");
+}
+var initCommand = buildCommand3({
+  parameters: {
+    flags: {},
+    positional: {
+      kind: "tuple",
+      parameters: [
+        {
+          brief: "AI provider(s): claude-code, cursor, codex, opencode, or comma-separated",
+          parse: String,
+          optional: true
+        }
+      ]
+    }
+  },
+  docs: {
+    brief: "Initialize OmniDev in the current project"
+  },
+  func: runInit
+});
+function parseProviderArg(arg) {
+  const allAdapters = getAllAdapters();
+  const validIds = new Set(allAdapters.map((a) => a.id));
+  if (arg.toLowerCase() === "both") {
+    return ["claude-code", "cursor"];
+  }
+  const parts = arg.split(",").map((p) => p.trim().toLowerCase());
+  const result = [];
+  for (const part of parts) {
+    let id = part;
+    if (id === "claude") {
+      id = "claude-code";
+    }
+    if (!validIds.has(id)) {
+      throw new Error(`Invalid provider: ${part}. Valid providers: ${[...validIds].join(", ")}`);
+    }
+    result.push(id);
+  }
+  return result;
+}
+async function updateRootGitignore() {
+  const gitignorePath = ".gitignore";
+  const entriesToAdd = [".omni/", "omni.local.toml"];
+  let content = "";
+  if (existsSync5(gitignorePath)) {
+    content = await Bun.file(gitignorePath).text();
+  }
+  const lines = content.split(`
+`);
+  const missingEntries = entriesToAdd.filter((entry) => !lines.some((line) => line.trim() === entry));
+  if (missingEntries.length === 0) {
+    return;
+  }
+  const needsNewline = content.length > 0 && !content.endsWith(`
+`);
+  const section = `${needsNewline ? `
+` : ""}# OmniDev
+${missingEntries.join(`
+`)}
+`;
+  await Bun.write(gitignorePath, content + section);
+}
+
+// src/commands/profile.ts
+import { existsSync as existsSync6 } from "node:fs";
+import {
+  getActiveProfile,
+  loadConfig as loadConfig2,
+  resolveEnabledCapabilities,
+  setActiveProfile as setActiveProfile2,
+  syncAgentConfiguration as syncAgentConfiguration3
+} from "@omnidev-ai/core";
+import { buildCommand as buildCommand4, buildRouteMap as buildRouteMap2 } from "@stricli/core";
+var listCommand2 = buildCommand4({
+  docs: {
+    brief: "List available profiles"
+  },
+  parameters: {},
+  async func() {
+    await runProfileList();
+  }
+});
+async function runSetCommand(_flags, profileName) {
+  await runProfileSet(profileName);
+}
+var setCommand = buildCommand4({
+  docs: {
+    brief: "Set the active profile"
+  },
+  parameters: {
+    flags: {},
+    positional: {
+      kind: "tuple",
+      parameters: [
+        {
+          brief: "Profile name",
+          parse: String
+        }
+      ]
+    }
+  },
+  func: runSetCommand
+});
+var profileRoutes = buildRouteMap2({
+  routes: {
+    list: listCommand2,
+    set: setCommand
+  },
+  docs: {
+    brief: "Manage capability profiles"
+  }
+});
+async function runProfileList() {
+  try {
+    if (!existsSync6("omni.toml")) {
+      console.log("✗ No config file found");
+      console.log("  Run: omnidev init");
+      process.exit(1);
+    }
+    const config = await loadConfig2();
+    const activeProfile = await getActiveProfile() ?? config.active_profile ?? "default";
+    const profiles = config.profiles ?? {};
+    const profileNames = Object.keys(profiles);
+    if (profileNames.length === 0) {
+      console.log("No profiles defined in omni.toml");
+      console.log("");
+      console.log("Using default capabilities from omni.toml");
+      return;
+    }
+    console.log("Available Profiles:");
+    console.log("");
+    for (const name of profileNames) {
+      const isActive = name === activeProfile;
+      const icon = isActive ? "●" : "○";
+      const profile = profiles[name];
+      if (profile === undefined) {
+        continue;
+      }
+      console.log(`${icon} ${name}${isActive ? " (active)" : ""}`);
+      const capabilities = resolveEnabledCapabilities(config, name);
+      if (capabilities.length > 0) {
+        console.log(`  Capabilities: ${capabilities.join(", ")}`);
+      } else {
+        console.log("  Capabilities: none");
+      }
+      console.log("");
+    }
+  } catch (error) {
+    console.error("✗ Error loading profiles:", error);
+    process.exit(1);
+  }
+}
+async function runProfileSet(profileName) {
+  try {
+    if (!existsSync6("omni.toml")) {
+      console.log("✗ No config file found");
+      console.log("  Run: omnidev init");
+      process.exit(1);
+    }
+    const config = await loadConfig2();
+    const profiles = config.profiles ?? {};
+    if (!(profileName in profiles)) {
+      console.log(`✗ Profile "${profileName}" not found in omni.toml`);
+      console.log("");
+      console.log("Available profiles:");
+      const profileNames = Object.keys(profiles);
+      if (profileNames.length === 0) {
+        console.log("  (none defined)");
+      } else {
+        for (const name of profileNames) {
+          console.log(`  - ${name}`);
+        }
+      }
+      process.exit(1);
+    }
+    await setActiveProfile2(profileName);
+    console.log(`✓ Active profile set to: ${profileName}`);
+    console.log("");
+    const adapters = await getEnabledAdapters();
+    await syncAgentConfiguration3({ adapters });
+  } catch (error) {
+    console.error("✗ Error setting profile:", error);
+    process.exit(1);
+  }
+}
+
+// src/commands/provider.ts
+import {
+  disableProvider,
+  enableProvider,
+  readEnabledProviders as readEnabledProviders2,
+  syncAgentConfiguration as syncAgentConfiguration4
+} from "@omnidev-ai/core";
+import { buildCommand as buildCommand5, buildRouteMap as buildRouteMap3 } from "@stricli/core";
+async function runProviderList() {
+  const enabled = await readEnabledProviders2();
+  const allAdapters = getAllAdapters();
+  console.log("Available providers:");
+  console.log("");
+  for (const adapter of allAdapters) {
+    const isEnabled = enabled.includes(adapter.id);
+    const marker = isEnabled ? "●" : "○";
+    console.log(`  ${marker} ${adapter.displayName} (${adapter.id})`);
+  }
+  console.log("");
+  console.log("Legend: ● enabled, ○ disabled");
+}
+async function runProviderEnable(_flags, providerId) {
+  if (!providerId) {
+    console.error("Error: Provider ID is required");
+    console.error("Usage: omnidev provider enable <provider-id>");
+    process.exit(1);
+  }
+  const allAdapters = getAllAdapters();
+  const adapter = allAdapters.find((a) => a.id === providerId);
+  if (!adapter) {
+    console.error(`Error: Unknown provider "${providerId}"`);
+    console.error("Available providers:");
+    for (const a of allAdapters) {
+      console.error(`  - ${a.id}`);
+    }
+    process.exit(1);
+  }
+  await enableProvider(providerId);
+  console.log(`✓ Enabled provider: ${adapter.displayName}`);
+  const enabledAdapters = await getEnabledAdapters();
+  await syncAgentConfiguration4({ silent: false, adapters: enabledAdapters });
+}
+async function runProviderDisable(_flags, providerId) {
+  if (!providerId) {
+    console.error("Error: Provider ID is required");
+    console.error("Usage: omnidev provider disable <provider-id>");
+    process.exit(1);
+  }
+  const allAdapters = getAllAdapters();
+  const adapter = allAdapters.find((a) => a.id === providerId);
+  if (!adapter) {
+    console.error(`Error: Unknown provider "${providerId}"`);
+    console.error("Available providers:");
+    for (const a of allAdapters) {
+      console.error(`  - ${a.id}`);
+    }
+    process.exit(1);
+  }
+  await disableProvider(providerId);
+  console.log(`✓ Disabled provider: ${adapter.displayName}`);
+}
+var listCommand3 = buildCommand5({
+  parameters: {
+    flags: {},
+    positional: { kind: "tuple", parameters: [] }
+  },
+  docs: {
+    brief: "List all providers and their status"
+  },
+  func: runProviderList
+});
+var enableCommand2 = buildCommand5({
+  parameters: {
+    flags: {},
+    positional: {
+      kind: "tuple",
+      parameters: [
+        {
+          brief: "Provider ID to enable",
+          parse: String,
+          optional: true
+        }
+      ]
+    }
+  },
+  docs: {
+    brief: "Enable a provider"
+  },
+  func: runProviderEnable
+});
+var disableCommand2 = buildCommand5({
+  parameters: {
+    flags: {},
+    positional: {
+      kind: "tuple",
+      parameters: [
+        {
+          brief: "Provider ID to disable",
+          parse: String,
+          optional: true
+        }
+      ]
+    }
+  },
+  docs: {
+    brief: "Disable a provider"
+  },
+  func: runProviderDisable
+});
+var providerRoutes = buildRouteMap3({
+  routes: {
+    list: listCommand3,
+    enable: enableCommand2,
+    disable: disableCommand2
+  },
+  docs: {
+    brief: "Manage AI provider adapters"
+  }
+});
+
+// src/commands/sync.ts
+import { getActiveProfile as getActiveProfile2, loadConfig as loadConfig3, syncAgentConfiguration as syncAgentConfiguration5 } from "@omnidev-ai/core";
+import { buildCommand as buildCommand6 } from "@stricli/core";
+var syncCommand = buildCommand6({
+  docs: {
+    brief: "Manually sync all capabilities, roles, and instructions"
+  },
+  parameters: {},
+  async func() {
+    return await runSync();
+  }
+});
+async function runSync() {
+  console.log("Syncing OmniDev configuration...");
+  console.log("");
+  try {
+    const config = await loadConfig3();
+    const activeProfile = await getActiveProfile2() ?? config.active_profile ?? "default";
+    const adapters = await getEnabledAdapters();
+    const result = await syncAgentConfiguration5({ silent: false, adapters });
+    console.log("");
+    console.log("✓ Sync completed successfully!");
+    console.log("");
+    console.log(`Profile: ${activeProfile}`);
+    console.log(`Capabilities: ${result.capabilities.join(", ") || "none"}`);
+    console.log(`Providers: ${adapters.map((a) => a.displayName).join(", ") || "none"}`);
+    console.log("");
+    console.log("Synced components:");
+    console.log("  • Capability registry");
+    console.log("  • Capability sync hooks");
+    console.log("  • .omni/.gitignore");
+    console.log("  • .omni/instructions.md");
+    if (adapters.length > 0) {
+      console.log("  • Provider-specific files");
+    }
+  } catch (error) {
+    console.error("");
+    console.error("✗ Sync failed:");
+    console.error(`  ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+}
+
+// src/lib/debug.ts
+import { debug } from "@omnidev-ai/core";
+
+// src/lib/dynamic-app.ts
+async function buildDynamicApp() {
+  const routes = {
+    init: initCommand,
+    doctor: doctorCommand,
+    sync: syncCommand,
+    capability: capabilityRoutes,
+    profile: profileRoutes,
+    provider: providerRoutes
+  };
+  debug("Core routes registered", Object.keys(routes));
+  if (existsSync7(".omni/config.toml")) {
+    try {
+      const capabilityCommands = await loadCapabilityCommands();
+      debug("Capability commands loaded", {
+        commands: Object.keys(capabilityCommands),
+        details: Object.entries(capabilityCommands).map(([name, cmd]) => ({
+          name,
+          type: typeof cmd,
+          constructor: cmd?.constructor?.name,
+          keys: Object.keys(cmd),
+          hasGetRoutingTargetForInput: typeof cmd?.getRoutingTargetForInput
+        }))
+      });
+      Object.assign(routes, capabilityCommands);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.warn(`Warning: Failed to load capability commands: ${errorMessage}`);
+      debug("Full error loading capabilities", error);
+    }
+  }
+  debug("Final routes", Object.keys(routes));
+  const app = buildApplication(buildRouteMap4({
+    routes,
+    docs: {
+      brief: "OmniDev commands"
+    }
+  }), {
+    name: "omnidev",
+    versionInfo: {
+      currentVersion: "0.1.0"
+    }
+  });
+  debug("App built successfully");
+  return app;
+}
+async function loadCapabilityCommands() {
+  const { buildCapabilityRegistry, installCapabilityDependencies } = await import("@omnidev-ai/core");
+  await installCapabilityDependencies(true);
+  const registry = await buildCapabilityRegistry();
+  const capabilities = registry.getAllCapabilities();
+  const commands = {};
+  for (const capability of capabilities) {
+    try {
+      debug(`Loading capability '${capability.id}'`, { path: capability.path });
+      const capabilityExport = await loadCapabilityExport(capability);
+      debug(`Capability '${capability.id}' export`, {
+        found: !!capabilityExport,
+        hasCLICommands: !!capabilityExport?.cliCommands,
+        cliCommands: capabilityExport?.cliCommands ? Object.keys(capabilityExport.cliCommands) : []
+      });
+      if (capabilityExport?.cliCommands) {
+        for (const [commandName, command] of Object.entries(capabilityExport.cliCommands)) {
+          if (commands[commandName]) {
+            console.warn(`Command '${commandName}' from capability '${capability.id}' conflicts with existing command. Using '${capability.id}' version.`);
+          }
+          commands[commandName] = command;
+          debug(`Registered command '${commandName}' from '${capability.id}'`, {
+            type: typeof command,
+            constructor: command?.constructor?.name
+          });
+        }
+      }
+    } catch (error) {
+      console.error(`Failed to load capability '${capability.id}':`, error);
+    }
+  }
+  return commands;
+}
+async function loadCapabilityExport(capability) {
+  const capabilityPath = join5(process.cwd(), capability.path);
+  const indexPath = join5(capabilityPath, "index.ts");
+  if (!existsSync7(indexPath)) {
+    const jsIndexPath = join5(capabilityPath, "index.js");
+    if (!existsSync7(jsIndexPath)) {
+      return null;
+    }
+    const module2 = await import(jsIndexPath);
+    if (!module2.default) {
+      return null;
+    }
+    return module2.default;
+  }
+  const module = await import(indexPath);
+  if (!module.default) {
+    return null;
+  }
+  const capExport = module.default;
+  if (capExport.cliCommands) {
+    for (const [name, cmd] of Object.entries(capExport.cliCommands)) {
+      debug(`CLI command '${name}' structure`, {
+        type: typeof cmd,
+        constructor: cmd?.constructor?.name,
+        keys: Object.keys(cmd),
+        hasGetRoutingTargetForInput: typeof cmd?.getRoutingTargetForInput,
+        routesKeys: cmd.routes ? Object.keys(cmd.routes) : undefined
+      });
+    }
+  }
+  return capExport;
+}
+
+// src/index.ts
+var app = await buildDynamicApp();
+debug("CLI startup", {
+  arguments: process.argv.slice(2),
+  cwd: process.cwd()
+});
+try {
+  run(app, process.argv.slice(2), {
+    process
+  });
+} catch (error) {
+  if (error instanceof Error) {
+    if (error.message.includes("getRoutingTargetForInput") || error.stack?.includes("@stricli/core")) {
+      const args = process.argv.slice(2);
+      console.error(`
+Error: Command not found or invalid usage.`);
+      if (args.length > 0) {
+        console.error(`
+You tried to run: omnidev ${args.join(" ")}`);
+        console.error(`
+This could mean:`);
+        console.error("  1. The command doesn't exist");
+        console.error("  2. A required capability is not enabled");
+        console.error(`  3. Invalid command syntax
+`);
+      }
+      console.error("Run 'omnidev --help' to see available commands");
+      console.error(`
+To enable capabilities, run: omnidev capability enable <name>`);
+      console.error("To see enabled capabilities: omnidev capability list");
+      process.exit(1);
+    } else {
+      throw error;
+    }
+  }
+}