oneagent 0.2.5 → 0.3.0

package/dist/index.js

@@ -609,7 +609,7 @@ var import_picocolors, import_sisteransi, at = (t) => t === 161 || t === 164 ||
 ` && (r && p && (i += st(r)), n && (i += it(n))), V += h.length, m = A, A = g.next();
   }
   return i;
-}, At, _, bt, z, rt = (t) => ("columns" in t) && typeof t.columns == "number" ? t.columns : 80, nt = (t) => ("rows" in t) && typeof t.rows == "number" ? t.rows : 20, Vt, kt, yt, Lt, Wt;
+}, At, _, bt, z, rt = (t) => ("columns" in t) && typeof t.columns == "number" ? t.columns : 80, nt = (t) => ("rows" in t) && typeof t.rows == "number" ? t.rows : 20, Vt, kt, yt, Lt, Wt, $t;
 var init_dist2 = __esm(() => {
   import_picocolors = __toESM(require_picocolors(), 1);
   import_sisteransi = __toESM(require_src(), 1);
@@ -826,6 +826,27 @@ var init_dist2 = __esm(() => {
       });
     }
   };
+  $t = class $t extends x {
+    get userInputWithCursor() {
+      if (this.state === "submit")
+        return this.userInput;
+      const e = this.userInput;
+      if (this.cursor >= e.length)
+        return `${this.userInput}█`;
+      const s = e.slice(0, this.cursor), [i, ...r] = e.slice(this.cursor);
+      return `${s}${import_picocolors.default.inverse(i)}${r.join("")}`;
+    }
+    get cursor() {
+      return this._cursor;
+    }
+    constructor(e) {
+      super({ ...e, initialUserInput: e.initialUserInput ?? e.initialValue }), this.on("userInput", (s) => {
+        this._setValue(s);
+      }), this.on("finalize", () => {
+        this.value || (this.value = e.defaultValue), this.value === undefined && (this.value = "");
+      });
+    }
+  };
 });
 
 // ../../node_modules/.bun/@clack+prompts@1.0.1/node_modules/@clack/prompts/dist/index.mjs
@@ -1067,7 +1088,7 @@ ${l}
       }
     }
   } }).prompt();
-}, We = (t = "", r) => {
+}, R2, We = (t = "", r) => {
   (r?.output ?? process.stdout).write(`${import_picocolors2.default.gray(ht2)}  ${t}
 `);
 }, Le = (t = "", r) => {
@@ -1244,7 +1265,35 @@ ${n}
       }
     }
   } }).prompt();
-}, Qt;
+}, Qt, Ze = (t) => new $t({ validate: t.validate, placeholder: t.placeholder, defaultValue: t.defaultValue, initialValue: t.initialValue, output: t.output, signal: t.signal, input: t.input, render() {
+  const r = t?.withGuide ?? _.withGuide, s = `${`${r ? `${import_picocolors2.default.gray(d)}
+` : ""}${W2(this.state)}  `}${t.message}
+`, i = t.placeholder ? import_picocolors2.default.inverse(t.placeholder[0]) + import_picocolors2.default.dim(t.placeholder.slice(1)) : import_picocolors2.default.inverse(import_picocolors2.default.hidden("_")), a = this.userInput ? this.userInputWithCursor : i, o = this.value ?? "";
+  switch (this.state) {
+    case "error": {
+      const u = this.error ? `  ${import_picocolors2.default.yellow(this.error)}` : "", l = r ? `${import_picocolors2.default.yellow(d)}  ` : "", n = r ? import_picocolors2.default.yellow(x2) : "";
+      return `${s.trim()}
+${l}${a}
+${n}${u}
+`;
+    }
+    case "submit": {
+      const u = o ? `  ${import_picocolors2.default.dim(o)}` : "", l = r ? import_picocolors2.default.gray(d) : "";
+      return `${s}${l}${u}`;
+    }
+    case "cancel": {
+      const u = o ? `  ${import_picocolors2.default.strikethrough(import_picocolors2.default.dim(o))}` : "", l = r ? import_picocolors2.default.gray(d) : "";
+      return `${s}${l}${u}${o.trim() ? `
+${l}` : ""}`;
+    }
+    default: {
+      const u = r ? `${import_picocolors2.default.cyan(d)}  ` : "", l = r ? import_picocolors2.default.cyan(x2) : "";
+      return `${s}${u}${a}
+${l}
+`;
+    }
+  }
+} }).prompt();
 var init_dist3 = __esm(() => {
   init_dist2();
   init_dist2();
@@ -1286,10 +1335,58 @@ var init_dist3 = __esm(() => {
   Ee = { limit: 1 / 0, ellipsis: "", ellipsisWidth: 0 };
   St2 = `${Ae}8;;`;
   Ht = new RegExp(`(?:\\${kt2}(?<code>\\d+)m|\\${St2}(?<uri>.*)${Ct2})`, "y");
+  R2 = { message: (t = [], { symbol: r = import_picocolors2.default.gray(d), secondarySymbol: s = import_picocolors2.default.gray(d), output: i = process.stdout, spacing: a = 1, withGuide: o } = {}) => {
+    const u = [], l = o ?? _.withGuide, n = l ? s : "", c = l ? `${r}  ` : "", g = l ? `${s}  ` : "";
+    for (let p = 0;p < a; p++)
+      u.push(n);
+    const F = Array.isArray(t) ? t : t.split(`
+`);
+    if (F.length > 0) {
+      const [p, ...E] = F;
+      p.length > 0 ? u.push(`${c}${p}`) : u.push(l ? r : "");
+      for (const $ of E)
+        $.length > 0 ? u.push(`${g}${$}`) : u.push(l ? s : "");
+    }
+    i.write(`${u.join(`
+`)}
+`);
+  }, info: (t, r) => {
+    R2.message(t, { ...r, symbol: import_picocolors2.default.blue(ft2) });
+  }, success: (t, r) => {
+    R2.message(t, { ...r, symbol: import_picocolors2.default.green(Ft2) });
+  }, step: (t, r) => {
+    R2.message(t, { ...r, symbol: import_picocolors2.default.green(V) });
+  }, warn: (t, r) => {
+    R2.message(t, { ...r, symbol: import_picocolors2.default.yellow(yt2) });
+  }, warning: (t, r) => {
+    R2.warn(t, r);
+  }, error: (t, r) => {
+    R2.message(t, { ...r, symbol: import_picocolors2.default.red(Et2) });
+  } };
   Ke = import_picocolors2.default.magenta;
   zt = { light: C("─", "-"), heavy: C("━", "="), block: C("█", "#") };
   Qt = `${import_picocolors2.default.gray(d)}  `;
 });
+
+// src/utils.ts
+function timeAgo(date) {
+  const seconds = Math.floor((Date.now() - date.getTime()) / 1000);
+  if (seconds < 60)
+    return `${seconds}s ago`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60)
+    return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24)
+    return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  if (days < 30)
+    return `${days}d ago`;
+  const months = Math.floor(days / 30);
+  if (months < 12)
+    return `${months}mo ago`;
+  return `${Math.floor(months / 12)}y ago`;
+}
 // ../core/src/agents.ts
 var AGENT_DEFINITIONS;
 var init_agents = __esm(() => {
@@ -1301,7 +1398,8 @@ var init_agents = __esm(() => {
       detectIndicators: ["CLAUDE.md", ".claude"],
       mainFile: "CLAUDE.md",
       rulesDir: ".claude/rules",
-      skillsDir: ".claude/skills"
+      skillsDir: ".claude/skills",
+      commandsDir: ".claude/commands"
     },
     {
       target: "cursor",
@@ -1311,7 +1409,8 @@ var init_agents = __esm(() => {
       mainFile: "AGENTS.md",
       rulesDir: ".cursor/rules",
       skillsDir: ".cursor/skills",
-      deprecatedFiles: [".cursorrules"]
+      deprecatedFiles: [".cursorrules"],
+      commandsDir: ".cursor/commands"
     },
     {
       target: "windsurf",
@@ -1326,9 +1425,12 @@ var init_agents = __esm(() => {
     {
       target: "opencode",
       displayName: "OpenCode",
-      hint: "AGENTS.md + opencode.json",
+      hint: "AGENTS.md + .opencode/",
       detectIndicators: ["opencode.json", ".opencode"],
-      mainFile: "AGENTS.md"
+      mainFile: "AGENTS.md",
+      rulesDir: ".opencode/rules",
+      skillsDir: ".opencode/skills",
+      commandsDir: ".opencode/commands"
     },
     {
       target: "copilot",
@@ -8364,15 +8466,6 @@ async function removeDeprecatedFiles(root) {
     } catch {}
   }
 }
-async function detectDeprecatedCommandFiles(root) {
-  const commandsDir = path2.join(root, ".claude/commands");
-  try {
-    const entries = await fs2.readdir(commandsDir, { withFileTypes: true });
-    return entries.filter((e2) => e2.isFile()).map((e2) => path2.join(".claude/commands", e2.name));
-  } catch {
-    return [];
-  }
-}
 var AGENT_FILES, DEPRECATED_FILES;
 var init_detect = __esm(() => {
   init_agents();
@@ -8389,34 +8482,20 @@ var init_detect = __esm(() => {
 // ../core/src/rules.ts
 import path3 from "path";
 import fs3 from "fs/promises";
-function parseFrontmatter(raw) {
-  const match = raw.match(/^---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)$/);
-  if (!match)
-    return { applyTo: "**", content: raw };
-  const frontmatter = match[1] ?? "";
-  const content = match[2] ?? "";
-  const applyToMatch = frontmatter.match(/applyTo:\s*["']?([^"'\n]+)["']?/);
-  const applyTo = applyToMatch?.[1]?.trim() ?? "**";
-  return { applyTo, content };
-}
-async function readRuleFile(filePath) {
-  const raw = await fs3.readFile(filePath, "utf-8");
-  const { applyTo, content } = parseFrontmatter(raw);
-  return { name: path3.basename(filePath, ".md"), path: filePath, applyTo, content };
-}
 async function readRules(root) {
   const rulesDir = path3.join(root, ".oneagent/rules");
   try {
     const files = await fs3.readdir(rulesDir);
-    const mdFiles = files.filter((f) => f.endsWith(".md"));
-    const rules = await Promise.all(mdFiles.map((f) => readRuleFile(path3.join(rulesDir, f))));
-    return rules.sort((a, b) => a.name.localeCompare(b.name));
+    return files.filter((f) => f.endsWith(".md")).map((f) => ({ name: path3.basename(f, ".md"), path: path3.join(rulesDir, f) })).sort((a, b) => a.name.localeCompare(b.name));
   } catch {
     return [];
   }
 }
 var init_rules = () => {};
 
+// ../core/src/commands.ts
+var init_commands = () => {};
+
 // ../core/src/skills.ts
 import path4 from "path";
 import fs4 from "fs/promises";
@@ -8463,7 +8542,7 @@ async function ensureDir(dirPath) {
 async function createSymlink(symlinkPath, target) {
   await ensureDir(path5.dirname(symlinkPath));
   try {
-    await fs5.unlink(symlinkPath);
+    await fs5.rm(symlinkPath, { recursive: true });
   } catch {}
   await fs5.symlink(target, symlinkPath);
 }
@@ -8500,6 +8579,13 @@ function buildSkillSymlinks(root, targets) {
     return { symlinkPath, target: relativeTarget(symlinkPath, targetAbs), label: d2.skillsDir };
   });
 }
+function buildCommandSymlinks(root, targets) {
+  const targetAbs = path5.join(root, ".oneagent/commands");
+  return AGENT_DEFINITIONS.filter((d2) => targets.includes(d2.target) && d2.commandsDir).map((d2) => {
+    const symlinkPath = path5.join(root, d2.commandsDir);
+    return { symlinkPath, target: relativeTarget(symlinkPath, targetAbs), label: d2.commandsDir };
+  });
+}
 function buildAgentsDirSymlinks(root) {
   const symlinkPath = path5.join(root, ".agents/skills");
   const targetAbs = path5.join(root, ".oneagent/skills");
@@ -8555,13 +8641,21 @@ async function migrateAndRemoveDir(src, dest, root) {
 async function migrateRuleAndSkillFiles(root) {
   const destRules = path5.join(root, ".oneagent/rules");
   const destSkills = path5.join(root, ".oneagent/skills");
-  await migrateFilesFromDir(path5.join(root, ".cursor/rules"), destRules, root);
-  await migrateFilesFromDir(path5.join(root, ".claude/rules"), destRules, root);
-  await migrateFilesFromDir(path5.join(root, ".windsurf/rules"), destRules, root);
+  const destCommands = path5.join(root, ".oneagent/commands");
+  for (const def of AGENT_DEFINITIONS) {
+    if (def.rulesDir)
+      await migrateAndRemoveDir(path5.join(root, def.rulesDir), destRules, root);
+  }
   await migrateAndRemoveDir(path5.join(root, ".agents/skills"), destSkills, root);
+  for (const def of AGENT_DEFINITIONS) {
+    if (def.commandsDir)
+      await migrateAndRemoveDir(path5.join(root, def.commandsDir), destCommands, root);
+  }
 }
 async function createAllSymlinks(entries) {
-  await Promise.all(entries.map((e2) => createSymlink(e2.symlinkPath, e2.target)));
+  for (const e2 of entries) {
+    await createSymlink(e2.symlinkPath, e2.target);
+  }
 }
 async function checkSymlink(entry) {
   try {
@@ -8582,19 +8676,13 @@ var init_symlinks = __esm(() => {
 // ../core/src/copilot.ts
 import path6 from "path";
 import fs6 from "fs/promises";
-function buildCopilotContent(rule) {
-  return `---
-applyTo: "${rule.applyTo}"
----
-${rule.content}`;
-}
 function copilotFilePath(root, ruleName) {
   return path6.join(root, ".github/instructions", `${ruleName}.instructions.md`);
 }
 async function generateCopilotRule(root, rule) {
-  const filePath = copilotFilePath(root, rule.name);
-  await fs6.mkdir(path6.dirname(filePath), { recursive: true });
-  await fs6.writeFile(filePath, buildCopilotContent(rule));
+  const destPath = copilotFilePath(root, rule.name);
+  await fs6.mkdir(path6.dirname(destPath), { recursive: true });
+  await fs6.copyFile(rule.path, destPath);
 }
 async function generateCopilotRules(root, rules) {
   await Promise.all(rules.map((rule) => generateCopilotRule(root, rule)));
@@ -8637,6 +8725,21 @@ function buildOpencodeConfig(existing) {
     instructions: ".oneagent/instructions.md"
   };
 }
+async function addOpenCodePlugin(root, id) {
+  const filePath = path7.join(root, "opencode.json");
+  let existing;
+  try {
+    existing = JSON.parse(await fs7.readFile(filePath, "utf-8"));
+  } catch {
+    return;
+  }
+  const current = Array.isArray(existing.plugin) ? existing.plugin : [];
+  if (current.includes(id))
+    return;
+  existing.plugin = [...current, id];
+  await fs7.writeFile(filePath, JSON.stringify(existing, null, 2) + `
+`);
+}
 async function writeOpencode(root, _rules) {
   const existing = await readOpencode(root);
   const config = buildOpencodeConfig(existing);
@@ -8654,7 +8757,8 @@ async function detectGenerateCollisions(root, config) {
   const mainEntries = buildMainSymlinks(root, targets);
   const ruleSkillEntries = [
     ...buildRulesSymlinks(root, targets),
-    ...buildSkillSymlinks(root, targets)
+    ...buildSkillSymlinks(root, targets),
+    ...buildCommandSymlinks(root, targets)
   ];
   const [mainCollisions, ruleSkillSymlinkCollisions] = await Promise.all([
     Promise.all(mainEntries.map((entry) => readDetectedFile(root, path8.relative(root, entry.symlinkPath)))).then((files) => files.filter((f) => f !== null)),
@@ -8666,11 +8770,14 @@ async function detectGenerateCollisions(root, config) {
       ...rules.map(async (rule) => {
         const filePath = copilotFilePath(root, rule.name);
         try {
-          const content = await fs8.readFile(filePath, "utf-8");
-          if (content === buildCopilotContent(rule))
+          const [source, dest] = await Promise.all([
+            fs8.readFile(rule.path, "utf-8"),
+            fs8.readFile(filePath, "utf-8")
+          ]);
+          if (source === dest)
             return null;
           const stat = await fs8.lstat(filePath);
-          return { relativePath: path8.relative(root, filePath), absolutePath: filePath, sizeBytes: stat.size, modifiedAt: stat.mtime, content };
+          return { relativePath: path8.relative(root, filePath), absolutePath: filePath, sizeBytes: stat.size, modifiedAt: stat.mtime, content: dest };
         } catch {
           return null;
         }
@@ -8702,7 +8809,8 @@ async function generate(root, config) {
   const mainSymlinks = buildMainSymlinks(root, targets);
   const rulesSymlinks = buildRulesSymlinks(root, targets);
   const skillSymlinks = await buildSkillSymlinks(root, targets);
-  await createAllSymlinks([...mainSymlinks, ...rulesSymlinks, ...skillSymlinks, ...buildAgentsDirSymlinks(root)]);
+  const commandSymlinks = buildCommandSymlinks(root, targets);
+  await createAllSymlinks([...mainSymlinks, ...rulesSymlinks, ...skillSymlinks, ...commandSymlinks, ...buildAgentsDirSymlinks(root)]);
   if (targets.includes("copilot")) {
     await Promise.all([generateCopilotRules(root, rules), generateCopilotSkills(root, skills)]);
   }
@@ -8724,10 +8832,12 @@ var init_generate = __esm(() => {
 import fs9 from "fs/promises";
 async function checkGeneratedFile(root, rule) {
   const filePath = copilotFilePath(root, rule.name);
-  const expected = buildCopilotContent(rule);
   try {
-    const content = await fs9.readFile(filePath, "utf-8");
-    return { path: filePath, exists: true, upToDate: content === expected };
+    const [source, dest] = await Promise.all([
+      fs9.readFile(rule.path, "utf-8"),
+      fs9.readFile(filePath, "utf-8")
+    ]);
+    return { path: filePath, exists: true, upToDate: source === dest };
   } catch {
     return { path: filePath, exists: false, upToDate: false };
   }
@@ -8755,6 +8865,7 @@ async function checkStatus(root, config) {
     ...buildMainSymlinks(root, targets),
     ...buildRulesSymlinks(root, targets),
     ...buildSkillSymlinks(root, targets),
+    ...buildCommandSymlinks(root, targets),
     ...buildAgentsDirSymlinks(root)
   ];
   const symlinks = await Promise.all(allEntries.map(checkSymlink));
@@ -8779,6 +8890,50 @@ import path9 from "path";
 import fs10 from "fs/promises";
 import { execFile } from "child_process";
 import { promisify } from "util";
+function parseTemplateYaml(yamlText, fallbackName = "custom") {
+  const nameMatch = yamlText.match(/^name:\s*(.+)$/m);
+  const name = nameMatch?.[1]?.trim() ?? fallbackName;
+  const descMatch = yamlText.match(/^description:\s*(.+)$/m);
+  const description = descMatch?.[1]?.trim() ?? "";
+  const skills = parseSkillsFromYaml(yamlText);
+  const plugins = parsePluginsFromYaml(yamlText);
+  return { name, description, skills, plugins };
+}
+function parseSkillsFromYaml(yamlText) {
+  const skills = [];
+  const section = yamlText.match(/^skills:\s*\n((?:(?:  -.+|\s{4}.+)\n?)*)/m);
+  if (!section)
+    return skills;
+  const block = section[1];
+  const entries = block.split(/\n(?=  -)/);
+  for (const entry of entries) {
+    const repoMatch = entry.match(/repo:\s*(\S+)/);
+    const skillMatch = entry.match(/skill:\s*(\S+)/);
+    if (repoMatch && skillMatch) {
+      skills.push({ repo: repoMatch[1].trim(), skill: skillMatch[1].trim() });
+    }
+  }
+  return skills;
+}
+function parsePluginsFromYaml(yamlText) {
+  const plugins = [];
+  const section = yamlText.match(/^plugins:\s*\n((?:(?:  -.+|\s{4}.+)\n?)*)/m);
+  if (!section)
+    return plugins;
+  const block = section[1];
+  const entries = block.split(/\n(?=  -)/);
+  for (const entry of entries) {
+    const targetMatch = entry.match(/target:\s*(\S+)/);
+    const idMatch = entry.match(/id:\s*(.+)/);
+    if (targetMatch && idMatch) {
+      plugins.push({
+        target: targetMatch[1].trim(),
+        id: idMatch[1].trim()
+      });
+    }
+  }
+  return plugins;
+}
 async function applyTemplateFiles(root, template) {
   const oneagentDir = path9.join(root, ".oneagent");
   await fs10.mkdir(path9.join(oneagentDir, "rules"), { recursive: true });
@@ -8788,16 +8943,54 @@ async function applyTemplateFiles(root, template) {
     await fs10.writeFile(path9.join(oneagentDir, "rules", `${rule.name}.md`), rule.content);
   }
 }
-async function installTemplateSkills(root, template, onSkillInstalled) {
-  for (const identifier of template.skills) {
+async function installTemplateSkills(root, template) {
+  const results = await Promise.all(template.skills.map(async (entry) => {
     try {
-      await execFileAsync("npx", ["skills", "add", identifier, "--agent", "universal", "--yes"], { cwd: root });
-      onSkillInstalled?.(identifier);
+      await execFileAsync("npx", ["skills", "add", entry.repo, "--skill", entry.skill, "--agent", "universal", "--yes"], { cwd: root });
+      return { entry, ok: true };
+    } catch (err) {
+      const reason = err instanceof Error ? err.message : String(err);
+      return { entry, ok: false, reason };
+    }
+  }));
+  return {
+    installed: results.filter((r) => r.ok).map((r) => r.entry),
+    failed: results.filter((r) => !r.ok).map((r) => ({ entry: r.entry, reason: r.reason }))
+  };
+}
+async function installTemplatePlugins(root, template, activeTargets2) {
+  const installed = [];
+  const manual = [];
+  const failed = [];
+  for (const plugin of template.plugins) {
+    if (!activeTargets2.includes(plugin.target))
+      continue;
+    try {
+      switch (plugin.target) {
+        case "claude":
+          await execFileAsync("claude", ["plugin", "install", plugin.id], { cwd: root });
+          installed.push(plugin);
+          break;
+        case "copilot":
+          await execFileAsync("copilot", ["plugin", "install", plugin.id], { cwd: root });
+          installed.push(plugin);
+          break;
+        case "opencode":
+          await addOpenCodePlugin(root, plugin.id);
+          installed.push(plugin);
+          break;
+        case "cursor":
+          manual.push(plugin);
+          break;
+        case "windsurf":
+          break;
+      }
     } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      throw new Error(`Failed to install skill "${identifier}": ${message}`);
+      const reason = err instanceof Error ? err.message : String(err);
+      failed.push({ plugin, reason });
     }
   }
+  return { installed, manual, failed };
 }
 async function fetchTemplateFromGitHub(url) {
   const rawBase = githubUrlToRawBase(url);
@@ -8805,23 +8998,9 @@ async function fetchTemplateFromGitHub(url) {
     fetchText(`${rawBase}/template.yml`),
     fetchText(`${rawBase}/instructions.md`)
   ]);
-  const descMatch = yamlText.match(/^description:\s*(.+)$/m);
-  const description = descMatch?.[1]?.trim() ?? "";
-  const nameMatch = yamlText.match(/^name:\s*(.+)$/m);
-  const name = nameMatch?.[1]?.trim() ?? "custom";
-  const skills = [];
-  const skillsBlockMatch = yamlText.match(/^skills:\s*\n((?:  - .+\n?)*)/m);
-  if (skillsBlockMatch) {
-    const lines = skillsBlockMatch[1].split(`
-`).filter(Boolean);
-    for (const line of lines) {
-      const skill = line.replace(/^\s*-\s*/, "").trim();
-      if (skill)
-        skills.push(skill);
-    }
-  }
+  const { name, description, skills, plugins } = parseTemplateYaml(yamlText);
   const rules = await fetchGitHubRules(url);
-  return { name, description, skills, instructions, rules };
+  return { name, description, skills, plugins, instructions, rules };
 }
 async function fetchText(url) {
   const response = await fetch(url);
@@ -8830,20 +9009,23 @@ async function fetchText(url) {
   }
   return response.text();
 }
-function githubUrlToRawBase(url) {
-  const match = url.match(/^https:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\/tree\/([^/]+))?(?:\/.*)?$/);
+function parseGitHubUrl(url) {
+  const match = url.match(/^https:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\/tree\/([^/]+?)(?:\/(.+))?)?(?:\/)?$/);
   if (!match) {
     throw new Error(`Invalid GitHub URL: "${url}". Expected format: https://github.com/owner/repo`);
   }
