@alavida/agentpack 0.1.1 → 0.1.2

package/src/infrastructure/runtime/materialize-skills.js

@@ -0,0 +1,117 @@
+import { existsSync, mkdirSync, rmSync, symlinkSync } from 'node:fs';
+import { dirname, join, relative } from 'node:path';
+import { writeInstallState } from '../fs/install-state-repository.js';
+
+function ensureDir(pathValue) {
+  mkdirSync(pathValue, { recursive: true });
+}
+
+export function removePathIfExists(pathValue) {
+  rmSync(pathValue, { recursive: true, force: true });
+}
+
+export function ensureSkillLink(repoRoot, baseDir, skillName, skillDir, normalizeDisplayPath) {
+  const skillsDir = join(repoRoot, baseDir, 'skills');
+  ensureDir(skillsDir);
+  const linkPath = join(skillsDir, skillName);
+  removePathIfExists(linkPath);
+  symlinkSync(skillDir, linkPath, 'dir');
+  return normalizeDisplayPath(repoRoot, linkPath);
+}
+
+export function removeSkillLinks(repoRoot, name, normalizeDisplayPath) {
+  const removed = [];
+  for (const pathValue of [
+    join(repoRoot, '.claude', 'skills', name),
+    join(repoRoot, '.agents', 'skills', name),
+  ]) {
+    if (!existsSync(pathValue)) continue;
+    removePathIfExists(pathValue);
+    removed.push(normalizeDisplayPath(repoRoot, pathValue));
+  }
+  return removed;
+}
+
+export function removeSkillLinksByNames(repoRoot, names, normalizeDisplayPath) {
+  const removed = [];
+  for (const name of names) {
+    removed.push(...removeSkillLinks(repoRoot, name, normalizeDisplayPath));
+  }
+  return [...new Set(removed)];
+}
+
+function ensureSymlink(targetPath, linkPath) {
+  removePathIfExists(linkPath);
+  mkdirSync(dirname(linkPath), { recursive: true });
+  symlinkSync(targetPath, linkPath, 'dir');
+}
+
+export function buildInstallRecord(repoRoot, packageDir, directTargetMap, {
+  parseSkillFrontmatterFile,
+  readPackageMetadata,
+  normalizeRelativePath,
+} = {}) {
+  const packageMetadata = readPackageMetadata(packageDir);
+  if (!packageMetadata.packageName) return null;
+
+  const skillMetadata = parseSkillFrontmatterFile(join(packageDir, 'SKILL.md'));
+  const skillDirName = skillMetadata.name;
+  const materializations = [];
+
+  const claudeTargetAbs = join(repoRoot, '.claude', 'skills', skillDirName);
+  ensureSymlink(packageDir, claudeTargetAbs);
+  materializations.push({
+    target: normalizeRelativePath(relative(repoRoot, claudeTargetAbs)),
+    mode: 'symlink',
+  });
+
+  const agentsTargetAbs = join(repoRoot, '.agents', 'skills', skillDirName);
+  ensureSymlink(packageDir, agentsTargetAbs);
+  materializations.push({
+    target: normalizeRelativePath(relative(repoRoot, agentsTargetAbs)),
+    mode: 'symlink',
+  });
+
+  return {
+    packageName: packageMetadata.packageName,
+    direct: directTargetMap.has(packageMetadata.packageName),
+    requestedTarget: directTargetMap.get(packageMetadata.packageName) || null,
+    packageVersion: packageMetadata.packageVersion,
+    sourcePackagePath: normalizeRelativePath(relative(repoRoot, packageDir)),
+    materializations,
+  };
+}
+
+export function rebuildInstallState(repoRoot, directTargetMap, {
+  listInstalledPackageDirs,
+  parseSkillFrontmatterFile,
+  readPackageMetadata,
+  normalizeRelativePath,
+} = {}) {
+  const packageDirs = listInstalledPackageDirs(join(repoRoot, 'node_modules'));
+  const installs = {};
+
+  for (const packageDir of packageDirs) {
+    const skillFile = join(packageDir, 'SKILL.md');
+    if (!existsSync(skillFile)) continue;
+
+    const record = buildInstallRecord(repoRoot, packageDir, directTargetMap, {
+      parseSkillFrontmatterFile,
+      readPackageMetadata,
+      normalizeRelativePath,
+    });
+    if (!record) continue;
+
+    installs[record.packageName] = {
+      direct: record.direct,
+      requested_target: record.requestedTarget,
+      package_version: record.packageVersion,
+      source_package_path: record.sourcePackagePath,
+      materializations: record.materializations,
+    };
+  }
+
+  const state = { version: 1, installs };
+  writeInstallState(repoRoot, state);
+  return state;
+}

package/src/infrastructure/runtime/watch-tree.js

