@omnidev-ai/cli 0.14.0 → 0.16.0

package/dist/index.js

@@ -1243,6 +1243,15 @@ var init_stringify = __esm(() => {
 });
 
 // ../../node_modules/.bun/smol-toml@1.6.0/node_modules/smol-toml/dist/index.js
+var exports_dist = {};
+__export(exports_dist, {
+  stringify: () => stringify,
+  parse: () => parse,
+  default: () => dist_default,
+  TomlError: () => TomlError,
+  TomlDate: () => TomlDate
+});
+var dist_default;
 var init_dist = __esm(() => {
   init_parse();
   init_stringify();
@@ -1275,6 +1284,7 @@ var init_dist = __esm(() => {
    * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    */
+  dist_default = { parse, stringify, TomlDate, TomlError };
 });
 
 // ../core/src/config/parser.ts
@@ -2791,19 +2801,56 @@ function convertCommandExports(commandExports, capabilityId) {
     return result;
   });
 }
+function mergeByName(fileBased, programmatic) {
+  const byName = new Map;
+  for (const item of fileBased) {
+    byName.set(item.name, item);
+  }
+  for (const item of programmatic) {
+    byName.set(item.name, item);
+  }
+  return Array.from(byName.values());
+}
 async function loadCapability(capabilityPath) {
   const config = await loadCapabilityConfig(capabilityPath);
   const id = config.capability.id;
   const exports = await importCapabilityExports(capabilityPath);
   const exportsAny = exports;
-  const skills = "skills" in exports && Array.isArray(exportsAny.skills) ? convertSkillExports(exportsAny.skills, id) : await loadSkills(capabilityPath, id);
-  const rules = "rules" in exports && Array.isArray(exportsAny.rules) ? convertRuleExports(exportsAny.rules, id) : await loadRules(capabilityPath, id);
-  const docs = "docs" in exports && Array.isArray(exportsAny.docs) ? convertDocExports(exportsAny.docs, id) : await loadDocs(capabilityPath, id);
-  const subagents = "subagents" in exports && Array.isArray(exportsAny.subagents) ? convertSubagentExports(exportsAny.subagents, id) : await loadSubagents(capabilityPath, id);
-  const commands = "commands" in exports && Array.isArray(exportsAny.commands) ? convertCommandExports(exportsAny.commands, id) : await loadCommands(capabilityPath, id);
-  const typeDefinitionsFromExports = "typeDefinitions" in exports && typeof exportsAny.typeDefinitions === "string" ? exportsAny.typeDefinitions : undefined;
+  const defaultExport = exportsAny.default ?? {};
+  const getExportValue = (key) => {
+    if (key in exports && exports[key] !== undefined) {
+      return exportsAny[key];
+    }
+    if (key in defaultExport && defaultExport[key] !== undefined) {
+      return defaultExport[key];
+    }
+    return;
+  };
+  const skillsExport = getExportValue("skills");
+  const programmaticSkills = Array.isArray(skillsExport) ? convertSkillExports(skillsExport, id) : [];
+  const fileSkills = await loadSkills(capabilityPath, id);
+  const skills = mergeByName(fileSkills, programmaticSkills);
+  const rulesExport = getExportValue("rules");
+  const programmaticRules = Array.isArray(rulesExport) ? convertRuleExports(rulesExport, id) : [];
+  const fileRules = await loadRules(capabilityPath, id);
+  const rules = mergeByName(fileRules, programmaticRules);
+  const docsExport = getExportValue("docs");
+  const programmaticDocs = Array.isArray(docsExport) ? convertDocExports(docsExport, id) : [];
+  const fileDocs = await loadDocs(capabilityPath, id);
+  const docs = mergeByName(fileDocs, programmaticDocs);
+  const subagentsExport = getExportValue("subagents");
+  const programmaticSubagents = Array.isArray(subagentsExport) ? convertSubagentExports(subagentsExport, id) : [];
+  const fileSubagents = await loadSubagents(capabilityPath, id);
+  const subagents = mergeByName(fileSubagents, programmaticSubagents);
+  const commandsExport = getExportValue("commands");
+  const programmaticCommands = Array.isArray(commandsExport) ? convertCommandExports(commandsExport, id) : [];
+  const fileCommands = await loadCommands(capabilityPath, id);
+  const commands = mergeByName(fileCommands, programmaticCommands);
+  const typeDefinitionsExport = getExportValue("typeDefinitions");
+  const typeDefinitionsFromExports = typeof typeDefinitionsExport === "string" ? typeDefinitionsExport : undefined;
   const typeDefinitions = typeDefinitionsFromExports !== undefined ? typeDefinitionsFromExports : await loadTypeDefinitions(capabilityPath);
-  const gitignore = "gitignore" in exports && Array.isArray(exportsAny.gitignore) ? exportsAny.gitignore : undefined;
+  const gitignoreExport = getExportValue("gitignore");
+  const gitignore = Array.isArray(gitignoreExport) ? gitignoreExport : undefined;
   const hooks = loadCapabilityHooks(id, capabilityPath, { resolveCapabilityRoot: true });
   const result = {
     id,
@@ -3528,6 +3575,9 @@ function shortCommit(commit) {
 function shortContentHash(hash) {
   return hash.substring(0, 12);
 }
+function escapeTomlString(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+}
 async function computeContentHash(dirPath, excludePatterns = CONTENT_HASH_EXCLUDES) {
   const hash = createHash("sha256");
   const files = [];
@@ -3734,27 +3784,48 @@ async function cloneRepo(gitUrl, targetPath, ref) {
   }
 }
 async function fetchRepo(repoPath, ref) {
-  const fetchResult = await spawnCapture("git", ["fetch", "--depth", "1", "origin"], {
+  const fetchArgs = ["fetch", "--depth", "1", "origin"];
+  if (ref) {
+    fetchArgs.push(ref);
+  }
+  const fetchResult = await spawnCapture("git", fetchArgs, {
     cwd: repoPath
   });
   if (fetchResult.exitCode !== 0) {
     throw new Error(`Failed to fetch in ${repoPath}: ${fetchResult.stderr.trim()}`);
   }
   const currentCommit = await getRepoCommit(repoPath);
-  const targetRef = ref || "HEAD";
-  const lsResult = await spawnCapture("git", ["ls-remote", "origin", targetRef], {
+  let resetTarget;
+  if (ref) {
+    resetTarget = "FETCH_HEAD";
+  } else {
+    const remoteShowResult = await spawnCapture("git", ["remote", "show", "origin"], {
+      cwd: repoPath
+    });
+    let defaultBranch = "main";
+    if (remoteShowResult.exitCode === 0) {
+      const match = remoteShowResult.stdout.match(/HEAD branch:\s*(\S+)/);
+      if (match?.[1]) {
+        defaultBranch = match[1];
+      }
+    }
+    resetTarget = `origin/${defaultBranch}`;
+  }
+  const revParseResult = await spawnCapture("git", ["rev-parse", resetTarget], {
     cwd: repoPath
   });
-  if (lsResult.exitCode !== 0) {
-    throw new Error(`Failed to ls-remote in ${repoPath}: ${lsResult.stderr.trim()}`);
+  if (revParseResult.exitCode !== 0) {
+    throw new Error(`Failed to resolve ${resetTarget} in ${repoPath}: ${revParseResult.stderr.trim()}`);
   }
-  const remoteCommit = lsResult.stdout.split("\t")[0];
-  if (currentCommit === remoteCommit) {
+  const targetCommit = revParseResult.stdout.trim();
+  if (currentCommit === targetCommit) {
     return false;
   }
-  const pullResult = await spawnCapture("git", ["pull", "--ff-only"], { cwd: repoPath });
-  if (pullResult.exitCode !== 0) {
-    throw new Error(`Failed to pull in ${repoPath}: ${pullResult.stderr.trim()}`);
+  const resetResult = await spawnCapture("git", ["reset", "--hard", resetTarget], {
+    cwd: repoPath
+  });
+  if (resetResult.exitCode !== 0) {
+    throw new Error(`Failed to reset in ${repoPath}: ${resetResult.stderr.trim()}`);
   }
   return true;
 }
@@ -3952,27 +4023,27 @@ async function generateCapabilityToml(id, repoPath, source, commit, content) {
 # This capability was wrapped from an external repository
 
 [capability]
-id = "${id}"
-name = "${name}"
-version = "${version}"
-description = "${description}"
+id = "${escapeTomlString(id)}"
+name = "${escapeTomlString(name)}"
+version = "${escapeTomlString(version)}"
+description = "${escapeTomlString(description)}"
 `;
   if (pluginMeta?.author?.name || pluginMeta?.author?.email) {
     tomlContent += `
 [capability.author]
 `;
     if (pluginMeta.author.name) {
-      tomlContent += `name = "${pluginMeta.author.name}"
+      tomlContent += `name = "${escapeTomlString(pluginMeta.author.name)}"
 `;
     }
     if (pluginMeta.author.email) {
-      tomlContent += `email = "${pluginMeta.author.email}"
+      tomlContent += `email = "${escapeTomlString(pluginMeta.author.email)}"
 `;
     }
   }
   tomlContent += `
 [capability.metadata]
-repository = "${repoUrl}"
+repository = "${escapeTomlString(repoUrl)}"
 wrapped = true
 commit = "${commit}"
 `;
@@ -4138,28 +4209,28 @@ async function generateFileSourceCapabilityToml(id, source, hashVersion, content
 # This capability was wrapped from a local directory
 
 [capability]
-id = "${id}"
-name = "${name}"
-version = "${version}"
-description = "${description}"
+id = "${escapeTomlString(id)}"
+name = "${escapeTomlString(name)}"
+version = "${escapeTomlString(version)}"
+description = "${escapeTomlString(description)}"
 `;
   if (pluginMeta?.author?.name || pluginMeta?.author?.email) {
     tomlContent += `
 [capability.author]
 `;
     if (pluginMeta.author.name) {
-      tomlContent += `name = "${pluginMeta.author.name}"
+      tomlContent += `name = "${escapeTomlString(pluginMeta.author.name)}"
 `;
     }
     if (pluginMeta.author.email) {
-      tomlContent += `email = "${pluginMeta.author.email}"
+      tomlContent += `email = "${escapeTomlString(pluginMeta.author.email)}"
 `;
     }
   }
   tomlContent += `
 [capability.metadata]
 wrapped = true
-source = "${source}"
+source = "${escapeTomlString(source)}"
 `;
   await writeFile3(join8(targetPath, "capability.toml"), tomlContent, "utf-8");
 }
@@ -5076,6 +5147,7 @@ import { mkdirSync as mkdirSync5 } from "node:fs";
 async function installCapabilityDependencies(silent) {
   const { existsSync: existsSync19, readdirSync: readdirSync7, readFileSync: readFileSync3 } = await import("node:fs");
   const { join: join9 } = await import("node:path");
+  const { parse: parse2 } = await Promise.resolve().then(() => (init_dist(), exports_dist));
   const capabilitiesDir = ".omni/capabilities";
   if (!existsSync19(capabilitiesDir)) {
     return;
@@ -5099,43 +5171,24 @@ async function installCapabilityDependencies(silent) {
     }
     const capabilityPath = join9(capabilitiesDir, entry.name);
     const packageJsonPath = join9(capabilityPath, "package.json");
+    const capabilityTomlPath = join9(capabilityPath, "capability.toml");
     if (!existsSync19(packageJsonPath)) {
       continue;
     }
-    await new Promise((resolve2, reject) => {
-      const useNpmCi = hasNpm && existsSync19(join9(capabilityPath, "package-lock.json"));
-      const cmd = hasBun ? "bun" : "npm";
-      const args = hasBun ? ["install"] : useNpmCi ? ["ci"] : ["install"];
-      const proc = spawn2(cmd, args, {
-        cwd: capabilityPath,
-        stdio: "pipe"
-      });
-      let stderr = "";
-      proc.stderr?.on("data", (data) => {
-        stderr += data.toString();
-      });
-      proc.on("close", (code) => {
-        if (code === 0) {
-          resolve2();
-        } else {
-          reject(new Error(`Failed to install dependencies for ${capabilityPath}:
-${stderr}`));
+    if (existsSync19(capabilityTomlPath)) {
+      try {
+        const tomlContent = readFileSync3(capabilityTomlPath, "utf-8");
+        const parsed = parse2(tomlContent);
+        if (parsed.capability?.metadata?.wrapped === true) {
+          continue;
         }
-      });
-      proc.on("error", (error) => {
-        reject(error);
-      });
-    });
-    const hasIndexTs = existsSync19(join9(capabilityPath, "index.ts"));
-    let hasBuildScript = false;
+      } catch {}
+    }
     try {
-      const pkgJson = JSON.parse(readFileSync3(packageJsonPath, "utf-8"));
-      hasBuildScript = Boolean(pkgJson.scripts?.build);
-    } catch {}
-    if (hasBuildScript) {
       await new Promise((resolve2, reject) => {
+        const useNpmCi = hasNpm && existsSync19(join9(capabilityPath, "package-lock.json"));
         const cmd = hasBun ? "bun" : "npm";
-        const args = ["run", "build"];
+        const args = hasBun ? ["install"] : useNpmCi ? ["ci"] : ["install"];
         const proc = spawn2(cmd, args, {
           cwd: capabilityPath,
           stdio: "pipe"
@@ -5148,7 +5201,7 @@ ${stderr}`));
           if (code === 0) {
             resolve2();
           } else {
-            reject(new Error(`Failed to build capability ${capabilityPath}:
+            reject(new Error(`Failed to install dependencies for ${capabilityPath}:
 ${stderr}`));
           }
         });
@@ -5156,12 +5209,46 @@ ${stderr}`));
           reject(error);
         });
       });
-    } else if (hasIndexTs && !silent) {
-      const hasBuiltIndex = existsSync19(join9(capabilityPath, "dist", "index.js"));
-      if (!hasBuiltIndex) {
-        console.warn(`Warning: Capability at ${capabilityPath} has index.ts but no build script.
+      const hasIndexTs = existsSync19(join9(capabilityPath, "index.ts"));
+      let hasBuildScript = false;
+      try {
+        const pkgJson = JSON.parse(readFileSync3(packageJsonPath, "utf-8"));
+        hasBuildScript = Boolean(pkgJson.scripts?.build);
+      } catch {}
+      if (hasBuildScript) {
+        await new Promise((resolve2, reject) => {
+          const cmd = hasBun ? "bun" : "npm";
+          const args = ["run", "build"];
+          const proc = spawn2(cmd, args, {
+            cwd: capabilityPath,
+            stdio: "pipe"
+          });
+          let stderr = "";
+          proc.stderr?.on("data", (data) => {
+            stderr += data.toString();
+          });
+          proc.on("close", (code) => {
+            if (code === 0) {
+              resolve2();
+            } else {
+              reject(new Error(`Failed to build capability ${capabilityPath}:
+${stderr}`));
+            }
+          });
+          proc.on("error", (error) => {
+            reject(error);
+          });
+        });
+      } else if (hasIndexTs && !silent) {
+        const hasBuiltIndex = existsSync19(join9(capabilityPath, "dist", "index.js"));
+        if (!hasBuiltIndex) {
+          console.warn(`Warning: Capability at ${capabilityPath} has index.ts but no build script.
   Add a "build" script to package.json (e.g., "build": "tsc") to compile TypeScript.`);
+        }
       }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.warn(`Warning: ${errorMessage}`);
     }
   }
 }
@@ -5720,13 +5807,16 @@ function generateAgentsTemplate() {
 }
 
 // ../core/src/templates/capability.ts
+function escapeTomlString2(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+}
 function generateCapabilityToml2(options) {
   const description = options.description || "TODO: Add a description for your capability";
   return `[capability]
-id = "${options.id}"
-name = "${options.name}"
+id = "${escapeTomlString2(options.id)}"
+name = "${escapeTomlString2(options.name)}"
 version = "0.1.0"
-description = "${description}"
+description = "${escapeTomlString2(description)}"
 
 # Optional author information
 # [capability.author]

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@omnidev-ai/cli",
-	"version": "0.14.0",
+	"version": "0.16.0",
 	"type": "module",
 	"license": "MIT",
 	"imports": {