@iannuttall/dotagents 0.1.0 → 0.1.1

package/README.md

@@ -52,6 +52,8 @@ Global home affects all projects. Project folder only affects the current direct
 
 `.agents/skills` → `~/.factory/skills`
 
+`.agents/skills` → `~/.codex/skills`
+
 ## Development
 
 Run the TUI in dev mode:

package/dist/cli.js

@@ -3498,6 +3498,7 @@ import { render } from "ink";
 // src/tui/App.tsx
 import { useEffect as useEffect2, useMemo, useState } from "react";
 import fs10 from "fs";
+import path15 from "path";
 import { Box as Box4, Text as Text2, useApp, useInput as useInput2, useStdout as useStdout3 } from "ink";
 import SelectInput from "ink-select-input";
 import TextInput from "ink-text-input";
@@ -3571,7 +3572,8 @@ function getMappings(opts) {
       source: path2.join(canonical, "skills"),
       targets: [
         path2.join(roots.claudeRoot, "skills"),
-        path2.join(roots.factoryRoot, "skills")
+        path2.join(roots.factoryRoot, "skills"),
+        path2.join(roots.codexRoot, "skills")
       ],
       kind: "dir"
     }
@@ -3719,26 +3721,91 @@ async function createSource(task) {
   }
   await ensureFile(task.path, DEFAULT_AGENTS);
 }