@@ -0,0 +1,44 @@
+import { existsSync, readdirSync, watch } from 'node:fs';
+import { join } from 'node:path';
+
+export function watchDirectoryTree(rootDir, onChange) {
+  const watchers = new Map();
+
+  const watchDir = (dirPath) => {
+    if (watchers.has(dirPath) || !existsSync(dirPath)) return;
+
+    let entries = [];
+    try {
+      entries = readdirSync(dirPath, { withFileTypes: true });
+    } catch {
+      return;
+    }
+
+    const watcher = watch(dirPath, (_eventType, filename) => {
+      if (filename) {
+        const changedPath = join(dirPath, String(filename));
+        if (existsSync(changedPath)) {
+          watchDir(changedPath);
+        }
+      }
+
+      onChange();
+    });
+
+    watchers.set(dirPath, watcher);
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      watchDir(join(dirPath, entry.name));
+    }
+  };
+
+  watchDir(rootDir);
+
+  return {
+    close() {
+      for (const watcher of watchers.values()) watcher.close();
+      watchers.clear();
+    },
+  };
+}

package/src/lib/plugins.js

@@ -1,11 +1,11 @@
-import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, watch, writeFileSync } from 'node:fs';
+import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { createRequire } from 'node:module';
+import { resolveDependencyClosure } from '../domain/skills/skill-graph.js';
+import { normalizeRepoPath, parseSkillFrontmatterFile, readPackageMetadata } from '../domain/skills/skill-model.js';
+import { watchDirectoryTree } from '../infrastructure/runtime/watch-tree.js';
 import {
   findPackageDirByName,
-  normalizeRepoPath,
-  parseSkillFrontmatterFile,
-  readPackageMetadata,
   syncSkillDependencies,
 } from './skills.js';
 import { findRepoRoot } from './context.js';
@@ -76,50 +76,30 @@ function collectPluginLocalSkillDirs(pluginDir) {
 }
 
 function resolveBundleClosure(repoRoot, pluginDir, directRequires) {
-  const seen = new Set();
-  const queue = [...directRequires];
-  const bundled = [];
-  const unresolved = [];
-
-  while (queue.length > 0) {
-    const packageName = queue.shift();
-    if (seen.has(packageName)) continue;
-    seen.add(packageName);
-
-    const resolvedPackage = resolvePackageDir(repoRoot, pluginDir, packageName);
-    if (!resolvedPackage) {
-      unresolved.push(packageName);
-      continue;
-    }
-
-    const skillFile = join(resolvedPackage.packageDir, 'SKILL.md');
-    if (!existsSync(skillFile)) {
-      unresolved.push(packageName);
-      continue;
-    }
-
-    const metadata = parseSkillFrontmatterFile(skillFile);
-    const packageMetadata = readPackageMetadata(resolvedPackage.packageDir);
-
-    bundled.push({
-      packageName,
-      packageVersion: packageMetadata.packageVersion,
-      skillName: metadata.name,
-      skillFile,
-      packageDir: resolvedPackage.packageDir,
-      source: resolvedPackage.source,
-      requires: metadata.requires,
-    });
-
-    for (const requirement of metadata.requires) {
-      if (!seen.has(requirement)) queue.push(requirement);
-    }
-  }
-
-  bundled.sort((a, b) => a.packageName.localeCompare(b.packageName));
-  unresolved.sort();
+  const { resolved, unresolved } = resolveDependencyClosure(directRequires, {
+    resolveNode(packageName) {
+      const resolvedPackage = resolvePackageDir(repoRoot, pluginDir, packageName);
+      if (!resolvedPackage) return null;
+
+      const skillFile = join(resolvedPackage.packageDir, 'SKILL.md');
+      if (!existsSync(skillFile)) return null;
+
+      const metadata = parseSkillFrontmatterFile(skillFile);
+      const packageMetadata = readPackageMetadata(resolvedPackage.packageDir);
+
+      return {
+        packageName,
+        packageVersion: packageMetadata.packageVersion,
+        skillName: metadata.name,
+        skillFile,
+        packageDir: resolvedPackage.packageDir,
+        source: resolvedPackage.source,
+        requires: metadata.requires,
+      };
+    },
+  });
 
-  return { bundled, unresolved };
+  return { bundled: resolved, unresolved };
 }
 
 function stagePluginRuntimeFiles(pluginDir, stageDir) {
@@ -130,48 +110,6 @@ function stagePluginRuntimeFiles(pluginDir, stageDir) {
   }
 }
 
-function watchDirectoryTree(rootDir, onChange) {
-  const watchers = new Map();
-
-  const watchDir = (dirPath) => {
-    if (watchers.has(dirPath) || !existsSync(dirPath)) return;
-
-    let entries = [];
-    try {
-      entries = readdirSync(dirPath, { withFileTypes: true });
-    } catch {
-      return;
-    }
-
-    const watcher = watch(dirPath, (_eventType, filename) => {
-      if (filename) {
-        const changedPath = join(dirPath, String(filename));
-        if (existsSync(changedPath)) {
-          watchDir(changedPath);
-        }
-      }
-
-      onChange();
-    });
-
-    watchers.set(dirPath, watcher);
-
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      watchDir(join(dirPath, entry.name));
-    }
-  };
-
-  watchDir(rootDir);
-
-  return {
-    close() {
-      for (const watcher of watchers.values()) watcher.close();
-      watchers.clear();
-    },
-  };
-}
-
 export function buildPlugin(target, {
   cwd = process.cwd(),
   clean = false,