pi-agent-toolkit 0.1.2 → 0.2.0

package/dist/index.js

@@ -1,6 +1,9 @@
 #!/usr/bin/env node
 
 // src/index.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname3, resolve as resolve5 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 import { defineCommand, runMain } from "citty";
 
 // src/commands/install.ts
@@ -185,8 +188,7 @@ var extensions = [
     group: "tools",
     description: "Intercepts pip/python calls and redirects to uv",
     method: "copy",
-    source: "extensions/uv.ts",
-    recommends: ["intercepted-commands"]
+    source: "extensions/uv.ts"
   },
   {
     name: "execute-command",
@@ -541,13 +543,15 @@ function getByCategory(category) {
   return registry.filter((c) => c.category === category);
 }
 function getExtensionGroups() {
-  const groups = {};
-  for (const ext of getByCategory("extensions")) {
-    const group = ext.group ?? "tools";
-    if (!groups[group]) groups[group] = [];
-    groups[group].push(ext);
-  }
-  return groups;
+  return getByCategory("extensions").reduce(
+    (acc, ext) => {
+      const key = ext.group ?? "tools";
+      if (!acc[key]) acc[key] = [];
+      acc[key].push(ext);
+      return acc;
+    },
+    {}
+  );
 }
 var GROUP_LABELS = {
   safety: "Safety",
@@ -561,19 +565,21 @@ var GROUP_LABELS = {
 
 // src/lib/warnings.ts
 import * as p from "@clack/prompts";
-async function checkRecommendations(selected) {
+function findMissingRecommendations(selected) {
   const selectedNames = new Set(selected.map((c) => c.name));
   const warnings = [];
   for (const component of selected) {
     if (!component.recommends) continue;
     for (const rec of component.recommends) {
       if (!selectedNames.has(rec)) {
-        warnings.push(
-          `${component.name} works best with ${rec}, which you didn't select.`
-        );
+        warnings.push(`${component.name} works best with ${rec}, which you didn't select.`);
       }
     }
   }
+  return warnings;
+}
+async function checkRecommendations(selected) {
+  const warnings = findMissingRecommendations(selected);
   if (warnings.length === 0) return true;
   p.log.warn("Some selected components have recommendations:");
   for (const warning of warnings) {
@@ -594,12 +600,11 @@ async function checkRecommendations(selected) {
 import {
   cpSync,
   existsSync as existsSync2,
-  mkdirSync as mkdirSync2,
-  symlinkSync,
   lstatSync,
-  readlinkSync,
+  mkdirSync as mkdirSync2,
   readdirSync,
   statSync,
+  symlinkSync,
   unlinkSync
 } from "fs";
 import { resolve as resolve2, basename } from "path";
@@ -635,51 +640,64 @@ function emptyManifest() {
     updatedAt: ""
   };
 }
-function readManifest() {
-  if (!existsSync(MANIFEST_PATH)) return emptyManifest();
+function readManifest(path = MANIFEST_PATH) {
+  if (!existsSync(path)) return emptyManifest();
   try {
-    const raw = readFileSync(MANIFEST_PATH, "utf-8");
-    return JSON.parse(raw);
+    const raw = readFileSync(path, "utf-8");
+    const parsed = JSON.parse(raw);
+    const defaults = emptyManifest();
+    const installed = parsed.installed ?? {};
+    return {
+      version: parsed.version ?? defaults.version,
+      installed: {
+        extensions: installed.extensions ?? defaults.installed.extensions,
+        skills: {
+          bundled: installed.skills?.bundled ?? defaults.installed.skills.bundled,
+          external: installed.skills?.external ?? defaults.installed.skills.external
+        },
+        packages: installed.packages ?? defaults.installed.packages,
+        configs: installed.configs ?? defaults.installed.configs
+      },
+      installedAt: parsed.installedAt ?? defaults.installedAt,
+      updatedAt: parsed.updatedAt ?? defaults.updatedAt
+    };
   } catch {
     return emptyManifest();
   }
 }
-function writeManifest(manifest) {
-  const dir = dirname2(MANIFEST_PATH);
-  mkdirSync(dir, { recursive: true });
-  writeFileSync(MANIFEST_PATH, JSON.stringify(manifest, null, 2) + "\n");
+function writeManifest(manifest, path = MANIFEST_PATH) {
+  mkdirSync(dirname2(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(manifest, null, 2) + "\n");
 }
-function recordInstall(names, category, cliVersion) {
-  const manifest = readManifest();
+function getList(manifest, category) {
+  switch (category) {
+    case "extensions":
+      return manifest.installed.extensions;
+    case "skills-bundled":
+      return manifest.installed.skills.bundled;
+    case "skills-external":
+      return manifest.installed.skills.external;
+    case "packages":
+      return manifest.installed.packages;
+    case "configs":
+      return manifest.installed.configs;
+    default:
+      return null;
+  }
+}
+function recordInstall(names, category, cliVersion, path = MANIFEST_PATH) {
+  const manifest = readManifest(path);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   if (!manifest.installedAt) manifest.installedAt = now;
   manifest.updatedAt = now;
   manifest.version = cliVersion;
-  for (const name of names) {
-    switch (category) {
-      case "extensions":
-        if (!manifest.installed.extensions.includes(name))
-          manifest.installed.extensions.push(name);
-        break;
-      case "skills-bundled":
-        if (!manifest.installed.skills.bundled.includes(name))
-          manifest.installed.skills.bundled.push(name);
-        break;
-      case "skills-external":
-        if (!manifest.installed.skills.external.includes(name))
-          manifest.installed.skills.external.push(name);
-        break;
-      case "packages":
-        if (!manifest.installed.packages.includes(name))
-          manifest.installed.packages.push(name);
-        break;
-      case "configs":
-        if (!manifest.installed.configs.includes(name))
-          manifest.installed.configs.push(name);
-        break;
+  const list2 = getList(manifest, category);
+  if (list2) {
+    for (const name of names) {
+      if (!list2.includes(name)) list2.push(name);
     }
   }
-  writeManifest(manifest);
+  writeManifest(manifest, path);
 }
 
 // src/lib/installer.ts
@@ -712,42 +730,24 @@ function resolveTarget(component) {
       return resolve2(PI_AGENT_DIR, component.name);
   }
 }
-function copyComponent(source, target, isDirectory) {
-  const targetDir = isDirectory ? resolve2(target, "..") : resolve2(target, "..");
-  mkdirSync2(targetDir, { recursive: true });
-  if (isDirectory) {
-    cpSync(source, target, { recursive: true });
-  } else {
-    cpSync(source, target);
-  }
+function copyComponent(source, target) {
+  mkdirSync2(resolve2(target, ".."), { recursive: true });
+  cpSync(source, target, { recursive: true });
 }
 function linkComponent(source, target) {
   const targetDir = resolve2(target, "..");
   mkdirSync2(targetDir, { recursive: true });
-  if (existsSync2(target) || isSymlink(target)) {
-    unlinkSync(target);
-  }
+  if (targetExists(target)) unlinkSync(target);
   symlinkSync(source, target);
 }
-function isSymlink(path) {
+function targetExists(path) {
   try {
     lstatSync(path);
-    return lstatSync(path).isSymbolicLink();
+    return true;
   } catch {
     return false;
   }
 }
-function targetExists(target) {
-  if (isSymlink(target)) {
-    try {
-      readlinkSync(target);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  return existsSync2(target);
-}
 function installLocal(component, options) {
   const source = resolveSource(component, options);
   const target = resolveTarget(component);
@@ -762,7 +762,7 @@ function installLocal(component, options) {
       linkComponent(source, target);
       return { success: true, message: "linked" };
     } else {
-      copyComponent(source, target, component.isDirectory ?? false);
+      copyComponent(source, target);
       return { success: true, message: "copied" };
     }
   } catch (err) {
@@ -810,10 +810,10 @@ async function installComponents(components, options) {
   mkdirSync2(PI_EXTENSIONS_DIR, { recursive: true });
   mkdirSync2(PI_SKILLS_DIR, { recursive: true });
   mkdirSync2(AGENTS_SKILLS_DIR, { recursive: true });
-  const spinner2 = p2.spinner();
+  const spinner3 = p2.spinner();
   const results = [];
   for (const component of components) {
-    spinner2.start(`Installing ${component.name}...`);
+    spinner3.start(`Installing ${component.name}...`);
     let result;
     switch (component.method) {
       case "copy":
@@ -831,9 +831,9 @@ async function installComponents(components, options) {
     }
     results.push({ name: component.name, ...result });
     if (result.success) {
-      spinner2.stop(`${component.name}: ${result.message}`);
+      spinner3.stop(`${component.name}: ${result.message}`);
     } else {
-      spinner2.stop(`${component.name}: FAILED - ${result.message}`);
+      spinner3.stop(`${component.name}: FAILED - ${result.message}`);
     }
   }
   const successByCategory = /* @__PURE__ */ new Map();
@@ -841,19 +841,17 @@ async function installComponents(components, options) {
     if (!r.success) continue;
     const component = components.find((c) => c.name === r.name);
     if (!component) continue;
-    const cat = component.category;
-    if (!successByCategory.has(cat)) successByCategory.set(cat, []);
-    successByCategory.get(cat).push(r.name);
+    const list2 = successByCategory.get(component.category) ?? [];
+    list2.push(r.name);
+    successByCategory.set(component.category, list2);
   }
   for (const [category, names] of successByCategory) {
     recordInstall(names, category, options.cliVersion);
   }
   const succeeded = results.filter((r) => r.success).length;
-  const failed = results.filter((r) => !r.success).length;
+  const failed = results.length - succeeded;
   if (failed > 0) {
-    p2.log.warn(
-      `Installed ${succeeded}/${results.length} components. ${failed} failed:`
-    );
+    p2.log.warn(`Installed ${succeeded}/${results.length} components. ${failed} failed:`);
     for (const r of results.filter((r2) => !r2.success)) {
       p2.log.error(`  ${r.name}: ${r.message}`);
     }
@@ -868,130 +866,82 @@ function installExtensionDeps() {
   for (const entry of entries) {
     const fullPath = resolve2(extDir, entry);
     try {
-      if (statSync(fullPath).isDirectory() && existsSync2(resolve2(fullPath, "package.json"))) {
-        p2.log.info(`Installing dependencies for ${entry}...`);
-        execSync("npm install --silent", { cwd: fullPath, stdio: "pipe" });
+      if (!statSync(fullPath).isDirectory() || !existsSync2(resolve2(fullPath, "package.json"))) {
+        continue;
       }
     } catch {
+      continue;
+    }
+    try {
+      p2.log.info(`Installing dependencies for ${entry}...`);
+      execSync("npm install --silent", { cwd: fullPath, stdio: "pipe" });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      p2.log.error(`Failed to install dependencies for ${entry}: ${msg}`);
     }
   }
 }
 
 // src/commands/install.ts
-function componentOptions(components) {
-  return components.map((c) => ({
-    value: c.name,
-    label: c.name,
-    hint: c.description
-  }));
-}
-async function interactivePicker() {
-  const selected = [];
-  const groups = getExtensionGroups();
-  const extensionOptions = [];
-  for (const group of Object.keys(GROUP_LABELS)) {
-    const components = groups[group];
-    if (!components?.length) continue;
-    extensionOptions.push({
-      value: `__separator_${group}`,
-      label: pc.dim(`--- ${GROUP_LABELS[group]} ---`),
-      hint: ""
-    });
-    extensionOptions.push(...componentOptions(components));
-  }
-  const extResult = await p3.multiselect({
-    message: "Select extensions to install:",
-    options: extensionOptions.filter((o) => !o.value.startsWith("__separator")),
+async function selectComponents(message, components) {
+  if (components.length === 0) return [];
+  const result = await p3.multiselect({
+    message,
+    options: components.map((c) => ({
+      value: c.name,
+      label: c.name,
+      hint: c.description
+    })),
     required: false
   });
-  if (p3.isCancel(extResult)) {
+  if (p3.isCancel(result)) {
     p3.cancel("Installation cancelled.");
     process.exit(0);
   }
-  selected.push(...extResult);
-  const bundledSkills2 = getByCategory("skills-bundled");
-  if (bundledSkills2.length > 0) {
-    const skillResult = await p3.multiselect({
-      message: "Select bundled skills to install:",
-      options: componentOptions(bundledSkills2),
-      required: false
-    });
-    if (p3.isCancel(skillResult)) {
-      p3.cancel("Installation cancelled.");
-      process.exit(0);
-    }
-    selected.push(...skillResult);
-  }
-  const externalSkills2 = getByCategory("skills-external");
-  if (externalSkills2.length > 0) {
-    const extSkillResult = await p3.multiselect({
+  return result;
+}
+async function interactivePicker() {
+  const selected = [];
+  const steps = [
+    { message: "Select extensions to install:", components: getByCategory("extensions") },
+    { message: "Select bundled skills to install:", components: getByCategory("skills-bundled") },
+    {
       message: "Select external skills to install (fetched from source repos):",
-      options: componentOptions(externalSkills2),
-      required: false
-    });
-    if (p3.isCancel(extSkillResult)) {
-      p3.cancel("Installation cancelled.");
-      process.exit(0);
-    }
-    selected.push(...extSkillResult);
-  }
-  const pkgs = getByCategory("packages");
-  if (pkgs.length > 0) {
-    const pkgResult = await p3.multiselect({
-      message: "Select pi packages to install:",
-      options: componentOptions(pkgs),
-      required: false
-    });
-    if (p3.isCancel(pkgResult)) {
-      p3.cancel("Installation cancelled.");
-      process.exit(0);
-    }
-    selected.push(...pkgResult);
-  }
-  const configs2 = getByCategory("configs");
-  if (configs2.length > 0) {
-    const configResult = await p3.multiselect({
-      message: "Select starter configs to install (copied as templates, won't overwrite existing):",
-      options: componentOptions(configs2),
-      required: false
-    });
-    if (p3.isCancel(configResult)) {
-      p3.cancel("Installation cancelled.");
-      process.exit(0);
+      components: getByCategory("skills-external")
+    },
+    { message: "Select pi packages to install:", components: getByCategory("packages") },
+    {
+      message: "Select starter configs (copied as templates, won't overwrite existing):",
+      components: getByCategory("configs")
     }
-    selected.push(...configResult);
+  ];
+  for (const step of steps) {
+    const names = await selectComponents(step.message, step.components);
+    selected.push(...names);
   }
   return registry.filter((c) => selected.includes(c.name));
 }
 function resolveFromFlags(args) {
-  const names = /* @__PURE__ */ new Set();
-  if (args.extensions) {
-    for (const name of args.extensions) names.add(name);
-  }
-  if (args.skills) {
-    for (const name of args.skills) names.add(name);
-  }
-  if (args.packages) {
-    for (const name of args.packages) names.add(name);
-  }
+  const names = /* @__PURE__ */ new Set([
+    ...args.extensions ?? [],
+    ...args.skills ?? [],
+    ...args.packages ?? []
+  ]);
   const resolved = [];
   const notFound = [];
   for (const name of names) {
     const component = registry.find((c) => c.name === name);
-    if (component) {
-      resolved.push(component);
-    } else {
-      notFound.push(name);
-    }
+    if (component) resolved.push(component);
+    else notFound.push(name);
   }
   if (notFound.length > 0) {
     p3.log.warn(`Unknown components: ${notFound.join(", ")}`);
-    p3.log.info('Run "pi-toolkit list" to see available components.');
+    p3.log.info('Run "pi-agent-toolkit list" to see available components.');
   }
   return resolved;
 }
 async function runInstall(args) {
-  p3.intro(pc.bold("pi-toolkit install"));
+  p3.intro(pc.bold("pi-agent-toolkit install"));
   if (args.link && !args.repoPath) {
     p3.log.error("--link requires --repo-path to be set.");
     p3.log.info("Example: pi-toolkit install --link --repo-path ~/Code/pi-toolkit");
@@ -1011,18 +961,14 @@ async function runInstall(args) {
     p3.outro("Done.");
     return;
   }
-  const extCount = components.filter((c) => c.category === "extensions").length;
-  const skillCount = components.filter(
-    (c) => c.category === "skills-bundled" || c.category === "skills-external"
-  ).length;
-  const pkgCount = components.filter((c) => c.category === "packages").length;
-  const cfgCount = components.filter((c) => c.category === "configs").length;
-  const parts = [];
-  if (extCount) parts.push(`${extCount} extension${extCount > 1 ? "s" : ""}`);
-  if (skillCount) parts.push(`${skillCount} skill${skillCount > 1 ? "s" : ""}`);
-  if (pkgCount) parts.push(`${pkgCount} package${pkgCount > 1 ? "s" : ""}`);
-  if (cfgCount) parts.push(`${cfgCount} config${cfgCount > 1 ? "s" : ""}`);
-  p3.log.info(`Will install: ${parts.join(", ")}`);
+  const counts = [
+    ["extension", components.filter((c) => c.category === "extensions").length],
+    ["skill", components.filter((c) => c.category.startsWith("skills-")).length],
+    ["package", components.filter((c) => c.category === "packages").length],
+    ["config", components.filter((c) => c.category === "configs").length]
+  ];
+  const summary = counts.filter(([, n]) => n > 0).map(([label, n]) => `${n} ${label}${n > 1 ? "s" : ""}`).join(", ");
+  p3.log.info(`Will install: ${summary}`);
   if (args.link) {
     p3.log.info(`Mode: symlink (repo: ${args.repoPath})`);
   }
@@ -1054,7 +1000,7 @@ async function runInstall(args) {
 import pc2 from "picocolors";
 function runList() {
   console.log();
-  console.log(pc2.bold("pi-toolkit: available components"));
+  console.log(pc2.bold("pi-agent-toolkit: available components"));
   console.log();
   console.log(pc2.bold(pc2.cyan("Extensions")));
   const groups = getExtensionGroups();
@@ -1103,7 +1049,7 @@ function runList() {
 }
 
 // src/commands/status.ts
-import { existsSync as existsSync3, lstatSync as lstatSync2, readlinkSync as readlinkSync2 } from "fs";
+import { existsSync as existsSync3, lstatSync as lstatSync2, readlinkSync } from "fs";
 import { resolve as resolve3, basename as basename2 } from "path";
 import pc3 from "picocolors";
 function expectedPath(component) {
@@ -1121,8 +1067,7 @@ function expectedPath(component) {
     case "skills-external": {
       const piPath = resolve3(PI_SKILLS_DIR, component.name);
       const agentsPath = resolve3(AGENTS_SKILLS_DIR, component.name);
-      if (existsSync3(piPath) || isSymlink2(piPath)) return piPath;
-      if (existsSync3(agentsPath) || isSymlink2(agentsPath)) return agentsPath;
+      if (existsSync3(piPath)) return piPath;
       return agentsPath;
     }
     case "packages":
@@ -1136,44 +1081,36 @@ function expectedPath(component) {
       return null;
   }
 }
-function isSymlink2(path) {
+function checkFile(path) {
   try {
-    return lstatSync2(path).isSymbolicLink();
+    const stats = lstatSync2(path);
+    if (stats.isSymbolicLink()) {
+      const target = readlinkSync(path);
+      const dangling = !existsSync3(path);
+      return {
+        exists: !dangling,
+        detail: dangling ? `dangling symlink -> ${target}` : `symlink -> ${target}`
+      };
+    }
+    return { exists: true };
   } catch {
-    return false;
+    return { exists: false };
   }
 }
-function checkFile(path) {
-  if (isSymlink2(path)) {
-    const target = readlinkSync2(path);
-    const dangling = !existsSync3(path);
-    return {
-      exists: !dangling,
-      detail: dangling ? `dangling symlink -> ${target}` : `symlink -> ${target}`
-    };
-  }
-  return { exists: existsSync3(path) };
-}
 function runStatus() {
   const manifest = readManifest();
   console.log();
-  console.log(pc3.bold("pi-toolkit status"));
+  console.log(pc3.bold("pi-agent-toolkit status"));
   console.log();
   if (!manifest.installedAt) {
     console.log(pc3.dim("No pi-toolkit manifest found. Nothing has been installed yet."));
-    console.log(pc3.dim('Run "pi-toolkit install" to get started.'));
+    console.log(pc3.dim('Run "pi-agent-toolkit install" to get started.'));
     console.log();
     return;
   }
-  console.log(
-    `${pc3.dim("CLI version:")}  ${manifest.version || "unknown"}`
-  );
-  console.log(
-    `${pc3.dim("Installed at:")} ${manifest.installedAt}`
-  );
-  console.log(
-    `${pc3.dim("Updated at:")}   ${manifest.updatedAt}`
-  );
+  console.log(`${pc3.dim("CLI version:")}  ${manifest.version || "unknown"}`);
+  console.log(`${pc3.dim("Installed at:")} ${manifest.installedAt}`);
+  console.log(`${pc3.dim("Updated at:")}   ${manifest.updatedAt}`);
   console.log();
   const installedNames = /* @__PURE__ */ new Set([
     ...manifest.installed.extensions,
@@ -1241,21 +1178,205 @@ function runStatus() {
   }
   const missing = entries.filter((e) => e.status === "missing");
   if (missing.length > 0) {
-    console.log(
-      pc3.yellow(
-        `${missing.length} component(s) in manifest but missing from disk:`
-      )
-    );
+    console.log(pc3.yellow(`${missing.length} component(s) in manifest but missing from disk:`));
     for (const m of missing) {
       console.log(pc3.yellow(`  - ${m.name}`));
     }
-    console.log(pc3.dim('Re-run "pi-toolkit install" to restore them.'));
+    console.log(pc3.dim('Re-run "pi-agent-toolkit install" to restore them.'));
     console.log();
   }
 }
 
+// src/commands/sync.ts
+import {
+  cpSync as cpSync2,
+  existsSync as existsSync4,
+  lstatSync as lstatSync3,
+  mkdirSync as mkdirSync3,
+  readdirSync as readdirSync2,
+  rmSync,
+  statSync as statSync2,
+  symlinkSync as symlinkSync2,
+  unlinkSync as unlinkSync2
+} from "fs";
+import { resolve as resolve4 } from "path";
+import * as p4 from "@clack/prompts";
+import pc4 from "picocolors";
+function getExternalSkillNames() {
+  return new Set(getByCategory("skills-external").map((c) => c.name));
+}
+function isSymlink(path) {
+  try {
+    return lstatSync3(path).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+function findUnmanaged(scanDir, targetDir, category, skipNames) {
+  if (!existsSync4(scanDir)) return [];
+  const items = [];
+  const entries = readdirSync2(scanDir);
+  for (const entry of entries) {
+    const fullPath = resolve4(scanDir, entry);
+    if (isSymlink(fullPath)) continue;
+    if (skipNames.has(entry) || skipNames.has(entry.replace(/\.ts$/, ""))) continue;
+    if (entry === "node_modules" || entry.startsWith(".")) continue;
+    let isDir;
+    try {
+      isDir = statSync2(fullPath).isDirectory();
+    } catch {
+      continue;
+    }
+    if (category === "extensions") {
+      if (!isDir && !entry.endsWith(".ts")) continue;
+    } else {
+      if (!isDir) continue;
+    }
+    items.push({
+      name: entry,
+      sourcePath: fullPath,
+      targetDir,
+      category,
+      isDirectory: isDir
+    });
+  }
+  return items;
+}
+function absorbItem(item) {
+  const targetPath = resolve4(item.targetDir, item.name);
+  try {
+    mkdirSync3(item.targetDir, { recursive: true });
+    if (item.isDirectory) {
+      cpSync2(item.sourcePath, targetPath, { recursive: true });
+      rmSync(item.sourcePath, { recursive: true, force: true });
+    } else {
+      cpSync2(item.sourcePath, targetPath);
+      unlinkSync2(item.sourcePath);
+    }
+    symlinkSync2(targetPath, item.sourcePath);
+    return { success: true, message: "absorbed and symlinked" };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { success: false, message: msg };
+  }
+}
+async function runSync(options) {
+  p4.intro(pc4.bold("pi-agent-toolkit sync"));
+  const repoPath = resolve4(options.repoPath);
+  const dotfilesPath = resolve4(repoPath, "dotfiles");
+  if (!existsSync4(dotfilesPath)) {
+    p4.log.error(`dotfiles/ not found at ${dotfilesPath}`);
+    p4.log.info("Make sure --repo-path points to your pi-toolkit repo clone.");
+    process.exit(1);
+  }
+  p4.log.info(`Repo: ${repoPath}`);
+  p4.log.info("Scanning for unmanaged extensions and skills...");
+  const externalSkills2 = getExternalSkillNames();
+  const knownExtensions = /* @__PURE__ */ new Set();
+  const extDir = resolve4(dotfilesPath, "extensions");
+  if (existsSync4(extDir)) {
+    for (const entry of readdirSync2(extDir)) {
+      knownExtensions.add(entry);
+    }
+  }
+  const knownAgentSkills = /* @__PURE__ */ new Set();
+  const agentSkillsDir = resolve4(dotfilesPath, "agent-skills");
+  if (existsSync4(agentSkillsDir)) {
+    for (const entry of readdirSync2(agentSkillsDir)) {
+      knownAgentSkills.add(entry);
+    }
+  }
+  const knownGlobalSkills = /* @__PURE__ */ new Set();
+  const globalSkillsDir = resolve4(dotfilesPath, "global-skills");
+  if (existsSync4(globalSkillsDir)) {
+    for (const entry of readdirSync2(globalSkillsDir)) {
+      knownGlobalSkills.add(entry);
+    }
+  }
+  const found = [
+    ...findUnmanaged(
+      PI_EXTENSIONS_DIR,
+      resolve4(dotfilesPath, "extensions"),
+      "extensions",
+      knownExtensions
+    ),
+    ...findUnmanaged(
+      PI_SKILLS_DIR,
+      resolve4(dotfilesPath, "agent-skills"),
+      "agent-skills",
+      /* @__PURE__ */ new Set([...knownAgentSkills, ...externalSkills2])
+    ),
+    ...findUnmanaged(
+      AGENTS_SKILLS_DIR,
+      resolve4(dotfilesPath, "global-skills"),
+      "global-skills",
+      /* @__PURE__ */ new Set([...knownGlobalSkills, ...externalSkills2])
+    )
+  ];
+  if (found.length === 0) {
+    p4.log.success("No unmanaged extensions or skills found. Everything is in sync.");
+    p4.outro("Done.");
+    return;
+  }
+  p4.log.info(`Found ${found.length} unmanaged item(s):`);
+  for (const item of found) {
+    const suffix = item.isDirectory ? "/" : "";
+    p4.log.message(`  ${pc4.yellow(item.name + suffix)} ${pc4.dim(`(${item.category})`)}`);
+  }
+  let toAbsorb;
+  if (options.all) {
+    toAbsorb = found;
+  } else {
+    const selected = await p4.multiselect({
+      message: "Select items to absorb into the repo:",
+      options: found.map((item) => ({
+        value: item.name,
+        label: item.name + (item.isDirectory ? "/" : ""),
+        hint: `${item.category} -> dotfiles/${item.category}/${item.name}`
+      })),
+      required: false
+    });
+    if (p4.isCancel(selected)) {
+      p4.cancel("Sync cancelled.");
+      process.exit(0);
+    }
+    const selectedNames = new Set(selected);
+    toAbsorb = found.filter((item) => selectedNames.has(item.name));
+  }
+  if (toAbsorb.length === 0) {
+    p4.log.warn("Nothing selected to absorb.");
+    p4.outro("Done.");
+    return;
+  }
+  const spinner3 = p4.spinner();
+  let succeeded = 0;
+  let failed = 0;
+  for (const item of toAbsorb) {
+    spinner3.start(`Absorbing ${item.name}...`);
+    const result = absorbItem(item);
+    if (result.success) {
+      spinner3.stop(`${item.name}: ${result.message}`);
+      succeeded++;
+    } else {
+      spinner3.stop(`${item.name}: FAILED - ${result.message}`);
+      failed++;
+    }
+  }
+  if (failed > 0) {
+    p4.log.warn(`Absorbed ${succeeded}/${toAbsorb.length}. ${failed} failed.`);
+  } else {
+    p4.log.success(`All ${succeeded} item(s) absorbed into the repo.`);
+  }
+  p4.outro(
+    pc4.green("Next steps: review the new files in dotfiles/, add to registry.ts, then commit.")
+  );
+}
+
 // src/index.ts
-var CLI_VERSION = "0.1.0";
+var __dirname2 = dirname3(fileURLToPath2(import.meta.url));
+var CLI_VERSION = JSON.parse(
+  readFileSync2(resolve5(__dirname2, "..", "package.json"), "utf-8")
+).version;
 var install = defineCommand({
   meta: {
     name: "install",
@@ -1329,6 +1450,30 @@ var status = defineCommand({
     runStatus();
   }
 });
+var sync = defineCommand({
+  meta: {
+    name: "sync",
+    description: "Absorb unmanaged extensions and skills from pi into the repo"
+  },
+  args: {
+    "repo-path": {
+      type: "string",
+      description: "Path to local pi-toolkit repo clone",
+      required: true
+    },
+    all: {
+      type: "boolean",
+      description: "Absorb all unmanaged items without prompting",
+      default: false
+    }
+  },
+  run({ args }) {
+    return runSync({
+      repoPath: args["repo-path"],
+      all: args.all
+    });
+  }
+});
 var main = defineCommand({
   meta: {
     name: "pi-agent-toolkit",
@@ -1338,7 +1483,8 @@ var main = defineCommand({
   subCommands: {
     install,
     list,
-    status
+    status,
+    sync
   }
 });
 runMain(main);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-agent-toolkit",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "CLI to selectively install curated extensions, skills, and configs for the pi coding agent",
   "keywords": [
     "pi",
@@ -27,11 +27,13 @@
   "scripts": {
     "build": "tsup",
     "dev": "tsup --watch",
+    "test": "node --experimental-strip-types --test src/**/*.test.ts",
+    "typecheck": "tsc",
     "prepack": "npm run build"
   },
   "dependencies": {
-    "@clack/prompts": "^0.10.0",
-    "citty": "^0.1.6",
+    "@clack/prompts": "^0.11.0",
+    "citty": "^0.2.1",
     "picocolors": "^1.1.1"
   },
   "devDependencies": {