-async function createLink(source, target, kind, force) {
+function commonPath(paths) {
+  if (paths.length === 0)
+    return null;
+  const splitPaths = paths.map((p) => path5.resolve(p).split(path5.sep));
+  const minLen = Math.min(...splitPaths.map((parts) => parts.length));
+  const shared = [];
+  for (let i = 0;i < minLen; i += 1) {
+    const segment = splitPaths[0]?.[i];
+    if (!segment)
+      break;
+    if (splitPaths.every((parts) => parts[i] === segment)) {
+      shared.push(segment);
+    } else {
+      break;
+    }
+  }
+  if (shared.length === 0)
+    return null;
+  if (shared[0] === "")
+    return path5.sep + shared.slice(1).join(path5.sep);
+  return shared.join(path5.sep);
+}
+function inferBackupDir(plan) {
+  const sourceDirs = plan.tasks.map((task) => task.type === "ensure-source" ? task.path : task.source).filter(Boolean).map((p) => path5.dirname(p));
+  const root = commonPath(sourceDirs);
+  if (!root)
+    return null;
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+  return path5.join(root, "backup", timestamp);
+}
+async function backupTarget(target, backupDir) {
+  if (!await pathExists(target))
+    return false;
+  const stat = await fs3.promises.lstat(target);
+  if (stat.isSymbolicLink())
+    return false;
+  const root = path5.parse(target).root || path5.sep;
+  const rel = path5.relative(root, target);
+  const dest = path5.join(backupDir, rel);
+  await ensureDir(path5.dirname(dest));
+  try {
+    await fs3.promises.rename(target, dest);
+    return true;
+  } catch (err) {
+    if (err?.code !== "EXDEV")
+      throw err;
+  }
+  if (stat.isDirectory()) {
+    await copyDir(target, dest, true);
+  } else {
+    await copyFile(target, dest, true);
+  }
+  await removePath(target);
+  return true;
+}
+async function createLink(source, target, kind, force, backupDir) {
   if (await pathExists(target)) {
     if (!force)
-      return;
+      return { created: false, backedUp: false };
+    const backedUp = backupDir ? await backupTarget(target, backupDir) : false;
     await removePath(target);
+    await ensureDir(path5.dirname(target));
+    const type2 = kind === "dir" ? "junction" : "file";
+    await fs3.promises.symlink(source, target, type2);
+    return { created: true, backedUp };
   }
   await ensureDir(path5.dirname(target));
   const type = kind === "dir" ? "junction" : "file";
   await fs3.promises.symlink(source, target, type);
+  return { created: true, backedUp: false };
 }
 async function applyLinkPlan(plan, opts) {
   const force = !!opts?.force;
+  const backupDir = force ? opts?.backupDir || inferBackupDir(plan) || undefined : undefined;
   let applied = 0;
   let skipped = 0;
   let conflicts = 0;
+  let backedUp = 0;
   for (const task of plan.tasks) {
     if (task.type === "conflict") {
       conflicts += 1;
       if (force && task.target !== task.source && task.kind) {
-        await createLink(task.source, task.target, task.kind, true);
+        const result = await createLink(task.source, task.target, task.kind, true, backupDir);
+        if (result.backedUp)
+          backedUp += 1;
         applied += 1;
       }
       continue;
@@ -3754,14 +3821,16 @@ async function applyLinkPlan(plan, opts) {
     }
     if (task.type === "link") {
       const before = await pathExists(task.target);
-      await createLink(task.source, task.target, task.kind, force);
+      const result = await createLink(task.source, task.target, task.kind, force, backupDir);
+      if (result.backedUp)
+        backedUp += 1;
       if (before && !force)
         skipped += 1;
       else
         applied += 1;
     }
   }
-  return { applied, skipped, conflicts };
+  return { applied, skipped, conflicts, backupDir, backedUp };
 }
 
 // src/core/status.ts
@@ -3923,7 +3992,8 @@ async function scanMigration(opts) {
     ],
     skills: [
       { label: "Claude skills", dir: path8.join(roots.claudeRoot, "skills") },
-      { label: "Factory skills", dir: path8.join(roots.factoryRoot, "skills") }
+      { label: "Factory skills", dir: path8.join(roots.factoryRoot, "skills") },
+      { label: "Codex skills", dir: path8.join(roots.codexRoot, "skills") }
     ],
     agents: [
       { label: "Claude CLAUDE.md", file: path8.join(roots.claudeRoot, "CLAUDE.md") }
@@ -4006,6 +4076,7 @@ async function scanMigration(opts) {
     { label: "factory/hooks", path: path8.join(roots.factoryRoot, "hooks"), kind: "dir" },
     { label: "claude/skills", path: path8.join(roots.claudeRoot, "skills"), kind: "dir" },
     { label: "factory/skills", path: path8.join(roots.factoryRoot, "skills"), kind: "dir" },
+    { label: "codex/skills", path: path8.join(roots.codexRoot, "skills"), kind: "dir" },
     { label: "claude/CLAUDE.md", path: path8.join(roots.claudeRoot, "CLAUDE.md"), kind: "file" }
   ];
   return { auto, conflicts, backupPaths, canonicalRoot };
@@ -4605,6 +4676,7 @@ var App = () => {
   const [skillInput, setSkillInput] = useState("");
   const [marketplaceInput, setMarketplaceInput] = useState("");
   const [marketplacePlugins, setMarketplacePlugins] = useState([]);
+  const [forceBackupDir, setForceBackupDir] = useState(null);
   const [showDetails, setShowDetails] = useState(false);
   const [conflictsOnly, setConflictsOnly] = useState(false);
   const { stdout } = useStdout3();
@@ -4622,6 +4694,8 @@ var App = () => {
         return setStep("scope");
       if (step === "status")
         return setStep("action");
+      if (step === "force-confirm")
+        return setStep("action");
       if (step === "migrate-choice") {
         setMigratePlan(null);
         setMigrateSelections(new Map);
@@ -4659,7 +4733,7 @@ var App = () => {
       { label: "Apply/repair links", value: "apply" }
     ];
     if (conflicts > 0)
-      items.push({ label: "Force apply (overwrite conflicts)", value: "force-apply" });
+      items.push({ label: "Force apply (backup + overwrite conflicts)", value: "force-apply" });
     items.push({ label: "View status", value: "view-status" });
     items.push({ label: "Migrate existing content", value: "migrate" });
     items.push({ label: "Add skill", value: "add-skill" });
@@ -4892,13 +4966,33 @@ var App = () => {
                   return;
                 }
                 if (item.value === "apply" || item.value === "force-apply") {
-                  setBusy(item.value === "force-apply" ? "Applying (force)..." : "Applying...");
+                  if (item.value === "force-apply") {
+                    setBusy("Preparing force apply...");
+                    setStep("applying");
+                    (async () => {
+                      try {
+                        if (!scope)
+                          return;
+                        const roots = resolveRoots({ scope });
+                        const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+                        setForceBackupDir(path15.join(roots.canonicalRoot, "backup", timestamp));
+                        setStep("force-confirm");
+                      } catch (err) {
+                        setMessage(err?.message || String(err));
+                        setStep("done");
+                      } finally {
+                        setBusy(null);
+                      }
+                    })();
+                    return;
+                  }
+                  setBusy("Applying...");
                   setStep("applying");
                   (async () => {
                     try {
                       if (!plan || !scope)
                         return;
-                      const result = await applyLinkPlan(plan, { force: item.value === "force-apply" });
+                      const result = await applyLinkPlan(plan);
                       setMessage(`Applied: ${result.applied}, Skipped: ${result.skipped}, Conflicts: ${result.conflicts}`);
                       await refreshStatus(scope);
                     } catch (err) {
@@ -4981,6 +5075,70 @@ var App = () => {
       ]
     }, undefined, true, undefined, this);
   }
+  if (step === "force-confirm") {
+    return /* @__PURE__ */ jsxDEV4(Screen, {
+      children: [
+        /* @__PURE__ */ jsxDEV4(Text2, {
+          color: "yellow",
+          children: "Force apply will overwrite existing real files/directories."
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsxDEV4(Box4, {
+          flexDirection: "column",
+          marginTop: 1,
+          children: [
+            /* @__PURE__ */ jsxDEV4(Text2, {
+              children: "Backup will be created at:"
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsxDEV4(Text2, {
+              dimColor: true,
+              children: forceBackupDir || "(pending)"
+            }, undefined, false, undefined, this)
+          ]
+        }, undefined, true, undefined, this),
+        /* @__PURE__ */ jsxDEV4(Box4, {
+          marginTop: 1,
+          flexDirection: "column",
+          children: [
+            /* @__PURE__ */ jsxDEV4(SelectInput, {
+              items: [
+                { label: "Proceed (create backup + overwrite)", value: "proceed" },
+                { label: "Cancel", value: "cancel" }
+              ],
+              onSelect: (item) => {
+                if (item.value === "cancel") {
+                  setForceBackupDir(null);
+                  setStep("action");
+                  return;
+                }
+                setBusy("Applying (force)...");
+                setStep("applying");
+                (async () => {
+                  try {
+                    if (!plan || !scope)
+                      return;
+                    const backupDir = forceBackupDir || undefined;
+                    const result = await applyLinkPlan(plan, { force: true, backupDir });
+                    const backupNote = result.backedUp > 0 && result.backupDir ? `, Backed up: ${result.backedUp} (${result.backupDir})` : "";
+                    setMessage(`Applied: ${result.applied}, Skipped: ${result.skipped}, Conflicts: ${result.conflicts}${backupNote}`);
+                    await refreshStatus(scope);
+                  } catch (err) {
+                    setMessage(err?.message || String(err));
+                  } finally {
+                    setForceBackupDir(null);
+                    setBusy(null);
+                    setStep("done");
+                  }
+                })();
+              }
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsxDEV4(HelpBar, {
+              text: "Enter to confirm · Esc to cancel · q to quit"
+            }, undefined, false, undefined, this)
+          ]
+        }, undefined, true, undefined, this)
+      ]
+    }, undefined, true, undefined, this);
+  }
   if (step === "migrate-choice" && migratePlan) {
     const conflict = migratePlan.conflicts[migrateIndex];
     if (!conflict) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iannuttall/dotagents",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Canonical .agents manager with symlinks for popular AI tools",
   "type": "module",
   "license": "MIT",