@omnidev-ai/cli 0.9.0 → 0.10.0

package/dist/index.js

@@ -24,149 +24,213 @@ import { run } from "@stricli/core";
 // src/lib/dynamic-app.ts
 import { existsSync as existsSync8 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
-import { join as join5 } from "node:path";
+import { join as join9 } from "node:path";
 import { buildApplication, buildRouteMap as buildRouteMap5 } from "@stricli/core";
 
 // src/commands/add.ts
-import { existsSync as existsSync4 } from "node:fs";
+import { existsSync as existsSync3 } from "node:fs";
+import { basename, resolve } from "node:path";
 
-// ../adapters/src/claude-code/index.ts
-import { existsSync, mkdirSync } from "node:fs";
-import { readFile, writeFile } from "node:fs/promises";
+// ../adapters/src/writers/cursor-rules.ts
+import { mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
-import {
-  transformHooksConfig
-} from "@omnidev-ai/core";
-var claudeCodeAdapter = {
-  id: "claude-code",
-  displayName: "Claude Code",
-  async init(_ctx) {
+var CursorRulesWriter = {
+  id: "cursor-rules",
+  async write(bundle, ctx) {
+    const rulesDir = join(ctx.projectRoot, ctx.outputPath);
+    await mkdir(rulesDir, { recursive: true });
+    const filesWritten = [];
+    for (const rule of bundle.rules) {
+      const rulePath = join(rulesDir, `omnidev-${rule.name}.mdc`);
+      await writeFile(rulePath, rule.content, "utf-8");
+      filesWritten.push(join(ctx.outputPath, `omnidev-${rule.name}.mdc`));
+    }
     return {
-      filesCreated: [],
-      message: "Claude Code adapter initialized"
+      filesWritten
     };
-  },
-  async sync(bundle, ctx) {
+  }
+};
+// ../adapters/src/writers/hooks.ts
+import { existsSync } from "node:fs";
+import { mkdir as mkdir2, readFile, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname, join as join2 } from "node:path";
+import { transformHooksConfig } from "@omnidev-ai/core";
+var HooksWriter = {
+  id: "hooks",
+  async write(bundle, ctx) {
+    if (!bundle.hooks) {
+      return { filesWritten: [] };
+    }
+    const settingsPath = join2(ctx.projectRoot, ctx.outputPath);
+    const parentDir = dirname(settingsPath);
+    await mkdir2(parentDir, { recursive: true });
+    const claudeHooks = transformHooksConfig(bundle.hooks, "toClaude");
+    let existingSettings = {};
+    if (existsSync(settingsPath)) {
+      try {
+        const content = await readFile(settingsPath, "utf-8");
+        existingSettings = JSON.parse(content);
+      } catch {
+        existingSettings = {};
+      }
+    }
+    const newSettings = {
+      ...existingSettings,
+      hooks: claudeHooks
+    };
+    await writeFile2(settingsPath, `${JSON.stringify(newSettings, null, 2)}
+`, "utf-8");
+    return {
+      filesWritten: [ctx.outputPath]
+    };
+  }
+};
+// ../adapters/src/writers/instructions-md.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { mkdir as mkdir3, readFile as readFile2, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname as dirname2, join as join3 } from "node:path";
+var InstructionsMdWriter = {
+  id: "instructions-md",
+  async write(bundle, ctx) {
+    const outputFullPath = join3(ctx.projectRoot, ctx.outputPath);
+    const parentDir = dirname2(outputFullPath);
+    if (parentDir !== ctx.projectRoot) {
+      await mkdir3(parentDir, { recursive: true });
+    }
+    const omniMdPath = join3(ctx.projectRoot, "OMNI.md");
+    let omniMdContent = "";
+    if (existsSync2(omniMdPath)) {
+      omniMdContent = await readFile2(omniMdPath, "utf-8");
+    }
+    let content = omniMdContent;
+    content += `
+
+## OmniDev
+
+${bundle.instructionsContent}
+`;
+    await writeFile3(outputFullPath, content, "utf-8");
+    return {
+      filesWritten: [ctx.outputPath]
+    };
+  }
+};
+// ../adapters/src/writers/skills.ts
+import { mkdir as mkdir4, writeFile as writeFile4 } from "node:fs/promises";
+import { join as join4 } from "node:path";
+var SkillsWriter = {
+  id: "skills",
+  async write(bundle, ctx) {
+    const skillsDir = join4(ctx.projectRoot, ctx.outputPath);
+    await mkdir4(skillsDir, { recursive: true });
     const filesWritten = [];
-    const filesDeleted = [];
-    const claudeMdPath = join(ctx.projectRoot, "CLAUDE.md");
-    const claudeMdContent = await generateClaudeMdContent(ctx.projectRoot);
-    await writeFile(claudeMdPath, claudeMdContent, "utf-8");
-    filesWritten.push("CLAUDE.md");
-    const claudeDir = join(ctx.projectRoot, ".claude");
-    mkdirSync(claudeDir, { recursive: true });
-    const skillsDir = join(claudeDir, "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 skillDir = join4(skillsDir, skill.name);
+      await mkdir4(skillDir, { recursive: true });
+      const skillPath = join4(skillDir, "SKILL.md");
       const content = `---
 name: ${skill.name}
 description: "${skill.description}"
 ---
 
 ${skill.instructions}`;
-      await writeFile(skillPath, content, "utf-8");
-      filesWritten.push(`.claude/skills/${skill.name}/SKILL.md`);
-    }
-    if (bundle.hooks) {
-      const settingsPath = join(claudeDir, "settings.json");
-      const hooksWritten = await writeHooksToSettings(settingsPath, bundle.hooks);
-      if (hooksWritten) {
-        filesWritten.push(".claude/settings.json");
-      }
+      await writeFile4(skillPath, content, "utf-8");
+      filesWritten.push(join4(ctx.outputPath, skill.name, "SKILL.md"));
     }
     return {
-      filesWritten,
-      filesDeleted
+      filesWritten
     };
   }
 };
-async function generateClaudeMdContent(projectRoot) {
-  const omniMdPath = join(projectRoot, "OMNI.md");
-  let omniMdContent = "";
-  if (existsSync(omniMdPath)) {
-    omniMdContent = await readFile(omniMdPath, "utf-8");
-  }
-  let content = omniMdContent;
-  content += `
-
-## OmniDev
-
-@import .omni/instructions.md
-`;
-  return content;
-}
-async function writeHooksToSettings(settingsPath, hooks) {
-  const claudeHooks = transformHooksConfig(hooks, "toClaude");
-  let existingSettings = {};
-  if (existsSync(settingsPath)) {
-    try {
-      const content = await readFile(settingsPath, "utf-8");
-      existingSettings = JSON.parse(content);
-    } catch {
-      existingSettings = {};
+// ../adapters/src/writers/executor.ts
+async function executeWriters(writerConfigs, bundle, projectRoot) {
+  const seen = new Set;
+  const uniqueConfigs = [];
+  let deduplicatedCount = 0;
+  for (const config of writerConfigs) {
+    const key = `${config.writer.id}:${config.outputPath}`;
+    if (seen.has(key)) {
+      deduplicatedCount++;
+      continue;
     }
+    seen.add(key);
+    uniqueConfigs.push(config);
+  }
+  const allFilesWritten = [];
+  for (const config of uniqueConfigs) {
+    const result = await config.writer.write(bundle, {
+      outputPath: config.outputPath,
+      projectRoot
+    });
+    allFilesWritten.push(...result.filesWritten);
   }
-  const newSettings = {
-    ...existingSettings,
-    hooks: claudeHooks
+  return {
+    filesWritten: allFilesWritten,
+    deduplicatedCount
   };
-  await writeFile(settingsPath, `${JSON.stringify(newSettings, null, 2)}
-`, "utf-8");
-  return true;
 }
+// ../adapters/src/claude-code/index.ts
+var claudeCodeAdapter = {
+  id: "claude-code",
+  displayName: "Claude Code",
+  writers: [
+    { writer: InstructionsMdWriter, outputPath: "CLAUDE.md" },
+    { writer: SkillsWriter, outputPath: ".claude/skills/" },
+    { writer: HooksWriter, outputPath: ".claude/settings.json" }
+  ],
+  async init(_ctx) {
+    return {
+      filesCreated: [],
+      message: "Claude Code adapter initialized"
+    };
+  },
+  async sync(bundle, ctx) {
+    const result = await executeWriters(this.writers, bundle, ctx.projectRoot);
+    return {
+      filesWritten: result.filesWritten,
+      filesDeleted: []
+    };
+  }
+};
 // ../adapters/src/codex/index.ts
-import { existsSync as existsSync2 } from "node:fs";
-import { readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
-import { join as join2 } from "node:path";
+import { mkdirSync } from "node:fs";
+import { join as join5 } from "node:path";
 var codexAdapter = {
   id: "codex",
   displayName: "Codex",
-  async init(_ctx) {
+  writers: [
+    { writer: InstructionsMdWriter, outputPath: "AGENTS.md" },
+    { writer: SkillsWriter, outputPath: ".codex/skills/" }
+  ],
+  async init(ctx) {
+    const codexDir = join5(ctx.projectRoot, ".codex");
+    mkdirSync(codexDir, { recursive: true });
     return {
-      filesCreated: [],
+      filesCreated: [".codex/"],
       message: "Codex adapter initialized"
     };
   },
-  async sync(_bundle, ctx) {
-    const filesWritten = [];
-    const filesDeleted = [];
-    const agentsMdPath = join2(ctx.projectRoot, "AGENTS.md");
-    const agentsMdContent = await generateAgentsMdContent(ctx.projectRoot);
-    await writeFile2(agentsMdPath, agentsMdContent, "utf-8");
-    filesWritten.push("AGENTS.md");
+  async sync(bundle, ctx) {
+    const result = await executeWriters(this.writers, bundle, ctx.projectRoot);
     return {
-      filesWritten,
-      filesDeleted
+      filesWritten: result.filesWritten,
+      filesDeleted: []
     };
   }
 };
-async function generateAgentsMdContent(projectRoot) {
-  const omniMdPath = join2(projectRoot, "OMNI.md");
-  let omniMdContent = "";
-  if (existsSync2(omniMdPath)) {
-    omniMdContent = await readFile2(omniMdPath, "utf-8");
-  }
-  let content = omniMdContent;
-  content += `
-
-## OmniDev
-
-@import .omni/instructions.md
-`;
-  return content;
-}
 // ../adapters/src/cursor/index.ts
 import { mkdirSync as mkdirSync2 } from "node:fs";
-import { writeFile as writeFile3 } from "node:fs/promises";
-import { join as join3 } from "node:path";
+import { join as join6 } from "node:path";
 var cursorAdapter = {
   id: "cursor",
   displayName: "Cursor",
+  writers: [
+    { writer: InstructionsMdWriter, outputPath: "CLAUDE.md" },
+    { writer: SkillsWriter, outputPath: ".claude/skills/" },
+    { writer: CursorRulesWriter, outputPath: ".cursor/rules/" }
+  ],
   async init(ctx) {
-    const rulesDir = join3(ctx.projectRoot, ".cursor", "rules");
+    const rulesDir = join6(ctx.projectRoot, ".cursor", "rules");
     mkdirSync2(rulesDir, { recursive: true });
     return {
       filesCreated: [".cursor/rules/"],
@@ -174,66 +238,39 @@ var cursorAdapter = {
     };
   },
   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 writeFile3(rulePath, rule.content, "utf-8");
-      filesWritten.push(`.cursor/rules/omnidev-${rule.name}.mdc`);
-    }
+    const result = await executeWriters(this.writers, bundle, ctx.projectRoot);
     return {
-      filesWritten,
-      filesDeleted
+      filesWritten: result.filesWritten,
+      filesDeleted: []
     };
   }
 };
 // ../adapters/src/opencode/index.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync3 } from "node:fs";
-import { readFile as readFile3, writeFile as writeFile4 } from "node:fs/promises";
-import { join as join4 } from "node:path";
+import { mkdirSync as mkdirSync3 } from "node:fs";
+import { join as join7 } from "node:path";
 var opencodeAdapter = {
   id: "opencode",
   displayName: "OpenCode",
+  writers: [
+    { writer: InstructionsMdWriter, outputPath: "AGENTS.md" },
+    { writer: SkillsWriter, outputPath: ".opencode/skills/" }
+  ],
   async init(ctx) {
-    const opencodeDir = join4(ctx.projectRoot, ".opencode");
+    const opencodeDir = join7(ctx.projectRoot, ".opencode");
     mkdirSync3(opencodeDir, { recursive: true });
     return {
       filesCreated: [".opencode/"],
       message: "OpenCode adapter initialized"
     };
   },
-  async sync(_bundle, ctx) {
-    const filesWritten = [];
-    const filesDeleted = [];
-    const opencodeDir = join4(ctx.projectRoot, ".opencode");
-    mkdirSync3(opencodeDir, { recursive: true });
-    const instructionsPath = join4(opencodeDir, "instructions.md");
-    const instructionsContent = await generateOpencodeInstructionsContent(ctx.projectRoot);
-    await writeFile4(instructionsPath, instructionsContent, "utf-8");
-    filesWritten.push(".opencode/instructions.md");
+  async sync(bundle, ctx) {
+    const result = await executeWriters(this.writers, bundle, ctx.projectRoot);
     return {
-      filesWritten,
-      filesDeleted
+      filesWritten: result.filesWritten,
+      filesDeleted: []
     };
   }
 };
-async function generateOpencodeInstructionsContent(projectRoot) {
-  const omniMdPath = join4(projectRoot, "OMNI.md");
-  let omniMdContent = "";
-  if (existsSync3(omniMdPath)) {
-    omniMdContent = await readFile3(omniMdPath, "utf-8");
-  }
-  let content = omniMdContent;
-  content += `
-
-## OmniDev
-
-@import ../.omni/instructions.md
-`;
-  return content;
-}
 // ../adapters/src/registry.ts
 import { readEnabledProviders } from "@omnidev-ai/core";
 var builtInAdapters = [
@@ -257,37 +294,90 @@ import {
   patchAddCapabilitySource,
   patchAddMcp,
   patchAddToProfile,
-  syncAgentConfiguration
+  syncAgentConfiguration,
+  readCapabilityIdFromPath
 } from "@omnidev-ai/core";
 import { buildCommand, buildRouteMap } from "@stricli/core";
+async function inferCapabilityId(source, sourceType) {
+  if (sourceType === "local") {
+    const localPath = source.startsWith("file://") ? source.slice(7) : source;
+    const resolvedPath = resolve(localPath);
+    const id = await readCapabilityIdFromPath(resolvedPath);
+    if (id) {
+      return id;
+    }
+    return basename(resolvedPath);
+  }
+  const parts = source.replace("github:", "").split("/");
+  if (parts.length >= 2) {
+    return parts[parts.length - 1] ?? parts[1] ?? "capability";
+  }
+  return "capability";
+}
 async function runAddCap(flags, name) {
   try {
-    if (!existsSync4("omni.toml")) {
+    if (!existsSync3("omni.toml")) {
       console.log("✗ No config file found");
       console.log("  Run: omnidev init");
       process.exit(1);
     }
-    if (!flags.github.includes("/")) {
-      console.error("✗ Invalid GitHub repository format");
-      console.log("  Expected format: user/repo");
-      console.log("  Example: omnidev add cap my-cap --github expo/skills");
+    if (!flags.github && !flags.local) {
+      console.error("✗ No source specified");
+      console.log("  Use --github or --local to specify the capability source");
+      console.log("  Example: omnidev add cap --github expo/skills");
+      console.log("  Example: omnidev add cap --local ./capabilities/my-cap");
+      process.exit(1);
+    }
+    if (flags.github && flags.local) {
+      console.error("✗ Cannot specify both --github and --local");
+      console.log("  Use only one source flag");
       process.exit(1);
     }
+    let source;
+    let sourceType;
+    if (flags.local) {
+      sourceType = "local";
+      const localPath = flags.local.startsWith("file://") ? flags.local.slice(7) : flags.local;
+      source = `file://${localPath}`;
+      if (!existsSync3(localPath)) {
+        console.error(`✗ Local path not found: ${localPath}`);
+        process.exit(1);
+      }
+    } else if (flags.github) {
+      sourceType = "github";
+      if (!flags.github.includes("/")) {
+        console.error("✗ Invalid GitHub repository format");
+        console.log("  Expected format: user/repo");
+        console.log("  Example: omnidev add cap --github expo/skills");
+        process.exit(1);
+      }
+      source = `github:${flags.github}`;
+    } else {
+      throw new Error("Unreachable: no source specified");
+    }
+    let capabilityId = name;
+    if (!capabilityId) {
+      const sourceValue = sourceType === "local" ? flags.local : flags.github;
+      if (!sourceValue) {
+        throw new Error("Unreachable: cannot infer capability ID");
+      }
+      capabilityId = await inferCapabilityId(sourceValue, sourceType);
+      console.log(`  Inferred capability ID: ${capabilityId}`);
+    }
     const config = await loadBaseConfig();
     const activeProfile = await getActiveProfile() ?? config.active_profile ?? "default";
-    if (config.capabilities?.sources?.[name]) {
-      console.error(`✗ Capability source "${name}" already exists`);
+    if (config.capabilities?.sources?.[capabilityId]) {
+      console.error(`✗ Capability source "${capabilityId}" already exists`);
       console.log("  Use a different name or remove the existing source first");
       process.exit(1);
     }
-    const source = `github:${flags.github}`;
-    if (flags.path) {
-      await patchAddCapabilitySource(name, { source, path: flags.path });
+    if (flags.path && sourceType === "github") {
+      await patchAddCapabilitySource(capabilityId, { source, path: flags.path });
     } else {
-      await patchAddCapabilitySource(name, source);
+      await patchAddCapabilitySource(capabilityId, source);
     }
-    await patchAddToProfile(activeProfile, name);
-    console.log(`✓ Added capability source: ${name}`);
+    await patchAddToProfile(activeProfile, capabilityId);
+    console.log(`✓ Added capability source: ${capabilityId}`);
     console.log(`  Source: ${source}`);
     if (flags.path) {
       console.log(`  Path: ${flags.path}`);
@@ -304,7 +394,7 @@ async function runAddCap(flags, name) {
 }
 async function runAddMcp(flags, name) {
   try {
-    if (!existsSync4("omni.toml")) {
+    if (!existsSync3("omni.toml")) {
       console.log("✗ No config file found");
       console.log("  Run: omnidev init");
       process.exit(1);
@@ -416,23 +506,46 @@ function parseArgs(argsString) {
   return args;
 }
 async function runAddCapWrapper(flags, name) {
-  await runAddCap({ github: flags.github, path: flags.path }, name);
+  await runAddCap({ github: flags.github, local: flags.local, path: flags.path }, name);
 }
 var addCapCommand = buildCommand({
   docs: {
-    brief: "Add a capability source from GitHub",
-    fullDescription: "Add a capability source from a GitHub repository. The capability will be auto-enabled in the active profile."
+    brief: "Add a capability source from GitHub or local path",
+    fullDescription: `Add a capability source from a GitHub repository or local path. The capability will be auto-enabled in the active profile.
+
+GitHub source:
+  omnidev add cap [name] --github user/repo [--path subdir]
+
+Local source:
+  omnidev add cap [name] --local ./path/to/capability
+
+If the capability name is omitted, it will be inferred from:
+- For local sources: the ID in capability.toml or directory name
+- For GitHub sources: the repository name or last path segment
+
+Examples:
+  omnidev add cap my-cap --github expo/skills
+  omnidev add cap --github expo/skills                     # Infers name as "skills"
+  omnidev add cap --local ./capabilities/my-cap            # Infers name from capability.toml
+  omnidev add cap custom-name --local ./capabilities/my-cap`
   },
   parameters: {
     flags: {
       github: {
         kind: "parsed",
         brief: "GitHub repository in user/repo format",
-        parse: String
+        parse: String,
+        optional: true
+      },
+      local: {
+        kind: "parsed",
+        brief: "Local path to capability directory",
+        parse: String,
+        optional: true
       },
       path: {
         kind: "parsed",
-        brief: "Subdirectory within the repo containing the capability",
+        brief: "Subdirectory within the repo containing the capability (GitHub only)",
         parse: String,
         optional: true
       }
@@ -441,10 +554,16 @@ var addCapCommand = buildCommand({
       kind: "tuple",
       parameters: [
         {
-          brief: "Capability name",
-          parse: String
+          brief: "Capability name (optional, will be inferred if omitted)",
+          parse: String,
+          optional: true
         }
       ]
+    },
+    aliases: {
+      g: "github",
+      l: "local",
+      p: "path"
     }
   },
   func: runAddCapWrapper
@@ -550,15 +669,31 @@ var addRoutes = buildRouteMap({
 });
 
 // src/commands/capability.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync4 } from "node:fs";
+import { writeFile as writeFile5 } from "node:fs/promises";
+import { join as join8 } from "node:path";
+import { input } from "@inquirer/prompts";
 import {
   disableCapability,
   discoverCapabilities,
   enableCapability,
+  generateCapabilityToml,
+  generateHooksTemplate,
+  generateHookScript,
+  generateRuleTemplate,
+  generateSkillTemplate,
   getEnabledCapabilities,
   loadCapabilityConfig,
   syncAgentConfiguration as syncAgentConfiguration2
 } from "@omnidev-ai/core";
 import { buildCommand as buildCommand2, buildRouteMap as buildRouteMap2 } from "@stricli/core";
+
+// src/prompts/capability.ts
+function isValidCapabilityId(id) {
+  return /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/.test(id);
+}
+
+// src/commands/capability.ts
 async function runCapabilityList() {
   try {
     const enabledIds = await getEnabledCapabilities();
@@ -627,6 +762,105 @@ async function runCapabilityDisable(_flags, name) {
     process.exit(1);
   }
 }
+function toTitleCase(kebabCase) {
+  return kebabCase.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+async function runCapabilityNew(flags, capabilityId) {
+  try {
+    if (!existsSync4(".omni")) {
+      console.error("✗ OmniDev is not initialized in this directory.");
+      console.log("");
+      console.log("  Run: omnidev init");
+      process.exit(1);
+    }
+    if (!isValidCapabilityId(capabilityId)) {
+      console.error(`✗ Invalid capability ID: '${capabilityId}'`);
+      console.log("");
+      console.log("  ID must be lowercase, start with a letter, and use kebab-case");
+      console.log("  Example: my-capability, tasks, api-client");
+      process.exit(1);
+    }
+    const id = capabilityId;
+    let capabilityDir;
+    if (flags.path) {
+      capabilityDir = flags.path;
+    } else {
+      const defaultPath = `capabilities/${id}`;
+      capabilityDir = await input({
+        message: "Output path:",
+        default: defaultPath
+      });
+    }
+    if (existsSync4(capabilityDir)) {
+      console.error(`✗ Directory already exists at ${capabilityDir}`);
+      process.exit(1);
+    }
+    const name = toTitleCase(id);
+    mkdirSync4(capabilityDir, { recursive: true });
+    const capabilityToml = generateCapabilityToml({ id, name });
+    await writeFile5(join8(capabilityDir, "capability.toml"), capabilityToml, "utf-8");
+    const skillDir = join8(capabilityDir, "skills", "getting-started");
+    mkdirSync4(skillDir, { recursive: true });
+    await writeFile5(join8(skillDir, "SKILL.md"), generateSkillTemplate("getting-started"), "utf-8");
+    const rulesDir = join8(capabilityDir, "rules");
+    mkdirSync4(rulesDir, { recursive: true });
+    await writeFile5(join8(rulesDir, "coding-standards.md"), generateRuleTemplate("coding-standards"), "utf-8");
+    const hooksDir = join8(capabilityDir, "hooks");
+    mkdirSync4(hooksDir, { recursive: true });
+    await writeFile5(join8(hooksDir, "hooks.toml"), generateHooksTemplate(), "utf-8");
+    await writeFile5(join8(hooksDir, "example-hook.sh"), generateHookScript(), "utf-8");
+    console.log(`✓ Created capability: ${name}`);
+    console.log(`  Location: ${capabilityDir}`);
+    console.log("");
+    console.log("  Files created:");
+    console.log("    - capability.toml");
+    console.log("    - skills/getting-started/SKILL.md");
+    console.log("    - rules/coding-standards.md");
+    console.log("    - hooks/hooks.toml");
+    console.log("    - hooks/example-hook.sh");
+    console.log("");
+    console.log("\uD83D\uDCA1 To add this capability as a local source, run:");
+    console.log(`   omnidev add cap --local ./${capabilityDir}`);
+  } catch (error) {
+    console.error("Error creating capability:", error);
+    process.exit(1);
+  }
+}
+var newCommand = buildCommand2({
+  docs: {
+    brief: "Create a new capability with templates",
+    fullDescription: `Create a new capability with templates at a specified path.
+
+By default, creates the capability at capabilities/<id>. You can specify a custom path using the --path flag or interactively.
+
+Examples:
+  omnidev capability new my-cap                    # Prompts for path, defaults to capabilities/my-cap
+  omnidev capability new my-cap --path ./caps/my   # Uses ./caps/my directly`
+  },
+  parameters: {
+    flags: {
+      path: {
+        kind: "parsed",
+        brief: "Output path for the capability (skips interactive prompt)",
+        parse: String,
+        optional: true
+      }
+    },
+    positional: {
+      kind: "tuple",
+      parameters: [
+        {
+          brief: "Capability ID (kebab-case)",
+          parse: String
+        }
+      ]
+    },
+    aliases: {
+      p: "path"
+    }
+  },
+  func: runCapabilityNew
+});
 var listCommand = buildCommand2({
   docs: {
     brief: "List all discovered capabilities"
@@ -674,6 +908,7 @@ var disableCommand = buildCommand2({
 });
 var capabilityRoutes = buildRouteMap2({
   routes: {
+    new: newCommand,
     list: listCommand,
     enable: enableCommand,
     disable: disableCommand
@@ -686,7 +921,7 @@ var capabilityRoutes = buildRouteMap2({
 // src/commands/doctor.ts
 import { existsSync as existsSync5 } from "node:fs";
 import { execFile } from "node:child_process";
-import { readFile as readFile4 } from "node:fs/promises";
+import { readFile as readFile3 } from "node:fs/promises";
 import { promisify } from "node:util";
 import { buildCommand as buildCommand3 } from "@stricli/core";
 var doctorCommand = buildCommand3({
@@ -826,7 +1061,7 @@ async function checkRootGitignore() {
       fix: "Run: omnidev init"
     };
   }
-  const content = await readFile4(gitignorePath, "utf-8");
+  const content = await readFile3(gitignorePath, "utf-8");
   const lines = content.split(`
 `).map((line) => line.trim());
   const hasOmniDir = lines.includes(".omni/");
@@ -868,8 +1103,8 @@ async function checkCapabilitiesDir() {
 
 // src/commands/init.ts
 import { exec } from "node:child_process";
-import { existsSync as existsSync6, mkdirSync as mkdirSync4 } from "node:fs";
-import { readFile as readFile5, writeFile as writeFile5 } from "node:fs/promises";
+import { existsSync as existsSync6, mkdirSync as mkdirSync5 } from "node:fs";
+import { readFile as readFile4, writeFile as writeFile6 } from "node:fs/promises";
 import { promisify as promisify2 } from "node:util";
 import {
   generateOmniMdTemplate,
@@ -918,9 +1153,9 @@ async function promptForGitignoreProviderFiles(selectedProviders) {
 var execAsync = promisify2(exec);
 async function runInit(_flags, providerArg) {
   console.log("Initializing OmniDev...");
-  mkdirSync4(".omni", { recursive: true });
-  mkdirSync4(".omni/capabilities", { recursive: true });
-  mkdirSync4(".omni/state", { recursive: true });
+  mkdirSync5(".omni", { recursive: true });
+  mkdirSync5(".omni/capabilities", { recursive: true });
+  mkdirSync5(".omni/state", { recursive: true });
   await updateRootGitignore();
   let providerIds;
   const isInteractive = !providerArg;
@@ -963,7 +1198,7 @@ async function runInit(_flags, providerArg) {
     await setActiveProfile("default");
   }
   if (!existsSync6("OMNI.md")) {
-    await writeFile5("OMNI.md", generateOmniMdTemplate(), "utf-8");
+    await writeFile6("OMNI.md", generateOmniMdTemplate(), "utf-8");
   }
   const config = await loadConfig();
   const ctx = {
@@ -1037,7 +1272,7 @@ async function addToGitignore(entriesToAdd, sectionHeader) {
   const gitignorePath = ".gitignore";
   let content = "";
   if (existsSync6(gitignorePath)) {
-    content = await readFile5(gitignorePath, "utf-8");
+    content = await readFile4(gitignorePath, "utf-8");
   }
   const lines = content.split(`
 `);
@@ -1052,7 +1287,7 @@ async function addToGitignore(entriesToAdd, sectionHeader) {
 ${missingEntries.join(`
 `)}
 `;
-  await writeFile5(gitignorePath, content + section, "utf-8");
+  await writeFile6(gitignorePath, content + section, "utf-8");
 }
 async function getTrackedProviderFiles(files) {
   const tracked = [];
@@ -1341,9 +1576,8 @@ async function runSync() {
     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");
+      console.log("  • Provider-specific files (instructions embedded)");
     }
   } catch (error) {
     console.error("");
@@ -1445,10 +1679,10 @@ async function loadCapabilityCommands() {
   return commands;
 }
 async function loadCapabilityExport(capability) {
-  const capabilityPath = join5(process.cwd(), capability.path);
-  const indexPath = join5(capabilityPath, "index.ts");
+  const capabilityPath = join9(process.cwd(), capability.path);
+  const indexPath = join9(capabilityPath, "index.ts");
   if (!existsSync8(indexPath)) {
-    const jsIndexPath = join5(capabilityPath, "index.js");
+    const jsIndexPath = join9(capabilityPath, "index.js");
     if (!existsSync8(jsIndexPath)) {
       return null;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omnidev-ai/cli",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -28,7 +28,7 @@
   },
   "dependencies": {
     "@inquirer/prompts": "^8.1.0",
-    "@omnidev-ai/core": "0.9.0",
+    "@omnidev-ai/core": "0.10.0",
     "@stricli/core": "^1.2.5"
   },
   "devDependencies": {