@smicolon/ai-kit 0.5.1 → 0.5.2

package/dist/index.js

@@ -679,6 +679,114 @@ function isSymlink(p3) {
     return false;
   }
 }
+function findOrphans(pack, projectDir) {
+  const orphans = [];
+  const canonicalBase = path5.join(projectDir, CANONICAL_SKILLS_DIR);
+  for (const sourceSkillDir of pack.skills) {
+    const skillName = path5.basename(sourceSkillDir);
+    const canonicalDest = path5.join(canonicalBase, skillName);
+    if (skillDirMatchesSource(canonicalDest, sourceSkillDir)) {
+      orphans.push(canonicalDest);
+    }
+    for (const toolId of TOOL_IDS) {
+      const toolSkillsDir = TOOL_REGISTRY[toolId].components.skills;
+      if (!toolSkillsDir) continue;
+      const linkPath = path5.join(projectDir, toolSkillsDir, skillName);
+      if (path5.resolve(linkPath) === path5.resolve(canonicalDest)) continue;
+      if (symlinkPointsInto(linkPath, canonicalDest)) {
+        orphans.push(linkPath);
+      } else if (!isSymlink(linkPath) && skillDirMatchesSource(linkPath, sourceSkillDir)) {
+        orphans.push(linkPath);
+      }
+    }
+  }
+  const collectFiles = (sourceFiles, component) => {
+    for (const sourceFile of sourceFiles) {
+      const base = path5.basename(sourceFile);
+      for (const toolId of TOOL_IDS) {
+        const dir = TOOL_REGISTRY[toolId].components[component];
+        if (!dir) continue;
+        let destPath;
+        let expected;
+        if (component === "rules" && toolId === "cursor") {
+          const mdcName = path5.basename(sourceFile, ".md") + ".mdc";
+          destPath = path5.join(projectDir, dir, mdcName);
+          expected = Buffer.from(convertToMdc(sourceFile, pack.name));
+          if (fileContentEquals(destPath, expected)) orphans.push(destPath);
+          const legacyPath = path5.join(projectDir, dir, base);
+          try {
+            const legacyExpected = fs6.readFileSync(sourceFile);
+            if (fileContentEquals(legacyPath, legacyExpected)) {
+              orphans.push(legacyPath);
+            }
+          } catch {
+          }
+          continue;
+        }
+        destPath = path5.join(projectDir, dir, base);
+        try {
+          expected = fs6.readFileSync(sourceFile);
+        } catch {
+          continue;
+        }
+        if (fileContentEquals(destPath, expected)) {
+          orphans.push(destPath);
+        }
+      }
+    }
+  };
+  collectFiles(pack.agents, "agents");
+  collectFiles(pack.commands, "commands");
+  collectFiles(pack.rules, "rules");
+  return [...new Set(orphans)];
+}
+function fileContentEquals(filePath, expected) {
+  try {
+    if (!fs6.existsSync(filePath) || isSymlink(filePath)) return false;
+    const stat = fs6.statSync(filePath);
+    if (!stat.isFile()) return false;
+    return fs6.readFileSync(filePath).equals(expected);
+  } catch {
+    return false;
+  }
+}
+function symlinkPointsInto(linkPath, expectedDir) {
+  try {
+    if (!isSymlink(linkPath)) return false;
+    const resolved = path5.resolve(path5.dirname(linkPath), fs6.readlinkSync(linkPath));
+    return path5.resolve(resolved) === path5.resolve(expectedDir);
+  } catch {
+    return false;
+  }
+}
+function skillDirMatchesSource(destDir, sourceDir) {
+  if (!fs6.existsSync(destDir) || isSymlink(destDir)) return false;
+  if (!fs6.statSync(destDir).isDirectory()) return false;
+  const sourceFiles = collectRelativeFiles(sourceDir);
+  const destFiles = collectRelativeFiles(destDir);
+  if (sourceFiles.length !== destFiles.length) return false;
+  const sourceSet = new Set(sourceFiles);
+  for (const f of destFiles) if (!sourceSet.has(f)) return false;
+  for (const rel of sourceFiles) {
+    const src = fs6.readFileSync(path5.join(sourceDir, rel));
+    const dst = fs6.readFileSync(path5.join(destDir, rel));
+    if (!src.equals(dst)) return false;
+  }
+  return true;
+}
+function collectRelativeFiles(dir, base = dir) {
+  const out = [];
+  if (!fs6.existsSync(dir)) return out;
+  for (const entry of fs6.readdirSync(dir, { withFileTypes: true })) {
+    const full = path5.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      out.push(...collectRelativeFiles(full, base));
+    } else if (entry.isFile()) {
+      out.push(path5.relative(base, full));
+    }
+  }
+  return out.sort();
+}
 
 // src/global-config.ts
 import fs7 from "fs";