-  const [, owner, repo, branch = "main"] = match;
-  return `https://raw.githubusercontent.com/${owner}/${repo}/${branch}`;
+  const [, owner, repo, branch = "main", subdir = ""] = match;
+  return { owner, repo, branch, subdir };
+}
+function githubUrlToRawBase(url) {
+  const { owner, repo, branch, subdir } = parseGitHubUrl(url);
+  const base = `https://raw.githubusercontent.com/${owner}/${repo}/${branch}`;
+  return subdir ? `${base}/${subdir}` : base;
 }
 async function fetchGitHubRules(repoUrl) {
-  const match = repoUrl.match(/^https:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\/tree\/([^/]+))?(?:\/.*)?$/);
-  if (!match)
-    return [];
-  const [, owner, repo, branch = "main"] = match;
-  const apiUrl = `https://api.github.com/repos/${owner}/${repo}/contents/rules?ref=${branch}`;
+  const { owner, repo, branch, subdir } = parseGitHubUrl(repoUrl);
+  const rulesPath = subdir ? `${subdir}/rules` : "rules";
+  const apiUrl = `https://api.github.com/repos/${owner}/${repo}/contents/${rulesPath}?ref=${branch}`;
   try {
     const response = await fetch(apiUrl, {
       headers: { Accept: "application/vnd.github.v3+json" }
@@ -8863,6 +9045,7 @@ async function fetchGitHubRules(repoUrl) {
 }
 var execFileAsync;
 var init_apply_template = __esm(() => {
+  init_opencode();
   execFileAsync = promisify(execFile);
 });
 
@@ -8872,6 +9055,7 @@ var init_src = __esm(() => {
   init_config();
   init_detect();
   init_rules();
+  init_commands();
   init_skills();
   init_symlinks();
   init_copilot();
@@ -8881,39 +9065,6 @@ var init_src = __esm(() => {
   init_apply_template();
 });
 
-// src/utils.ts
-async function warnDeprecatedCommandFiles(root) {
-  const deprecated = await detectDeprecatedCommandFiles(root);
-  if (deprecated.length === 0)
-    return;
-  Ve(deprecated.map((f) => `  • ${f}`).join(`
-`) + `
-
-  Move them to .oneagent/skills/ to manage them with oneagent.`, ".claude/commands/ is deprecated — use .oneagent/skills/ instead");
-}
-function timeAgo(date) {
-  const seconds = Math.floor((Date.now() - date.getTime()) / 1000);
-  if (seconds < 60)
-    return `${seconds}s ago`;
-  const minutes = Math.floor(seconds / 60);
-  if (minutes < 60)
-    return `${minutes}m ago`;
-  const hours = Math.floor(minutes / 60);
-  if (hours < 24)
-    return `${hours}h ago`;
-  const days = Math.floor(hours / 24);
-  if (days < 30)
-    return `${days}d ago`;
-  const months = Math.floor(days / 30);
-  if (months < 12)
-    return `${months}mo ago`;
-  return `${Math.floor(months / 12)}y ago`;
-}
-var init_utils = __esm(() => {
-  init_dist3();
-  init_src();
-});
-
 // ../templates/src/index.ts
 import path10 from "path";
 import fs11 from "fs/promises";
@@ -8924,19 +9075,7 @@ async function loadTemplate(name) {
     fs11.readFile(path10.join(templateDir, "template.yml"), "utf-8"),
     fs11.readFile(path10.join(templateDir, "instructions.md"), "utf-8")
   ]);
-  const descMatch = yamlText.match(/^description:\s*(.+)$/m);
-  const description = descMatch?.[1]?.trim() ?? "";
-  const skills2 = [];
-  const skillsBlockMatch = yamlText.match(/^skills:\s*\n((?:  - .+\n?)*)/m);
-  if (skillsBlockMatch) {
-    const lines = skillsBlockMatch[1].split(`
-`).filter(Boolean);
-    for (const line of lines) {
-      const skill = line.replace(/^\s*-\s*/, "").trim();
-      if (skill)
-        skills2.push(skill);
-    }
-  }
+  const { description, skills: skills2, plugins } = parseTemplateYaml(yamlText, name);
   const rulesDir = path10.join(templateDir, "rules");
   let rules2 = [];
   try {
@@ -8946,18 +9085,24 @@ async function loadTemplate(name) {
       content: await fs11.readFile(path10.join(rulesDir, f), "utf-8")
     })));
   } catch {}
-  return { name, description, skills: skills2, instructions, rules: rules2 };
+  return { name, description, skills: skills2, plugins, instructions, rules: rules2 };
 }
 async function resolveBuiltinTemplate(name) {
   if (!TEMPLATE_NAMES.includes(name))
     return null;
   return loadTemplate(name);
 }
