@h1dr0n/skill-pool 0.1.0 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@h1dr0n/skill-pool",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "CLI tool to install AI coding skills per-project",
   "type": "module",
   "bin": {

package/src/commands/add.js

@@ -4,12 +4,7 @@ import chalk from 'chalk';
 import yaml from 'js-yaml';
 import { cloneRepo, isGitAvailable } from '../utils/git.js';
 import { fileExists, readFileContent, copyDir, removeDir, ensureDir } from '../utils/fs.js';
-import {
-  loadTracker,
-  saveTracker,
-  getInstalledVersion,
-  recordInstall,
-} from '../core/tracker.js';
+import { loadTracker, getInstalledVersion } from '../core/tracker.js';
 import { getAdapter, detectTargets } from '../adapters/index.js';
 
 /**
@@ -237,26 +232,9 @@ export async function addCommand(rawUrl, options = {}) {
       totalFiles += files.length;
     }
 
-    // 10. Update tracker with github source
-    tracker = recordInstall(tracker, manifest.name, manifest.version, targets);
-
-    // Add source metadata
-    tracker = {
-      ...tracker,
-      installed: {
-        ...tracker.installed,
-        [manifest.name]: {
-          ...tracker.installed[manifest.name],
-          source: `github:${rawUrl}`,
-        },
-      },
-    };
-
-    await saveTracker(projectDir, tracker);
-
     console.log(
       chalk.green(`  + ${manifest.name}@${manifest.version}`) +
-        chalk.gray(` (${totalFiles} rules, source: github)`)
+        chalk.gray(` (${totalFiles} files, source: github)`)
     );
     console.log(chalk.green(`\nInstalled 1 pack for ${targets.join(', ')}.`));
   } finally {

package/src/commands/install.js

@@ -1,39 +1,33 @@
 import chalk from 'chalk';
 import { resolveDependencies, checkConflicts } from '../core/resolver.js';
 import { loadManifest } from '../core/manifest.js';
-import {
-  loadTracker,
-  saveTracker,
-  getInstalledVersion,
-  recordInstall,
-} from '../core/tracker.js';
-import { getAdapter, detectTargets, getAllTargetNames } from '../adapters/index.js';
+import { loadTracker, getInstalledVersion } from '../core/tracker.js';
+import { getAdapter, detectTargets } from '../adapters/index.js';
 
 async function resolveTargets(projectDir, targetOption) {
   if (targetOption) {
     const names = targetOption.split(',').map((t) => t.trim());
-    names.forEach((n) => getAdapter(n)); // validate
+    names.forEach((n) => getAdapter(n));
     return names;
   }
 
   const detected = await detectTargets(projectDir);
   if (detected.length > 0) return detected;
 
-  // Default to claude if nothing detected
   return ['claude'];
 }
 
 export async function installCommand(packNames, options = {}) {
   const projectDir = process.cwd();
   const targets = await resolveTargets(projectDir, options.target);
-  let tracker = await loadTracker(projectDir);
+  const tracker = await loadTracker(projectDir);
 
   console.log(chalk.gray(`Targets: ${targets.join(', ')}\n`));
 
   if (packNames.length > 1) {
     const conflicts = await checkConflicts(packNames);
     if (conflicts.length > 0) {
-      console.log(chalk.yellow('⚠ Dependency version conflicts detected:\n'));
+      console.log(chalk.yellow('Dependency version conflicts detected:\n'));
       for (const conflict of conflicts) {
         console.log(
           chalk.yellow(
@@ -42,7 +36,7 @@ export async function installCommand(packNames, options = {}) {
           )
         );
       }
-      console.log(chalk.yellow('\n  Using latest version for each conflicting dependency.\n'));
+      console.log(chalk.yellow('\n  Using latest version for each.\n'));
     }
   }
 
@@ -71,17 +65,13 @@ export async function installCommand(packNames, options = {}) {
       totalFiles += files.length;
     }
 
-    tracker = recordInstall(tracker, packName, manifest.version, targets);
     installedCount++;
-
     console.log(
       chalk.green(`  + ${packName}@${manifest.version}`) +
-        chalk.gray(` (${totalFiles} rules)`)
+        chalk.gray(` (${totalFiles} files)`)
     );
   }
 
-  await saveTracker(projectDir, tracker);
-
   if (installedCount === 0) {
     console.log(chalk.yellow('\nAll packs already up to date.'));
   } else {

package/src/commands/remove.js

@@ -1,10 +1,5 @@
 import chalk from 'chalk';
-import {
-  loadTracker,
-  saveTracker,
-  isInstalled,
-  recordRemove,
-} from '../core/tracker.js';
+import { loadTracker, isInstalled, getInstalledTargets } from '../core/tracker.js';
 import { loadManifest } from '../core/manifest.js';
 import { getAdapter, getAllTargetNames } from '../adapters/index.js';
 
@@ -20,18 +15,13 @@ async function findDependents(packName, tracker) {
         dependents.push(installed);
       }
     } catch {
-      // skip if manifest can't be loaded
+      // skip
     }
   }
 
   return dependents;
 }
 
-function getTargetsForPack(tracker, packName) {
-  const info = tracker.installed[packName];
-  return info?.targets || getAllTargetNames();
-}
-
 async function removeFromAllTargets(packName, targets, projectDir) {
   let totalRemoved = 0;
   for (const targetName of targets) {
@@ -40,7 +30,7 @@ async function removeFromAllTargets(packName, targets, projectDir) {
       const removed = await adapter.remove(packName, projectDir);
       totalRemoved += removed.length;
     } catch {
-      // adapter might not have files for this pack
+      // adapter might not have files
     }
   }
   return totalRemoved;
@@ -48,7 +38,7 @@ async function removeFromAllTargets(packName, targets, projectDir) {
 
 export async function removeCommand(packName, options) {
   const projectDir = process.cwd();
-  let tracker = await loadTracker(projectDir);
+  const tracker = await loadTracker(projectDir);
 
   if (options.all) {
     const installedPacks = Object.keys(tracker.installed);
@@ -58,15 +48,13 @@ export async function removeCommand(packName, options) {
     }
 
     for (const name of installedPacks) {
-      const targets = getTargetsForPack(tracker, name);
-      const count = await removeFromAllTargets(name, targets, projectDir);
-      tracker = recordRemove(tracker, name);
+      const targets = getInstalledTargets(tracker, name);
+      const count = await removeFromAllTargets(name, targets.length > 0 ? targets : getAllTargetNames(), projectDir);
       console.log(
-        chalk.red(`  - ${name}`) + chalk.gray(` (${count} rules removed)`)
+        chalk.red(`  - ${name}`) + chalk.gray(` (${count} files removed)`)
       );
     }
 
-    await saveTracker(projectDir, tracker);
     console.log(chalk.green('\nAll packs removed.'));
     return;
   }
@@ -90,12 +78,10 @@ export async function removeCommand(packName, options) {
     );
   }
 
-  const targets = getTargetsForPack(tracker, packName);
-  const count = await removeFromAllTargets(packName, targets, projectDir);
-  tracker = recordRemove(tracker, packName);
-  await saveTracker(projectDir, tracker);
+  const targets = getInstalledTargets(tracker, packName);
+  const count = await removeFromAllTargets(packName, targets.length > 0 ? targets : getAllTargetNames(), projectDir);
 
   console.log(
-    chalk.red(`  - ${packName}`) + chalk.gray(` (${count} rules removed)`)
+    chalk.red(`  - ${packName}`) + chalk.gray(` (${count} files removed)`)
   );
 }

package/src/commands/update.js

@@ -1,15 +1,11 @@
 import chalk from 'chalk';
 import { loadManifest } from '../core/manifest.js';
-import {
-  loadTracker,
-  saveTracker,
-  recordInstall,
-} from '../core/tracker.js';
+import { loadTracker, getInstalledTargets } from '../core/tracker.js';
 import { getAdapter } from '../adapters/index.js';
 
 export async function updateCommand(packName) {
   const projectDir = process.cwd();
-  let tracker = await loadTracker(projectDir);
+  const tracker = await loadTracker(projectDir);
   const installedPacks = Object.keys(tracker.installed);
 
   if (installedPacks.length === 0) {
@@ -28,9 +24,9 @@ export async function updateCommand(packName) {
     }
 
     const manifest = await loadManifest(name);
-    const targets = info.targets || ['claude'];
+    const targets = getInstalledTargets(tracker, name);
+    if (targets.length === 0) targets.push('claude');
 
-    // Re-install to pick up content changes
     let totalFiles = 0;
     for (const targetName of targets) {
       const adapter = getAdapter(targetName);
@@ -38,7 +34,6 @@ export async function updateCommand(packName) {
       totalFiles += files.length;
     }
 
-    tracker = recordInstall(tracker, name, manifest.version, targets);
     updatedCount++;
 
     const versionChanged = info.version !== manifest.version;
@@ -48,10 +43,9 @@ export async function updateCommand(packName) {
 
     console.log(
       chalk.green(`  ~ ${name}@${label}`) +
-        chalk.gray(` (${totalFiles} rules)`)
+        chalk.gray(` (${totalFiles} files)`)
     );
   }
 
-  await saveTracker(projectDir, tracker);
   console.log(chalk.green(`\nUpdated ${updatedCount} pack(s).`));
 }

package/src/core/tracker.js

@@ -1,24 +1,38 @@
-import path from 'node:path';
-import { readFileContent, writeFileAtomic, fileExists } from '../utils/fs.js';
-
-const TRACKER_FILE = '.skillpool.json';
-
-function defaultTracker() {
-  return { version: '1.0.0', installed: {} };
-}
+import { getAdapter, getAllTargetNames } from '../adapters/index.js';
 
+/**
+ * Scan installed files across all adapters to build tracker state from markers.
+ * No .skillpool.json needed.
+ */
 export async function loadTracker(projectDir) {
-  const filePath = path.join(projectDir, TRACKER_FILE);
-  if (!(await fileExists(filePath))) {
-    return defaultTracker();
+  const installed = {};
+  const targetNames = getAllTargetNames();
+
+  for (const targetName of targetNames) {
+    const adapter = getAdapter(targetName);
+    try {
+      const items = await adapter.list(projectDir);
+      for (const item of items) {
+        if (!installed[item.pack]) {
+          installed[item.pack] = {
+            version: item.version,
+            targets: [],
+          };
+        }
+        if (!installed[item.pack].targets.includes(targetName)) {
+          installed[item.pack].targets.push(targetName);
+        }
+        // Use latest version found
+        if (item.version > installed[item.pack].version) {
+          installed[item.pack].version = item.version;
+        }
+      }
+    } catch {
+      // adapter dir doesn't exist, skip
+    }
   }
-  const content = await readFileContent(filePath);
-  return JSON.parse(content);
-}
 
-export async function saveTracker(projectDir, data) {
-  const filePath = path.join(projectDir, TRACKER_FILE);
-  await writeFileAtomic(filePath, JSON.stringify(data, null, 2) + '\n');
+  return { installed };
 }
 
 export function isInstalled(trackerData, packName) {
@@ -29,21 +43,6 @@ export function getInstalledVersion(trackerData, packName) {
   return trackerData.installed[packName]?.version || null;
 }
 
-export function recordInstall(trackerData, packName, version, targets) {
-  return {
-    ...trackerData,
-    installed: {
-      ...trackerData.installed,
-      [packName]: {
-        version,
-        installedAt: new Date().toISOString(),
-        targets,
-      },
-    },
-  };
-}
-
-export function recordRemove(trackerData, packName) {
-  const { [packName]: _, ...rest } = trackerData.installed;
-  return { ...trackerData, installed: rest };
+export function getInstalledTargets(trackerData, packName) {
+  return trackerData.installed[packName]?.targets || [];
 }