@@ -1018,30 +1126,58 @@ ${pc3.dim(`${packs.length} packs available`)}`);
 import { Command as Command4 } from "commander";
 import path9 from "path";
 import pc4 from "picocolors";
-var removeCommand = new Command4("remove").description("Remove a pack from your project").argument("<pack>", "Pack name to remove").option("--cwd <dir>", "Project directory").action((packName, opts) => {
+var removeCommand = new Command4("remove").description("Remove a pack from your project").argument("<pack>", "Pack name to remove").option("--cwd <dir>", "Project directory").action(async (packName, opts) => {
   const projectDir = opts.cwd ? path9.resolve(opts.cwd) : process.cwd();
   const config = readConfig(projectDir);
-  if (!config) {
-    console.log(pc4.dim("No packs installed."));
+  const packConfig = config?.packs[packName];
+  const trackedFiles2 = packConfig?.files ?? [];
+  if (trackedFiles2.length > 0) {
+    const removed2 = removePack2(projectDir, trackedFiles2);
+    console.log(pc4.green(`Removed ${removed2} file(s) for ${packName}`));
+    writeConfig(projectDir, removePack(config, packName));
+    console.log(pc4.dim("Config updated."));
     return;
   }
-  const packConfig = config.packs[packName];
-  if (!packConfig) {
+  const pack = await findPack(packName);
+  if (!pack) {
+    const installed = config && Object.keys(config.packs).length > 0 ? "\nInstalled: " + Object.keys(config.packs).join(", ") : "";
     console.error(
-      pc4.red(`Pack "${packName}" is not installed.`) + "\nInstalled: " + Object.keys(config.packs).join(", ")
+      pc4.red(`Pack "${packName}" is not installed and not found in the marketplace.`) + installed
     );
     process.exit(1);
   }
-  const files = packConfig.files ?? [];
-  if (files.length === 0) {
-    console.log(pc4.yellow(`No tracked files for "${packName}". Removing from config only.`));
+  const orphans = findOrphans(pack, projectDir);
+  if (packConfig) {
+    console.log(pc4.yellow(
+      `"${packName}" has no tracked files in .ai-kit.json (legacy install).`
+    ));
+  }
+  if (orphans.length === 0) {
+    if (packConfig) {
+      writeConfig(projectDir, removePack(config, packName));
+      console.log(pc4.dim("Config entry removed; nothing to clean on disk."));
+    } else {
+      console.log(pc4.dim(`Nothing to remove for "${packName}" \u2014 no tracked entry and no orphan files found.`));
+    }
+    return;
+  }
+  if (!packConfig) {
+    console.log(pc4.yellow(
+      `"${packName}" not in .ai-kit.json \u2014 found ${orphans.length} orphan file(s) to clean up:`
+    ));
   } else {
-    const removed = removePack2(projectDir, files);
-    console.log(pc4.green(`Removed ${removed} file(s) for ${packName}`));
+    console.log(pc4.yellow(`Found ${orphans.length} orphan file(s):`));
+  }
+  for (const p3 of orphans) {
+    console.log(pc4.dim("  " + path9.relative(projectDir, p3)));
+  }
+  const relPaths = orphans.map((p3) => path9.relative(projectDir, p3));
+  const removed = removePack2(projectDir, relPaths);
+  console.log(pc4.green(`Removed ${removed} orphan file(s) for ${packName}`));
+  if (packConfig) {
+    writeConfig(projectDir, removePack(config, packName));
+    console.log(pc4.dim("Config updated."));
   }
-  const updated = removePack(config, packName);
-  writeConfig(projectDir, updated);
-  console.log(pc4.dim("Config updated."));
 });
 
 // src/commands/update.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smicolon/ai-kit",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "description": "AI coding tool pack manager for Smicolon standards",
   "license": "MIT",
   "repository": {