-var __dirname2, TEMPLATE_NAMES, BUILTIN_TEMPLATE_NAMES;
+var __dirname2, TEMPLATE_NAMES, BUILTIN_TEMPLATE_NAMES, BUILTIN_TEMPLATE_META;
 var init_src2 = __esm(() => {
+  init_src();
   __dirname2 = path10.dirname(fileURLToPath(import.meta.url));
   TEMPLATE_NAMES = ["default", "react", "react-native"];
   BUILTIN_TEMPLATE_NAMES = TEMPLATE_NAMES;
+  BUILTIN_TEMPLATE_META = [
+    { name: "default", description: "General programming starter" },
+    { name: "react", description: "React / Next.js project starter" },
+    { name: "react-native", description: "React Native / Expo project starter" }
+  ];
 });
 
 // src/commands/init.ts
@@ -9052,6 +9197,32 @@ async function backupFiles(root, files) {
     await fs12.writeFile(path11.join(backupDir, safeName), file.content);
   }
 }
+async function pickTemplateInteractively() {
+  const result = await Je({
+    message: "Which template would you like to use?",
+    options: [
+      ...BUILTIN_TEMPLATE_META.map((t) => ({
+        value: t.name,
+        label: t.name,
+        hint: t.description
+      })),
+      { value: "__github__", label: "Custom GitHub template", hint: "Enter a GitHub URL" }
+    ]
+  });
+  if (Ct(result))
+    cancelAndExit();
+  if (result === "__github__") {
+    const url = await Ze({
+      message: "GitHub URL:",
+      placeholder: "https://github.com/owner/repo",
+      validate: (v) => !v || !v.startsWith("https://github.com/") ? "Must be a GitHub URL" : undefined
+    });
+    if (Ct(url))
+      cancelAndExit();
+    return url;
+  }
+  return result;
+}
 async function resolveTemplate(templateArg) {
   if (templateArg.startsWith("https://github.com/")) {
     return fetchTemplateFromGitHub(templateArg);
@@ -9061,34 +9232,13 @@ async function resolveTemplate(templateArg) {
     return builtin;
   throw new Error(`Unknown template "${templateArg}". Use one of: ${BUILTIN_TEMPLATE_NAMES.join(", ")} — or a GitHub URL.`);
 }
-var DOTAI_META_RULE = `---
-applyTo: "**"
----
-# oneagent
-
-This project uses [oneagent](https://github.com/moskalakamil/oneagent) to manage AI agent configuration.
-
-Rules are stored in \`.oneagent/rules/\` and distributed to agents automatically via symlinks or generated files.
-
-To add a new rule, create a \`.md\` file in \`.oneagent/rules/\` with optional frontmatter:
-
-\`\`\`md
----
-applyTo: "**/*.ts"
----
-# Rule name
-
-Rule content here.
-\`\`\`
-
-Then run \`dotai generate\` to distribute the rule to all configured agents.
-`, init_default;
+var ABOUT_ONEAGENT_RULE_PATH, init_default;
 var init_init = __esm(() => {
   init_dist();
   init_dist3();
-  init_utils();
   init_src();
   init_src2();
+  ABOUT_ONEAGENT_RULE_PATH = new URL("../assets/about-oneagent.md", import.meta.url);
   init_default = defineCommand2({
     meta: {
       name: "init",
@@ -9111,11 +9261,14 @@ var init_init = __esm(() => {
       const detected = await detectExistingFiles(root);
       let template = null;
       let importedContent = "";
-      if (args.template) {
+      const templateFlagPresent = process.argv.includes("--template");
+      const templateValue = typeof args.template === "string" && args.template.length > 0 ? args.template : null;
+      const templateArg = templateValue || (templateFlagPresent ? await pickTemplateInteractively() : null);
+      if (templateArg) {
         const s3 = bt2();
-        s3.start(`Resolving template "${args.template}"...`);
+        s3.start(`Resolving template "${templateArg}"...`);
         try {
-          template = await resolveTemplate(args.template);
+          template = await resolveTemplate(templateArg);
           s3.stop(`Template "${template.name}" ready.`);
         } catch (err) {
           s3.stop("Failed.");
@@ -9132,9 +9285,9 @@ var init_init = __esm(() => {
       s.start("Setting up .oneagent/ directory...");
       await fs12.mkdir(path11.join(root, ".oneagent/rules"), { recursive: true });
       await fs12.mkdir(path11.join(root, ".oneagent/skills"), { recursive: true });
+      await fs12.mkdir(path11.join(root, ".oneagent/commands"), { recursive: true });
       await backupFiles(root, detected);
       await removeDeprecatedFiles(root);
-      await warnDeprecatedCommandFiles(root);
       await migrateRuleAndSkillFiles(root);
       const config2 = { version: 1, targets: makeTargets(...selectedTargets) };
       await writeConfig(root, config2);
@@ -9147,31 +9300,64 @@ Add your AI instructions here.
 `;
         await fs12.writeFile(path11.join(root, ".oneagent/instructions.md"), instructionsContent);
       }
-      await fs12.writeFile(path11.join(root, ".oneagent/rules/oneagent.md"), DOTAI_META_RULE);
+      await fs12.copyFile(ABOUT_ONEAGENT_RULE_PATH, path11.join(root, ".oneagent/rules/about-oneagent.md"));
       s.stop("Directory structure created.");
+      const commandFiles = await fs12.readdir(path11.join(root, ".oneagent/commands")).catch(() => []);
+      if (commandFiles.some((f) => f.endsWith(".md"))) {
+        R2.warn("Commands detected in .oneagent/commands/. Consider migrating to .oneagent/skills/ — skills are distributed to more agents and support richer features.");
+      }
+      if (commandFiles.some((f) => f.endsWith(".md"))) {
+        const commandsSupported = new Set(AGENT_DEFINITIONS.filter((d2) => d2.commandsDir).map((d2) => d2.target));
+        const unsupported = selectedTargets.filter((t) => !commandsSupported.has(t));
+        if (unsupported.length > 0) {
+          const names = unsupported.map((t) => AGENT_DEFINITIONS.find((d2) => d2.target === t).displayName).join(", ");
+          R2.warn(`Commands in .oneagent/commands/ will not be available in: ${names} — these agents do not support custom slash commands.`);
+        }
+      }
       const s2 = bt2();
       s2.start("Generating symlinks and agent files...");
       await generate(root, config2);
       s2.stop("Done.");
-      const fetchedSkills = [];
+      let skillResult = { installed: [], failed: [] };
       if (template && template.skills.length > 0) {
         const s3 = bt2();
         s3.start("Installing skills...");
-        await installTemplateSkills(root, template, (id) => fetchedSkills.push(id));
-        s3.stop(`Installed ${fetchedSkills.length} skill(s).`);
+        skillResult = await installTemplateSkills(root, template);
+        s3.stop(`Installed ${skillResult.installed.length} skill(s).`);
+        for (const f of skillResult.failed) {
+          R2.warn(`Skill "${f.entry.skill}" (${f.entry.repo}) could not be installed and was skipped.`);
+        }
+      }
+      let pluginResult = { installed: [], manual: [], failed: [] };
+      if (template && template.plugins.length > 0) {
+        const s4 = bt2();
+        s4.start("Installing plugins...");
+        pluginResult = await installTemplatePlugins(root, template, selectedTargets);
+        s4.stop(`Installed ${pluginResult.installed.length} plugin(s).`);
+        for (const f of pluginResult.failed) {
+          R2.warn(`Plugin "${f.plugin.id}" (${f.plugin.target}) could not be installed and was skipped.`);
+        }
       }
       const lines = [
         ...template ? [
           `Template: ${template.name} — ${template.description}`,
-          ...fetchedSkills.length > 0 ? [`Fetched ${fetchedSkills.length} skill(s): ${fetchedSkills.join(", ")}`] : [],
-          ...template.rules.length > 0 ? [`Added ${template.rules.length} rule(s) from template`] : []
+          ...skillResult.installed.length > 0 ? [`Installed ${skillResult.installed.length} skill(s): ${skillResult.installed.map((s3) => s3.skill).join(", ")}`] : [],
+          ...template.rules.length > 0 ? [`Added ${template.rules.length} rule(s) from template`] : [],
+          ...pluginResult.installed.length > 0 ? [`Installed ${pluginResult.installed.length} plugin(s): ${pluginResult.installed.map((p) => p.id).join(", ")}`] : []
         ] : ["Created .oneagent/instructions.md"],
-        "Created .oneagent/rules/oneagent.md",
+        "Created .oneagent/rules/about-oneagent.md",
         ...selectedTargets.map((t) => `Configured: ${t}`),
         ...detected.length > 0 ? [`Backed up ${detected.length} file(s) to .oneagent/backup/`] : []
       ];
       Ve(lines.map((l) => `  • ${l}`).join(`
 `), "Setup complete");
+      if (pluginResult.manual.length > 0) {
+        Ve(`This template includes ${pluginResult.manual.length} Cursor plugin(s).
+To install them, run each command in the Cursor chat:
+
+${pluginResult.manual.map((p) => `  /add-plugin ${p.id}`).join(`
+`)}`, "Action required: Cursor plugins");
+      }
       Le("Run `oneagent status` to verify your setup.");
     }
   });
@@ -9188,7 +9374,6 @@ var generate_default;
 var init_generate2 = __esm(() => {
   init_dist();
   init_dist3();
-  init_utils();
   init_src();
   generate_default = defineCommand2({
     meta: {
@@ -9213,7 +9398,6 @@ var init_generate2 = __esm(() => {
           await fs13.writeFile(path12.join(backupDir, safeName), file.content);
         }
       }
-      await warnDeprecatedCommandFiles(root);
       if (ruleSkillFiles.length > 0) {
         Ve(ruleSkillFiles.map((f) => `  • ${f.relativePath}`).join(`
 `), "These rule/skill files are not dotai symlinks");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oneagent",
-  "version": "0.2.5",
+  "version": "0.3.0",
   "type": "module",
   "description": "One source of truth for AI agent rules — distributed via symlinks to Claude, Cursor, Windsurf, Copilot, OpenCode",
   "license": "MIT",