oneagent 0.3.0 → 0.4.0

package/dist/index.js

@@ -1387,6 +1387,9 @@ function timeAgo(date) {
     return `${months}mo ago`;
   return `${Math.floor(months / 12)}y ago`;
 }
+
+// ../core/src/constants.ts
+var ONEAGENT_DIR = ".oneagent";
 // ../core/src/agents.ts
 var AGENT_DEFINITIONS;
 var init_agents = __esm(() => {
@@ -1436,7 +1439,7 @@ var init_agents = __esm(() => {
       target: "copilot",
       displayName: "GitHub Copilot",
       hint: ".github/instructions/*.instructions.md",
-      detectIndicators: [".github/copilot-instructions.md", ".github"],
+      detectIndicators: [".github/copilot-instructions.md", ".github/instructions"],
       mainFile: ".github/copilot-instructions.md",
       skillsDir: ".github/skills"
     }
@@ -8415,9 +8418,10 @@ async function writeConfig(root, config) {
   await fs.mkdir(path.dirname(filePath), { recursive: true });
   await fs.writeFile(filePath, $stringify(config));
 }
-var CONFIG_REL = ".oneagent/config.yml", ALL_AGENT_TARGETS;
+var CONFIG_REL, ALL_AGENT_TARGETS;
 var init_config = __esm(() => {
   init_dist4();
+  CONFIG_REL = `${ONEAGENT_DIR}/config.yml`;
   ALL_AGENT_TARGETS = ["claude", "cursor", "windsurf", "opencode", "copilot"];
 });
 
@@ -8431,7 +8435,7 @@ async function readDetectedFile(root, rel) {
     if (stat.isSymbolicLink()) {
       const linkTarget = await fs2.readlink(absolutePath);
       const resolved = path2.resolve(path2.dirname(absolutePath), linkTarget);
-      if (resolved.startsWith(path2.join(root, ".one")))
+      if (resolved.startsWith(path2.join(root, ONEAGENT_DIR)))
         return null;
     }
     const content = await fs2.readFile(absolutePath, "utf-8");
@@ -8483,7 +8487,7 @@ var init_detect = __esm(() => {
 import path3 from "path";
 import fs3 from "fs/promises";
 async function readRules(root) {
-  const rulesDir = path3.join(root, ".oneagent/rules");
+  const rulesDir = path3.join(root, ONEAGENT_DIR, "rules");
   try {
     const files = await fs3.readdir(rulesDir);
     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));
@@ -8518,7 +8522,7 @@ async function readSkillFile(filePath) {
   return { name: path4.basename(filePath, ".md"), path: filePath, description, mode, content };
 }
 async function readSkills(root) {
-  const skillsDir = path4.join(root, ".oneagent/skills");
+  const skillsDir = path4.join(root, ONEAGENT_DIR, "skills");
   try {
     const files = await fs4.readdir(skillsDir);
     const mdFiles = files.filter((f) => f.endsWith(".md"));
@@ -8542,15 +8546,26 @@ async function ensureDir(dirPath) {
 async function createSymlink(symlinkPath, target) {
   await ensureDir(path5.dirname(symlinkPath));
   try {
-    await fs5.rm(symlinkPath, { recursive: true });
+    const stat = await fs5.lstat(symlinkPath);
+    if (stat.isSymbolicLink() && await fs5.readlink(symlinkPath) === target)
+      return;
   } catch {}
-  await fs5.symlink(target, symlinkPath);
+  for (let attempt = 0;attempt < 3; attempt++) {
+    await fs5.rm(symlinkPath, { recursive: true, force: true });
+    try {
+      await fs5.symlink(target, symlinkPath);
+      return;
+    } catch (err) {
+      if (err.code !== "EEXIST" || attempt === 2)
+        throw err;
+    }
+  }
 }
 function relativeTarget(symlinkPath, targetAbsPath) {
   return path5.relative(path5.dirname(symlinkPath), targetAbsPath);
 }
 function buildMainSymlinks(root, targets) {
-  const instructionsAbs = path5.join(root, ".oneagent/instructions.md");
+  const instructionsAbs = path5.join(root, ONEAGENT_DIR, "instructions.md");
   const seen = new Map;
   for (const target of targets) {
     const def = AGENT_DEFINITIONS.find((d2) => d2.target === target);
@@ -8566,21 +8581,21 @@ function buildMainSymlinks(root, targets) {
   return Array.from(seen.values());
 }
 function buildRulesSymlinks(root, targets) {
-  const targetAbs = path5.join(root, ".oneagent/rules");
+  const targetAbs = path5.join(root, ONEAGENT_DIR, "rules");
   return AGENT_DEFINITIONS.filter((d2) => targets.includes(d2.target) && d2.rulesDir).map((d2) => {
     const symlinkPath = path5.join(root, d2.rulesDir);
     return { symlinkPath, target: relativeTarget(symlinkPath, targetAbs), label: d2.rulesDir };
   });
 }
 function buildSkillSymlinks(root, targets) {
-  const targetAbs = path5.join(root, ".oneagent/skills");
+  const targetAbs = path5.join(root, ONEAGENT_DIR, "skills");
   return AGENT_DEFINITIONS.filter((d2) => targets.includes(d2.target) && d2.skillsDir).map((d2) => {
     const symlinkPath = path5.join(root, d2.skillsDir);
     return { symlinkPath, target: relativeTarget(symlinkPath, targetAbs), label: d2.skillsDir };
   });
 }
 function buildCommandSymlinks(root, targets) {
-  const targetAbs = path5.join(root, ".oneagent/commands");
+  const targetAbs = path5.join(root, ONEAGENT_DIR, "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 };
@@ -8588,7 +8603,7 @@ function buildCommandSymlinks(root, targets) {
 }
 function buildAgentsDirSymlinks(root) {
   const symlinkPath = path5.join(root, ".agents/skills");
-  const targetAbs = path5.join(root, ".oneagent/skills");
+  const targetAbs = path5.join(root, ONEAGENT_DIR, "skills");
   return [{ symlinkPath, target: relativeTarget(symlinkPath, targetAbs), label: ".agents/skills" }];
 }
 async function migrateFilesFromDir(srcDir, destDir, root) {
@@ -8600,9 +8615,22 @@ async function migrateFilesFromDir(srcDir, destDir, root) {
     return;
   }
   for (const entry of entries) {
-    if (!entry.isFile())
-      continue;
     const srcFile = path5.join(srcDir, entry.name);
+    const fileStat = await fs5.lstat(srcFile);
+    if (fileStat.isSymbolicLink())
+      continue;
+    if (fileStat.isDirectory()) {
+      const destSub = path5.join(destDir, entry.name);
+      try {
+        await fs5.access(destSub);
+      } catch {
+        await fs5.mkdir(destDir, { recursive: true });
+        await fs5.rename(srcFile, destSub);
+      }
+      continue;
+    }
+    if (!fileStat.isFile())
+      continue;
     const destFile = path5.join(destDir, entry.name);
     let destExists = false;
     try {
@@ -8615,7 +8643,7 @@ async function migrateFilesFromDir(srcDir, destDir, root) {
         fs5.readFile(destFile, "utf-8")
       ]);
       if (srcContent !== destContent) {
-        const backupDir = path5.join(root, ".oneagent/backup");
+        const backupDir = path5.join(root, ONEAGENT_DIR, "backup");
         await fs5.mkdir(backupDir, { recursive: true });
         const safeName = path5.relative(root, srcFile).replace(/\//g, "_");
         await fs5.writeFile(path5.join(backupDir, safeName), srcContent);
@@ -8639,21 +8667,75 @@ async function migrateAndRemoveDir(src, dest, root) {
   await fs5.rm(src, { recursive: true, force: true });
 }
 async function migrateRuleAndSkillFiles(root) {
-  const destRules = path5.join(root, ".oneagent/rules");
-  const destSkills = path5.join(root, ".oneagent/skills");
-  const destCommands = path5.join(root, ".oneagent/commands");
+  const destRules = path5.join(root, ONEAGENT_DIR, "rules");
+  const destSkills = path5.join(root, ONEAGENT_DIR, "skills");
+  const destCommands = path5.join(root, ONEAGENT_DIR, "commands");
   for (const def of AGENT_DEFINITIONS) {
     if (def.rulesDir)
       await migrateAndRemoveDir(path5.join(root, def.rulesDir), destRules, root);
   }
+  for (const def of AGENT_DEFINITIONS) {
+    if (def.skillsDir)
+      await migrateAndRemoveDir(path5.join(root, def.skillsDir), destSkills, 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 backupDirRecursive(srcDir, backupDir, prefix) {
+  let entries;
+  try {
+    entries = await fs5.readdir(srcDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const srcPath = path5.join(srcDir, entry.name);
+    const lstat = await fs5.lstat(srcPath);
+    if (lstat.isSymbolicLink())
+      continue;
+    if (lstat.isDirectory()) {
+      await backupDirRecursive(srcPath, backupDir, `${prefix}_${entry.name}`);
+    } else if (lstat.isFile()) {
+      await fs5.mkdir(backupDir, { recursive: true });
+      await fs5.copyFile(srcPath, path5.join(backupDir, `${prefix}_${entry.name}`));
+    }
+  }
+}
+async function cleanupAgentDir(root, target) {
+  const def = AGENT_DEFINITIONS.find((d2) => d2.target === target);
+  const backupDir = path5.join(root, ONEAGENT_DIR, "backup");
+  const agentDir = [def.rulesDir, def.skillsDir, def.commandsDir].filter(Boolean).map((d2) => d2.split("/")[0]).find((d2) => d2 !== ".github");
+  if (agentDir) {
+    const agentDirAbs = path5.join(root, agentDir);
+    let stat;
+    try {
+      stat = await fs5.lstat(agentDirAbs);
+    } catch {}
+    if (stat && stat.isDirectory() && !stat.isSymbolicLink()) {
+      await backupDirRecursive(agentDirAbs, backupDir, agentDir);
+      await fs5.rm(agentDirAbs, { recursive: true, force: true });
+    }
+  }
+  if (target === "opencode") {
+    const opPath = path5.join(root, "opencode.json");
+    try {
+      const content = await fs5.readFile(opPath, "utf-8");
+      await fs5.mkdir(backupDir, { recursive: true });
+      await fs5.writeFile(path5.join(backupDir, "opencode.json"), content);
+    } catch {}
+    try {
+      await fs5.unlink(opPath);
+    } catch {}
+  }
+}
 async function createAllSymlinks(entries) {
-  for (const e2 of entries) {
+  const deduped = new Map;
+  for (const e2 of entries)
+    deduped.set(e2.symlinkPath, e2);
+  for (const e2 of deduped.values()) {
     await createSymlink(e2.symlinkPath, e2.target);
   }
 }
@@ -8722,7 +8804,7 @@ async function readOpencode(root) {
 function buildOpencodeConfig(existing) {
   return {
     ...existing,
-    instructions: ".oneagent/instructions.md"
+    instructions: `${ONEAGENT_DIR}/instructions.md`
   };
 }
 async function addOpenCodePlugin(root, id) {
@@ -8846,7 +8928,7 @@ async function checkOpencodeStatus(root, _rules) {
   const existing = await readOpencode(root);
   if (!existing)
     return { exists: false, valid: false };
-  return { exists: true, valid: existing["instructions"] === ".oneagent/instructions.md" };
+  return { exists: true, valid: existing["instructions"] === `${ONEAGENT_DIR}/instructions.md` };
 }
 async function checkCopilotPrompt(root, skill) {
   const filePath = copilotPromptFilePath(root, skill.name);
@@ -8895,9 +8977,11 @@ function parseTemplateYaml(yamlText, fallbackName = "custom") {
   const name = nameMatch?.[1]?.trim() ?? fallbackName;
   const descMatch = yamlText.match(/^description:\s*(.+)$/m);
   const description = descMatch?.[1]?.trim() ?? "";
+  const extendsMatch = yamlText.match(/^extends:\s*(.+)$/m);
+  const extendsValue = extendsMatch?.[1]?.trim();
   const skills = parseSkillsFromYaml(yamlText);
   const plugins = parsePluginsFromYaml(yamlText);
-  return { name, description, skills, plugins };
+  return { name, description, skills, plugins, ...extendsValue ? { extends: extendsValue } : {} };
 }
 function parseSkillsFromYaml(yamlText) {
   const skills = [];
@@ -8934,8 +9018,31 @@ function parsePluginsFromYaml(yamlText) {
   }
   return plugins;
 }
+async function resolveExtends(child, resolveBuiltin) {
+  if (!child.extends)
+    return child;
+  let parent;
+  if (child.extends.startsWith("https://")) {
+    parent = await fetchTemplateFromGitHub(child.extends);
+  } else if (resolveBuiltin) {
+    const resolved = await resolveBuiltin(child.extends);
+    if (!resolved)
+      throw new Error(`Unknown builtin template: "${child.extends}"`);
+    parent = resolved;
+  } else {
+    throw new Error(`Cannot resolve extends: "${child.extends}"`);
+  }
+  return {
+    name: child.name,
+    description: child.description,
+    instructions: child.instructions,
+    skills: [...parent.skills, ...child.skills],
+    plugins: [...parent.plugins, ...child.plugins],
+    rules: [...parent.rules, ...child.rules]
+  };
+}
 async function applyTemplateFiles(root, template) {
-  const oneagentDir = path9.join(root, ".oneagent");
+  const oneagentDir = path9.join(root, ONEAGENT_DIR);
   await fs10.mkdir(path9.join(oneagentDir, "rules"), { recursive: true });
   await fs10.mkdir(path9.join(oneagentDir, "skills"), { recursive: true });
   await fs10.writeFile(path9.join(oneagentDir, "instructions.md"), template.instructions);
@@ -8944,19 +9051,26 @@ async function applyTemplateFiles(root, template) {
   }
 }
 async function installTemplateSkills(root, template) {
-  const results = await Promise.all(template.skills.map(async (entry) => {
+  const installed = [];
+  const failed = [];
+  for (const entry of template.skills) {
     try {
       await execFileAsync("npx", ["skills", "add", entry.repo, "--skill", entry.skill, "--agent", "universal", "--yes"], { cwd: root });
-      return { entry, ok: true };
+      installed.push(entry);
     } catch (err) {
       const reason = err instanceof Error ? err.message : String(err);
-      return { entry, ok: false, reason };
+      failed.push({ entry, 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 }))
-  };
+  }
+  return { installed, failed };
+}
+async function installBuiltinSkill(root) {
+  try {
+    await execFileAsync("npx", ["skills", "add", BUILTIN_SKILL_REPO, "--skill", BUILTIN_SKILL_NAME, "--agent", "universal", "--yes"], { cwd: root });
+    return true;
+  } catch {
+    return false;
+  }
 }
 async function installTemplatePlugins(root, template, activeTargets2) {
   const installed = [];
@@ -8993,14 +9107,31 @@ async function installTemplatePlugins(root, template, activeTargets2) {
   return { installed, manual, failed };
 }
 async function fetchTemplateFromGitHub(url) {
-  const rawBase = githubUrlToRawBase(url);
+  const { owner, repo, branch, subdir } = parseGitHubUrl(url);
+  const branchExplicit = url.includes("/tree/");
+  const resolvedBranch = branchExplicit ? branch : await fetchDefaultBranch(owner, repo);
+  const rawBase = `https://raw.githubusercontent.com/${owner}/${repo}/${resolvedBranch}${subdir ? `/${subdir}` : ""}`;
   const [yamlText, instructions] = await Promise.all([
     fetchText(`${rawBase}/template.yml`),
     fetchText(`${rawBase}/instructions.md`)
   ]);
-  const { name, description, skills, plugins } = parseTemplateYaml(yamlText);
+  const parsed = parseTemplateYaml(yamlText);
   const rules = await fetchGitHubRules(url);
-  return { name, description, skills, plugins, instructions, rules };
+  const base = { ...parsed, instructions, rules };
+  return resolveExtends(base);
+}
+async function fetchDefaultBranch(owner, repo) {
+  try {
+    const response = await fetch(`https://api.github.com/repos/${owner}/${repo}`, {
+      headers: { Accept: "application/vnd.github.v3+json" }
+    });
+    if (!response.ok)
+      return "main";
+    const data = await response.json();
+    return data.default_branch ?? "main";
+  } catch {
+    return "main";
+  }
 }
 async function fetchText(url) {
   const response = await fetch(url);
@@ -9017,11 +9148,6 @@ function parseGitHubUrl(url) {
   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 { owner, repo, branch, subdir } = parseGitHubUrl(repoUrl);
   const rulesPath = subdir ? `${subdir}/rules` : "rules";
@@ -9043,7 +9169,7 @@ async function fetchGitHubRules(repoUrl) {
     return [];
   }
 }
-var execFileAsync;
+var execFileAsync, BUILTIN_SKILL_REPO = "https://github.com/moskalakamil/oneagent", BUILTIN_SKILL_NAME = "oneagent";
 var init_apply_template = __esm(() => {
   init_opencode();
   execFileAsync = promisify(execFile);
@@ -9075,7 +9201,7 @@ async function loadTemplate(name) {
     fs11.readFile(path10.join(templateDir, "template.yml"), "utf-8"),
     fs11.readFile(path10.join(templateDir, "instructions.md"), "utf-8")
   ]);
-  const { description, skills: skills2, plugins } = parseTemplateYaml(yamlText, name);
+  const parsed = parseTemplateYaml(yamlText, name);
   const rulesDir = path10.join(templateDir, "rules");
   let rules2 = [];
   try {
@@ -9085,7 +9211,8 @@ async function loadTemplate(name) {
       content: await fs11.readFile(path10.join(rulesDir, f), "utf-8")
     })));
   } catch {}
-  return { name, description, skills: skills2, plugins, instructions, rules: rules2 };
+  const base = { ...parsed, instructions, rules: rules2 };
+  return resolveExtends(base, (n) => resolveBuiltinTemplate(n));
 }
 async function resolveBuiltinTemplate(name) {
   if (!TEMPLATE_NAMES.includes(name))
@@ -9121,20 +9248,12 @@ async function chooseContent(detected) {
     return "";
   if (detected.length === 1) {
     const file = detected[0];
-    const result2 = await Re({
-      message: `Found ${file.relativePath} (${timeAgo(file.modifiedAt)}). Import its content into .oneagent/instructions.md?`
-    });
-    if (Ct(result2))
-      cancelAndExit();
-    return result2 ? file.content : "";
+    R2.info(`Found ${file.relativePath} (${timeAgo(file.modifiedAt)}) — importing into ${ONEAGENT_DIR}/instructions.md`);
+    return file.content;
   }
   if (filesHaveSameContent(detected)) {
-    const result2 = await Re({
-      message: `Found ${detected.length} files with identical content. Import?`
-    });
-    if (Ct(result2))
-      cancelAndExit();
-    return result2 ? detected[0].content : "";
+    R2.info(`Found ${detected.length} files with identical content — importing into ${ONEAGENT_DIR}/instructions.md`);
+    return detected[0].content;
   }
   Ve(detected.map((f) => `  • ${f.relativePath}  ${timeAgo(f.modifiedAt)}`).join(`
 `), "Multiple files with different content found");
@@ -9190,13 +9309,19 @@ async function pickTargets(initialValues) {
 async function backupFiles(root, files) {
   if (files.length === 0)
     return;
-  const backupDir = path11.join(root, ".oneagent/backup");
+  const backupDir = path11.join(root, ONEAGENT_DIR, "backup");
   await fs12.mkdir(backupDir, { recursive: true });
   for (const file of files) {
     const safeName = file.relativePath.replace(/\//g, "_");
     await fs12.writeFile(path11.join(backupDir, safeName), file.content);
   }
 }
+async function cleanupUnselectedAgentDirs(root, presentTargets, selectedTargets) {
+  const unselected = presentTargets.filter((t) => !selectedTargets.includes(t));
+  for (const target of unselected) {
+    await cleanupAgentDir(root, target);
+  }
+}
 async function pickTemplateInteractively() {
   const result = await Je({
     message: "Which template would you like to use?",
@@ -9232,13 +9357,12 @@ async function resolveTemplate(templateArg) {
     return builtin;
   throw new Error(`Unknown template "${templateArg}". Use one of: ${BUILTIN_TEMPLATE_NAMES.join(", ")} — or a GitHub URL.`);
 }
-var ABOUT_ONEAGENT_RULE_PATH, init_default;
+var init_default;
 var init_init = __esm(() => {
   init_dist();
   init_dist3();
   init_src();
   init_src2();
-  ABOUT_ONEAGENT_RULE_PATH = new URL("../assets/about-oneagent.md", import.meta.url);
   init_default = defineCommand2({
     meta: {
       name: "init",
@@ -9248,6 +9372,12 @@ var init_init = __esm(() => {
       template: {
         type: "string",
         description: `Template to use: builtin name (${BUILTIN_TEMPLATE_NAMES.join("/")}) or GitHub URL`
+      },
+      yes: {
+        type: "boolean",
+        alias: "y",
+        description: "Skip prompts: auto-import detected files and select detected agents",
+        default: false
       }
     },
     async run({ args }) {
@@ -9276,19 +9406,26 @@ var init_init = __esm(() => {
           Ve(message, "Error");
           process.exit(1);
         }
+      } else if (args.yes) {
+        if (detected.length > 0) {
+          const newest = detected.toSorted((a, b) => b.modifiedAt.getTime() - a.modifiedAt.getTime())[0];
+          importedContent = newest.content;
+          R2.info(`Auto-importing content from ${newest.relativePath}`);
+        }
       } else {
         importedContent = await chooseContent(detected);
       }
       const presentTargets = await detectPresentTargets(root);
-      const selectedTargets = await pickTargets(presentTargets);
+      const selectedTargets = args.yes ? presentTargets.length > 0 ? presentTargets : ALL_AGENT_TARGETS.slice(0, 1) : await pickTargets(presentTargets);
       const s = bt2();
-      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 });
+      s.start(`Setting up ${ONEAGENT_DIR}/ directory...`);
+      await fs12.mkdir(path11.join(root, ONEAGENT_DIR, "rules"), { recursive: true });
+      await fs12.mkdir(path11.join(root, ONEAGENT_DIR, "skills"), { recursive: true });
+      await fs12.mkdir(path11.join(root, ONEAGENT_DIR, "commands"), { recursive: true });
       await backupFiles(root, detected);
       await removeDeprecatedFiles(root);
       await migrateRuleAndSkillFiles(root);
+      await cleanupUnselectedAgentDirs(root, presentTargets, selectedTargets);
       const config2 = { version: 1, targets: makeTargets(...selectedTargets) };
       await writeConfig(root, config2);
       if (template) {
@@ -9298,30 +9435,37 @@ var init_init = __esm(() => {
 
 Add your AI instructions here.
 `;
-        await fs12.writeFile(path11.join(root, ".oneagent/instructions.md"), instructionsContent);
+        await fs12.writeFile(path11.join(root, ONEAGENT_DIR, "instructions.md"), instructionsContent);
       }
-      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(() => []);
+      const commandFiles = await fs12.readdir(path11.join(root, ONEAGENT_DIR, "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.");
+        R2.warn(`Commands detected in ${ONEAGENT_DIR}/commands/. Consider migrating to ${ONEAGENT_DIR}/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.`);
+          R2.warn(`Commands in ${ONEAGENT_DIR}/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 sSkill = bt2();
+      sSkill.start("Installing oneagent skill...");
+      const builtinInstalled = await installBuiltinSkill(root);
+      if (builtinInstalled) {
+        sSkill.stop("Installed oneagent skill.");
+      } else {
+        sSkill.stop("Could not install oneagent skill (skipped).");
+      }
       let skillResult = { installed: [], failed: [] };
       if (template && template.skills.length > 0) {
         const s3 = bt2();
-        s3.start("Installing skills...");
+        s3.start("Installing template skills...");
         skillResult = await installTemplateSkills(root, template);
         s3.stop(`Installed ${skillResult.installed.length} skill(s).`);
         for (const f of skillResult.failed) {
@@ -9344,10 +9488,10 @@ Add your AI instructions here.
           ...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/about-oneagent.md",
+        ] : [`Created ${ONEAGENT_DIR}/instructions.md`],
+        ...builtinInstalled ? [`Installed oneagent skill`] : [],
         ...selectedTargets.map((t) => `Configured: ${t}`),
-        ...detected.length > 0 ? [`Backed up ${detected.length} file(s) to .oneagent/backup/`] : []
+        ...detected.length > 0 ? [`Backed up ${detected.length} file(s) to ${ONEAGENT_DIR}/backup/`] : []
       ];
       Ve(lines.map((l) => `  • ${l}`).join(`
 `), "Setup complete");
@@ -9380,18 +9524,25 @@ var init_generate2 = __esm(() => {
       name: "generate",
       description: "Generate symlinks and agent-specific files"
     },
-    async run() {
+    args: {
+      yes: {
+        type: "boolean",
+        alias: "y",
+        description: "Skip confirmation prompts and auto-migrate colliding files"
+      }
+    },
+    async run({ args }) {
       const root = process.cwd();
       let config2;
       try {
         config2 = await readConfig(root);
       } catch {
-        console.error("Error: No .oneagent/config.yml found. Run `oneagent init` first.");
+        console.error(`Error: No ${ONEAGENT_DIR}/config.yml found. Run \`oneagent init\` first.`);
         process.exit(1);
       }
       const { mainFiles, ruleSkillFiles } = await detectGenerateCollisions(root, config2);
       if (mainFiles.length > 0) {
-        const backupDir = path12.join(root, ".oneagent/backup");
+        const backupDir = path12.join(root, ONEAGENT_DIR, "backup");
         await fs13.mkdir(backupDir, { recursive: true });
         for (const file of mainFiles) {
           const safeName = file.relativePath.replace(/\//g, "_");
@@ -9399,16 +9550,20 @@ var init_generate2 = __esm(() => {
         }
       }
       if (ruleSkillFiles.length > 0) {
-        Ve(ruleSkillFiles.map((f) => `  • ${f.relativePath}`).join(`
-`), "These rule/skill files are not dotai symlinks");
-        const proceed = await Re({
-          message: "Move them to .oneagent/ and replace with symlinks?"
-        });
-        if (Ct(proceed) || !proceed) {
-          Le("Aborted.");
-          process.exit(0);
+        if (args.yes) {
+          await migrateRuleAndSkillFiles(root);
+        } else {
+          Ve(ruleSkillFiles.map((f) => `  • ${f.relativePath}`).join(`
+`), "These rule/skill files are not oneagent symlinks");
+          const proceed = await Re({
+            message: `Move them to ${ONEAGENT_DIR}/ and replace with symlinks?`
+          });
+          if (Ct(proceed) || !proceed) {
+            Le("Aborted.");
+            process.exit(0);
+          }
+          await migrateRuleAndSkillFiles(root);
         }
-        await migrateRuleAndSkillFiles(root);
       }
       const s = bt2();
       s.start("Generating...");
@@ -9444,7 +9599,7 @@ var init_status2 = __esm(() => {
       try {
         config2 = await readConfig(root);
       } catch {
-        console.error("Error: No .oneagent/config.yml found. Run `oneagent init` first.");
+        console.error(`Error: No ${ONEAGENT_DIR}/config.yml found. Run \`oneagent init\` first.`);
         process.exit(1);
       }
       const status2 = await checkStatus(root, config2);
@@ -9477,6 +9632,233 @@ OpenCode:
   });
 });
 
+// src/commands/targets.ts
+var exports_targets = {};
+__export(exports_targets, {
+  default: () => targets_default
+});
+import path13 from "path";
+import fs14 from "fs/promises";
+function cancelAndExit2() {
+  Le("Cancelled.");
+  process.exit(0);
+}
+async function detectPresentTargets2(root) {
+  const results = await Promise.all(AGENT_DEFINITIONS.map(async (def) => {
+    for (const indicator of def.detectIndicators) {
+      try {
+        await fs14.access(path13.join(root, indicator));
+        return def.target;
+      } catch {}
+    }
+    return null;
+  }));
+  return results.filter((t) => t !== null);
+}
+var targets_default;
+var init_targets = __esm(() => {
+  init_dist();
+  init_dist3();
+  init_src();
+  targets_default = defineCommand2({
+    meta: {
+      name: "targets",
+      description: "Add or remove AI agent targets"
+    },
+    async run() {
+      const root = process.cwd();
+      let config2;
+      try {
+        config2 = await readConfig(root);
+      } catch {
+        console.error(`Error: No ${ONEAGENT_DIR}/config.yml found. Run \`oneagent init\` first.`);
+        process.exit(1);
+      }
+      const current = activeTargets(config2);
+      const presentTargets = await detectPresentTargets2(root);
+      const initialValues = [...new Set([...current, ...presentTargets])];
+      Ve(current.map((t) => `  • ${AGENT_DEFINITIONS.find((d2) => d2.target === t).displayName}`).join(`
+`), "Currently configured targets");
+      const result = await je({
+        message: `Which AI agents do you want to support?
+\x1B[90m · Space to toggle · Enter to confirm\x1B[39m`,
+        options: AGENT_DEFINITIONS.map((d2) => ({ value: d2.target, label: d2.displayName, hint: d2.hint })),
+        initialValues,
+        required: true
+      });
+      if (Ct(result))
+        cancelAndExit2();
+      const selected = result;
+      const removed = current.filter((t) => !selected.includes(t));
+      const added = selected.filter((t) => !current.includes(t));
+      if (removed.length === 0 && added.length === 0) {
+        Le("No changes.");
+        return;
+      }
+      const s = bt2();
+      s.start("Updating targets...");
+      for (const target of removed) {
+        await cleanupAgentDir(root, target);
+      }
+      config2.targets = makeTargets(...selected);
+      await writeConfig(root, config2);
+      await generate(root, config2);
+      s.stop("Done.");
+      const lines = [
+        ...added.length > 0 ? [`Added: ${added.map((t) => AGENT_DEFINITIONS.find((d2) => d2.target === t).displayName).join(", ")}`] : [],
+        ...removed.length > 0 ? [`Removed: ${removed.map((t) => AGENT_DEFINITIONS.find((d2) => d2.target === t).displayName).join(", ")}`] : []
+      ];
+      Ve(lines.map((l) => `  • ${l}`).join(`
+`), "Targets updated");
+      if (removed.length > 0) {
+        R2.info(`Removed agent files backed up to ${ONEAGENT_DIR}/backup/`);
+      }
+      Le("Run `oneagent status` to verify your setup.");
+    }
+  });
+});
+
+// src/commands/add.ts
+var exports_add = {};
+__export(exports_add, {
+  default: () => add_default
+});
+var add_default;
+var init_add = __esm(() => {
+  init_dist();
+  init_dist3();
+  init_src();
+  add_default = defineCommand2({
+    meta: {
+      name: "add",
+      description: "Add an AI agent target"
+    },
+    args: {
+      target: {
+        type: "positional",
+        description: "Agent to add (claude, cursor, windsurf, opencode, copilot)",
+        required: false
+      }
+    },
+    async run({ args }) {
+      const root = process.cwd();
+      let config2;
+      try {
+        config2 = await readConfig(root);
+      } catch {
+        console.error(`Error: No ${ONEAGENT_DIR}/config.yml found. Run \`oneagent init\` first.`);
+        process.exit(1);
+      }
+      const current = activeTargets(config2);
+      const available = ALL_AGENT_TARGETS.filter((t) => !current.includes(t));
+      if (available.length === 0) {
+        R2.info("All agents are already configured.");
+        return;
+      }
+      let target;
+      if (args.target) {
+        if (!ALL_AGENT_TARGETS.includes(args.target)) {
+          console.error(`Unknown target "${args.target}". Available: ${ALL_AGENT_TARGETS.join(", ")}`);
+          process.exit(1);
+        }
+        target = args.target;
+        if (current.includes(target)) {
+          R2.info(`${AGENT_DEFINITIONS.find((d2) => d2.target === target).displayName} is already configured.`);
+          return;
+        }
+      } else {
+        const result = await Je({
+          message: "Which agent do you want to add?",
+          options: available.map((t) => {
+            const def = AGENT_DEFINITIONS.find((d2) => d2.target === t);
+            return { value: t, label: def.displayName, hint: def.hint };
+          })
+        });
+        if (Ct(result)) {
+          Le("Cancelled.");
+          process.exit(0);
+        }
+        target = result;
+      }
+      config2.targets[target] = true;
+      await writeConfig(root, config2);
+      await generate(root, config2);
+      R2.success(`Added ${AGENT_DEFINITIONS.find((d2) => d2.target === target).displayName}`);
+    }
+  });
+});
+
+// src/commands/remove.ts
+var exports_remove = {};
+__export(exports_remove, {
+  default: () => remove_default
+});
+var remove_default;
+var init_remove = __esm(() => {
+  init_dist();
+  init_dist3();
+  init_src();
+  remove_default = defineCommand2({
+    meta: {
+      name: "remove",
+      description: "Remove an AI agent target"
+    },
+    args: {
+      target: {
+        type: "positional",
+        description: "Agent to remove (claude, cursor, windsurf, opencode, copilot)",
+        required: false
+      }
+    },
+    async run({ args }) {
+      const root = process.cwd();
+      let config2;
+      try {
+        config2 = await readConfig(root);
+      } catch {
+        console.error(`Error: No ${ONEAGENT_DIR}/config.yml found. Run \`oneagent init\` first.`);
+        process.exit(1);
+      }
+      const current = activeTargets(config2);
+      if (current.length === 1) {
+        console.error("Cannot remove the last target. At least one agent must be configured.");
+        process.exit(1);
+      }
+      let target;
+      if (args.target) {
+        if (!ALL_AGENT_TARGETS.includes(args.target)) {
+          console.error(`Unknown target "${args.target}". Available: ${ALL_AGENT_TARGETS.join(", ")}`);
+          process.exit(1);
+        }
+        target = args.target;
+        if (!current.includes(target)) {
+          R2.info(`${AGENT_DEFINITIONS.find((d2) => d2.target === target).displayName} is not configured.`);
+          return;
+        }
+      } else {
+        const result = await Je({
+          message: "Which agent do you want to remove?",
+          options: current.map((t) => {
+            const def = AGENT_DEFINITIONS.find((d2) => d2.target === t);
+            return { value: t, label: def.displayName, hint: def.hint };
+          })
+        });
+        if (Ct(result)) {
+          Le("Cancelled.");
+          process.exit(0);
+        }
+        target = result;
+      }
+      await cleanupAgentDir(root, target);
+      config2.targets[target] = false;
+      await writeConfig(root, config2);
+      await generate(root, config2);
+      R2.success(`Removed ${AGENT_DEFINITIONS.find((d2) => d2.target === target).displayName}`);
+      R2.info(`Files backed up to ${ONEAGENT_DIR}/backup/`);
+    }
+  });
+});
+
 // ../../node_modules/.bun/citty@0.2.1/node_modules/citty/dist/index.mjs
 init_scule();
 import { parseArgs as parseArgs$1 } from "node:util";
@@ -9831,7 +10213,10 @@ var main = defineCommand({
   subCommands: {
     init: () => Promise.resolve().then(() => (init_init(), exports_init)).then((r) => r.default),
     generate: () => Promise.resolve().then(() => (init_generate2(), exports_generate)).then((r) => r.default),
-    status: () => Promise.resolve().then(() => (init_status2(), exports_status)).then((r) => r.default)
+    status: () => Promise.resolve().then(() => (init_status2(), exports_status)).then((r) => r.default),
+    targets: () => Promise.resolve().then(() => (init_targets(), exports_targets)).then((r) => r.default),
+    add: () => Promise.resolve().then(() => (init_add(), exports_add)).then((r) => r.default),
+    remove: () => Promise.resolve().then(() => (init_remove(), exports_remove)).then((r) => r.default)
   }
 });
 runMain(main);

package/package.json

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