@alavida/agentpack 0.1.1 → 0.1.3

package/src/lib/skills.js

@@ -1,8 +1,35 @@
-import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, symlinkSync, watch, writeFileSync } from 'node:fs';
+import { existsSync, readFileSync, readdirSync, watch, writeFileSync } from 'node:fs';
 import { dirname, isAbsolute, join, relative, resolve } from 'node:path';
-import { createHash } from 'node:crypto';
 import { execFileSync } from 'node:child_process';
 import { findAllWorkbenches, findRepoRoot, findWorkbenchContext, resolveWorkbenchFlag } from './context.js';
+import {
+  buildReverseDependencies,
+  buildSkillGraph,
+  buildSkillStatusMap,
+  readNodeStatus,
+} from '../domain/skills/skill-graph.js';
+import { readInstallState } from '../infrastructure/fs/install-state-repository.js';
+import {
+  ensureSkillLink,
+  rebuildInstallState,
+  removePathIfExists,
+  removeSkillLinks,
+  removeSkillLinksByNames,
+} from '../infrastructure/runtime/materialize-skills.js';
+import {
+  normalizeDisplayPath,
+  normalizeRepoPath,
+  parseSkillFrontmatterFile,
+  readPackageMetadata,
+} from '../domain/skills/skill-model.js';
+import {
+  buildStateRecordForPackageDir,
+  compareRecordedSources,
+  hashFile,
+  readBuildState,
+  writeBuildState,
+} from '../domain/skills/skill-provenance.js';
+import { startSkillDevWorkbench } from '../application/skills/start-skill-dev-workbench.js';
 import { AgentpackError, EXIT_CODES, NetworkError, NotFoundError, ValidationError } from '../utils/errors.js';
 
 const GITHUB_PACKAGES_REGISTRY = 'https://npm.pkg.github.com';
@@ -17,173 +44,6 @@ function inferManagedScope(packageName) {
   return MANAGED_PACKAGE_SCOPES.find((scope) => packageName?.startsWith(`${scope}/`)) || null;
 }
 
-function parseScalar(value) {
-  const trimmed = value.trim();
-  if (
-    (trimmed.startsWith('"') && trimmed.endsWith('"')) ||
-    (trimmed.startsWith("'") && trimmed.endsWith("'"))
-  ) {
-    return trimmed.slice(1, -1);
-  }
-  return trimmed;
-}
-
-function foldBlockScalar(lines, startIndex, baseIndent) {
-  const values = [];
-  let index = startIndex + 1;
-
-  while (index < lines.length) {
-    const rawLine = lines[index];
-    if (!rawLine.trim()) {
-      values.push('');
-      index += 1;
-      continue;
-    }
-
-    const indentMatch = rawLine.match(/^(\s*)/);
-    const indent = indentMatch ? indentMatch[1].length : 0;
-    if (indent <= baseIndent) break;
-
-    values.push(rawLine.slice(baseIndent + 2).trimEnd());
-    index += 1;
-  }
-
-  const folded = values
-    .join('\n')
-    .split('\n\n')
-    .map((chunk) => chunk.split('\n').join(' ').trim())
-    .filter((chunk, idx, arr) => chunk.length > 0 || idx < arr.length - 1)
-    .join('\n\n')
-    .trim();
-
-  return { value: folded, nextIndex: index };
-}
-
-function ensureContainer(target, key) {
-  if (!target[key] || typeof target[key] !== 'object' || Array.isArray(target[key])) {
-    target[key] = {};
-  }
-  return target[key];
-}
-
-export function parseSkillFrontmatterFile(skillFilePath) {
-  if (!existsSync(skillFilePath)) {
-    throw new NotFoundError(`skill file not found: ${skillFilePath}`, { code: 'skill_not_found' });
-  }
-
-  const content = readFileSync(skillFilePath, 'utf-8');
-  if (!content.startsWith('---\n')) {
-    throw new ValidationError('SKILL.md missing frontmatter', { code: 'missing_frontmatter' });
-  }
-
-  const fmEnd = content.indexOf('\n---', 4);
-  if (fmEnd === -1) {
-    throw new ValidationError('SKILL.md has unclosed frontmatter', { code: 'unclosed_frontmatter' });
-  }
-
-  const lines = content.slice(4, fmEnd).split('\n');
-  const fields = {};
-  let activeArrayKey = null;
-  let activeArrayTarget = null;
-  let activeParentKey = null;
-
-  for (let index = 0; index < lines.length; index += 1) {
-    const rawLine = lines[index];
-    const line = rawLine.trimEnd();
-    if (!line.trim()) continue;
-
-    const listMatch = rawLine.match(/^(\s*)-\s+(.+)$/);
-    if (listMatch && activeArrayKey && activeArrayTarget) {
-      activeArrayTarget[activeArrayKey].push(parseScalar(listMatch[2]));
-      continue;
-    }
-
-    const nestedKeyMatch = rawLine.match(/^\s{2}([A-Za-z][\w-]*):\s*(.*)$/);
-    if (nestedKeyMatch && activeParentKey) {
-      const [, key, value] = nestedKeyMatch;
-      const parent = ensureContainer(fields, activeParentKey);
-      if (value === '') {
-        parent[key] = [];
-        activeArrayKey = key;
-        activeArrayTarget = parent;
-        continue;
-      }
-
-      parent[key] = parseScalar(value);
-      activeArrayKey = null;
-      activeArrayTarget = null;
-      continue;
-    }
-
-    const keyMatch = rawLine.match(/^([A-Za-z][\w-]*):\s*(.*)$/);
-    if (!keyMatch) continue;
-
-    const [, key, value] = keyMatch;
-    if (value === '>' || value === '|') {
-      const { value: blockValue, nextIndex } = foldBlockScalar(lines, index, 0);
-      fields[key] = blockValue;
-      activeParentKey = null;
-      activeArrayKey = null;
-      activeArrayTarget = null;
-      index = nextIndex - 1;
-      continue;
-    }
-
-    if (value === '') {
-      fields[key] = fields[key] && typeof fields[key] === 'object' && !Array.isArray(fields[key])
-        ? fields[key]
-        : [];
-      activeParentKey = key;
-      activeArrayKey = Array.isArray(fields[key]) ? key : null;
-      activeArrayTarget = Array.isArray(fields[key]) ? fields : null;
-      continue;
-    }
-
-    fields[key] = parseScalar(value);
-    activeParentKey = null;
-    activeArrayKey = null;
-    activeArrayTarget = null;
-  }
-
-  if (!fields.name) {
-    throw new ValidationError('SKILL.md frontmatter missing "name" field', { code: 'missing_name' });
-  }
-  if (!fields.description) {
-    throw new ValidationError('SKILL.md frontmatter missing "description" field', { code: 'missing_description' });
-  }
-
-  return {
-    name: fields.name,
-    description: fields.description,
-    sources: Array.isArray(fields.metadata?.sources)
-      ? fields.metadata.sources
-      : (Array.isArray(fields.sources) ? fields.sources : []),
-    requires: Array.isArray(fields.metadata?.requires)
-      ? fields.metadata.requires
-      : (Array.isArray(fields.requires) ? fields.requires : []),
-    status: typeof fields.metadata?.status === 'string' ? fields.metadata.status : null,
-    replacement: typeof fields.metadata?.replacement === 'string' ? fields.metadata.replacement : null,
-    message: typeof fields.metadata?.message === 'string' ? fields.metadata.message : null,
-  };
-}
-
-function normalizeDisplayPath(repoRoot, absolutePath) {
-  return relative(repoRoot, absolutePath).split('\\').join('/');
-}
-
-function ensureDir(pathValue) {
-  mkdirSync(pathValue, { recursive: true });
-}
-
-function ensureSkillLink(repoRoot, baseDir, skillName, skillDir) {
-  const skillsDir = join(repoRoot, baseDir, 'skills');
-  ensureDir(skillsDir);
-  const linkPath = join(skillsDir, skillName);
-  removePathIfExists(linkPath);
-  symlinkSync(skillDir, linkPath, 'dir');
-  return normalizeDisplayPath(repoRoot, linkPath);
-}
-
 function resolveDevLinkedSkills(repoRoot, rootSkillDir) {
   const queue = [rootSkillDir];
   const seenDirs = new Set();
@@ -296,32 +156,6 @@ export function findPackageDirByName(repoRoot, packageName) {
   return null;
 }
 
-export function readPackageMetadata(packageDir) {
-  const packageJsonPath = join(packageDir, 'package.json');
-  if (!existsSync(packageJsonPath)) {
-    return {
-      packageName: null,
-      packageVersion: null,
-      dependencies: {},
-      devDependencies: {},
-      files: null,
-      repository: null,
-      publishConfigRegistry: null,
-    };
-  }
-
-  const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
-  return {
-    packageName: pkg.name || null,
-    packageVersion: pkg.version || null,
-    dependencies: pkg.dependencies || {},
-    devDependencies: pkg.devDependencies || {},
-    files: Array.isArray(pkg.files) ? pkg.files : null,
-    repository: pkg.repository || null,
-    publishConfigRegistry: pkg.publishConfig?.registry || null,
-  };
-}
-
 function readPackageJson(packageDir) {
   const packageJsonPath = join(packageDir, 'package.json');
   if (!existsSync(packageJsonPath)) {
@@ -398,8 +232,8 @@ export function devSkill(target, {
     const links = [];
 
     for (const linkedSkill of linkedSkills) {
-      links.push(ensureSkillLink(repoRoot, '.claude', linkedSkill.name, linkedSkill.skillDir));
-      links.push(ensureSkillLink(repoRoot, '.agents', linkedSkill.name, linkedSkill.skillDir));
+      links.push(ensureSkillLink(repoRoot, '.claude', linkedSkill.name, linkedSkill.skillDir, normalizeDisplayPath));
+      links.push(ensureSkillLink(repoRoot, '.agents', linkedSkill.name, linkedSkill.skillDir, normalizeDisplayPath));
     }
 
     return {
@@ -427,46 +261,30 @@ export function devSkill(target, {
   }
 }
 
-function removeSkillLinks(repoRoot, name) {
-  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;
-}
-
-function removeSkillLinksByNames(repoRoot, names) {
-  const removed = [];
-  for (const name of names) {
-    removed.push(...removeSkillLinks(repoRoot, name));
-  }
-  return [...new Set(removed)];
-}
-
 export function startSkillDev(target, {
   cwd = process.cwd(),
   sync = true,
+  dashboard = true,
   onStart = () => {},
   onRebuild = () => {},
 } = {}) {
-  const repoRoot = findRepoRoot(cwd);
-  const { skillDir } = resolveLocalPackagedSkillDir(repoRoot, target);
+  const outerRepoRoot = findRepoRoot(cwd);
+  const { skillDir } = resolveLocalPackagedSkillDir(outerRepoRoot, target);
+  const repoRoot = findRepoRoot(skillDir);
   let closed = false;
   let timer = null;
   let currentNames = [];
   let watcher = null;
+  let workbench = null;
+  let initialResult = null;
 
   const cleanup = () => {
     if (closed) return { name: currentNames[0] || null, unlinked: false, removed: [] };
     closed = true;
     clearTimeout(timer);
     if (watcher) watcher.close();
-    const removed = removeSkillLinksByNames(repoRoot, currentNames);
+    if (workbench) workbench.close();
+    const removed = removeSkillLinksByNames(repoRoot, currentNames, normalizeDisplayPath);
     detachProcessCleanup();
     return {
       name: currentNames[0] || null,
@@ -493,19 +311,56 @@ export function startSkillDev(target, {
     processCleanupHandlers.clear();
   };
 
-  const run = () => {
-    const result = devSkill(target, { cwd, sync });
+  const enrichResult = (result) => ({
+    ...result,
+    workbench: workbench
+      ? {
+        enabled: true,
+        url: workbench.url,
+        port: workbench.port,
+      }
+      : {
+        enabled: false,
+        url: null,
+        port: null,
+      },
+  });
+
+  const applyDevResult = (result) => {
     const nextNames = result.linkedSkills.map((entry) => entry.name);
     const staleNames = currentNames.filter((name) => !nextNames.includes(name));
     if (staleNames.length > 0) {
-      removeSkillLinksByNames(repoRoot, staleNames);
+      removeSkillLinksByNames(repoRoot, staleNames, normalizeDisplayPath);
     }
     currentNames = nextNames;
     return result;
   };
 
-  const initialResult = run();
-  onStart(initialResult);
+  const startOrRefreshWorkbench = async () => {
+    if (dashboard && !workbench) {
+      workbench = await startSkillDevWorkbench({
+        repoRoot,
+        skillDir,
+        open: true,
+        disableBrowser: process.env.AGENTPACK_DISABLE_BROWSER === '1',
+      });
+    } else if (workbench) {
+      workbench.refresh();
+    }
+  };
+
+  initialResult = enrichResult(applyDevResult(devSkill(target, { cwd, sync })));
+  const ready = Promise.resolve(startOrRefreshWorkbench())
+    .then(() => {
+      const result = enrichResult(initialResult);
+      initialResult = result;
+      onStart(result);
+      return result;
+    })
+    .catch((error) => {
+      cleanup();
+      throw error;
+    });
 
   attachProcessCleanup();
 
@@ -513,17 +368,22 @@ export function startSkillDev(target, {
     if (closed) return;
     clearTimeout(timer);
     timer = setTimeout(() => {
-      try {
-        const result = run();
-        onRebuild(result);
-      } catch (error) {
-        onRebuild({ error });
-      }
+      Promise.resolve()
+        .then(() => applyDevResult(devSkill(target, { cwd, sync })))
+        .then(async (result) => {
+          await startOrRefreshWorkbench();
+          return enrichResult(result);
+        })
+        .then(onRebuild)
+        .catch((error) => {
+          onRebuild({ error });
+        });
     }, 100);
   });
 
   return {
     initialResult,
+    ready,
     close() {
       return cleanup();
     },
@@ -544,7 +404,7 @@ export function unlinkSkill(name, { cwd = process.cwd() } = {}) {
     });
   }
 
-  const removed = removeSkillLinks(repoRoot, name);
+  const removed = removeSkillLinks(repoRoot, name, normalizeDisplayPath);
 
   return {
     name,
@@ -553,10 +413,6 @@ export function unlinkSkill(name, { cwd = process.cwd() } = {}) {
   };
 }
 
-export function normalizeRepoPath(repoRoot, absolutePath) {
-  return normalizeDisplayPath(repoRoot, absolutePath);
-}
-
 function buildValidateNextSteps(packageMetadata, valid) {
   if (!valid || !packageMetadata.packageName) return [];
 
@@ -737,48 +593,16 @@ export function inspectSkill(target, { cwd = process.cwd() } = {}) {
   };
 }
 
-function readSkillGraphNode(repoRoot, packageDir, directInstallNames = new Set()) {
-  const skillFile = join(packageDir, 'SKILL.md');
-  if (!existsSync(skillFile)) return null;
-
-  const skillMetadata = parseSkillFrontmatterFile(skillFile);
-  const packageMetadata = readPackageMetadata(packageDir);
-  if (!packageMetadata.packageName) return null;
-
-  const dependencyNames = Object.keys(packageMetadata.dependencies || {})
-    .filter((dependencyName) => {
-      const localPackageDir = findPackageDirByName(repoRoot, dependencyName);
-      if (localPackageDir && existsSync(join(localPackageDir, 'SKILL.md'))) return true;
-      const installedPackageDir = join(repoRoot, 'node_modules', ...dependencyName.split('/'));
-      return existsSync(join(installedPackageDir, 'SKILL.md'));
-    })
-    .sort((a, b) => a.localeCompare(b));
-
-  return {
-    name: skillMetadata.name,
-    packageName: packageMetadata.packageName,
-    packageVersion: packageMetadata.packageVersion,
-    skillPath: normalizeDisplayPath(repoRoot, packageDir),
-    skillFile: normalizeDisplayPath(repoRoot, skillFile),
-    direct: directInstallNames.has(packageMetadata.packageName),
-    dependencies: dependencyNames,
-  };
-}
-
 function buildAuthoredSkillGraph(repoRoot) {
-  const nodes = new Map();
-
-  for (const packageDir of listPackagedSkillDirs(repoRoot)) {
-    const node = readSkillGraphNode(repoRoot, packageDir);
-    if (!node) continue;
-    nodes.set(node.packageName, node);
-  }
-
-  return nodes;
+  return buildSkillGraph(repoRoot, listPackagedSkillDirs(repoRoot), {
+    parseSkillFrontmatterFile,
+    readPackageMetadata,
+    findPackageDirByName,
+    normalizeDisplayPath,
+  });
 }
 
 function buildInstalledSkillGraph(repoRoot) {
-  const nodes = new Map();
   const installState = readInstallState(repoRoot);
   const directInstallNames = new Set(
     Object.entries(installState.installs || {})
@@ -786,73 +610,19 @@ function buildInstalledSkillGraph(repoRoot) {
       .map(([packageName]) => packageName)
   );
 
-  for (const packageDir of listInstalledPackageDirs(join(repoRoot, 'node_modules'))) {
-    const node = readSkillGraphNode(repoRoot, packageDir, directInstallNames);
-    if (!node) continue;
-    nodes.set(node.packageName, node);
-  }
-
-  return nodes;
-}
-
-function buildReverseDependencies(nodes) {
-  const reverse = new Map();
-  for (const packageName of nodes.keys()) reverse.set(packageName, []);
-
-  for (const node of nodes.values()) {
-    for (const dependencyName of node.dependencies) {
-      if (!reverse.has(dependencyName)) continue;
-      reverse.get(dependencyName).push(node.packageName);
-    }
-  }
-
-  for (const values of reverse.values()) values.sort((a, b) => a.localeCompare(b));
-  return reverse;
+  return buildSkillGraph(repoRoot, listInstalledPackageDirs(join(repoRoot, 'node_modules')), {
+    directInstallNames,
+    parseSkillFrontmatterFile,
+    readPackageMetadata,
+    findPackageDirByName,
+    normalizeDisplayPath,
+  });
 }
 
-function buildSkillStatusMap(repoRoot) {
+function buildSkillStatusMapForRepo(repoRoot) {
   const nodes = buildAuthoredSkillGraph(repoRoot);
   const staleSkills = new Set(listStaleSkills({ cwd: repoRoot }).map((skill) => skill.packageName));
-  const cache = new Map();
-
-  function resolveStatus(packageName, seen = new Set()) {
-    if (cache.has(packageName)) return cache.get(packageName);
-    if (staleSkills.has(packageName)) {
-      cache.set(packageName, 'stale');
-      return 'stale';
-    }
-
-    if (seen.has(packageName)) return 'current';
-    seen.add(packageName);
-
-    const node = nodes.get(packageName);
-    if (!node) {
-      cache.set(packageName, null);
-      return null;
-    }
-
-    const dependencyStatuses = node.dependencies
-      .map((dependencyName) => resolveStatus(dependencyName, new Set(seen)))
-      .filter(Boolean);
-
-    const status = dependencyStatuses.some((value) => value === 'stale' || value === 'affected')
-      ? 'affected'
-      : 'current';
-
-    cache.set(packageName, status);
-    return status;
-  }
-
-  for (const packageName of nodes.keys()) {
-    resolveStatus(packageName);
-  }
-
-  return cache;
-}
-
-function readNodeStatus(statusMap, packageName) {
-  if (!statusMap) return null;
-  return statusMap.get(packageName) || null;
+  return buildSkillStatusMap(nodes, staleSkills);
 }
 
 export function inspectSkillDependencies(target, {
@@ -863,7 +633,7 @@ export function inspectSkillDependencies(target, {
   const authoredNodes = buildAuthoredSkillGraph(repoRoot);
   const installedNodes = buildInstalledSkillGraph(repoRoot);
   const statusRoot = discoveryRoot ? resolve(discoveryRoot) : repoRoot;
-  const statusMap = buildSkillStatusMap(statusRoot);
+  const statusMap = buildSkillStatusMapForRepo(statusRoot);
 
   const authoredTarget = authoredNodes.get(target) || null;
   const installedTarget = installedNodes.get(target) || null;
@@ -1086,6 +856,26 @@ export function validateSkills(target, { cwd = process.cwd() } = {}) {
   const validCount = skills.filter((skill) => skill.valid).length;
   const invalidCount = skills.length - validCount;
 
+  if (validCount > 0) {
+    const buildState = readBuildState(repoRoot);
+
+    for (const packageDir of packageDirs) {
+      const packageMetadata = readPackageMetadata(packageDir);
+      const result = skills.find((skill) => skill.packageName === packageMetadata.packageName);
+      if (!result?.valid) continue;
+
+      const { packageName, record } = buildStateRecordForPackageDir(repoRoot, packageDir, {
+        parseSkillFrontmatterFile,
+        readPackageMetadata,
+        normalizeDisplayPath,
+      });
+      if (!packageName) continue;
+      buildState.skills[packageName] = record;
+    }
+
+    writeBuildState(repoRoot, buildState);
+  }
+
   return {
     valid: invalidCount === 0,
     count: skills.length,
@@ -1094,67 +884,16 @@ export function validateSkills(target, { cwd = process.cwd() } = {}) {
     skills,
   };
 }
-
-
-function hashFile(filePath) {
-  const digest = createHash('sha256').update(readFileSync(filePath)).digest('hex');
-  return `sha256:${digest}`;
-}
-
 function normalizeRelativePath(pathValue) {
   return pathValue.split('\\').join('/');
 }
 
-function readBuildState(repoRoot) {
-  const buildStatePath = join(repoRoot, '.agentpack', 'build-state.json');
-  if (!existsSync(buildStatePath)) {
-    return { version: 1, skills: {} };
-  }
-
-  return JSON.parse(readFileSync(buildStatePath, 'utf-8'));
-}
-
-function readInstallState(repoRoot) {
-  const installStatePath = join(repoRoot, '.agentpack', 'install.json');
-  if (!existsSync(installStatePath)) {
-    return { version: 1, installs: {} };
-  }
-
-  return JSON.parse(readFileSync(installStatePath, 'utf-8'));
-}
-
-function writeInstallState(repoRoot, state) {
-  mkdirSync(join(repoRoot, '.agentpack'), { recursive: true });
-  writeFileSync(join(repoRoot, '.agentpack', 'install.json'), JSON.stringify(state, null, 2) + '\n');
-}
-
 function normalizeRequestedTarget(target, cwd = process.cwd()) {
   if (typeof target !== 'string') return target;
   if (target.startsWith('@')) return target;
   return normalizeRelativePath(resolve(cwd, target));
 }
 
-function compareRecordedSources(repoRoot, record) {
-  const changes = [];
-  const recordedSources = record.sources || {};
-
-  for (const [sourcePath, sourceRecord] of Object.entries(recordedSources)) {
-    const absoluteSourcePath = join(repoRoot, sourcePath);
-    const currentHash = hashFile(absoluteSourcePath);
-    const recordedHash = sourceRecord.hash;
-
-    if (currentHash !== recordedHash) {
-      changes.push({
-        path: sourcePath,
-        recorded: recordedHash,
-        current: currentHash,
-      });
-    }
-  }
-
-  return changes;
-}
-
 function listPackagedSkillDirs(repoRoot) {
   const stack = [repoRoot];
   const results = [];
@@ -1387,73 +1126,6 @@ function resolveNpmInstallTargets(directTargetMap) {
   return [...new Set(npmInstallTargets)];
 }
 
-function ensureSymlink(targetPath, linkPath) {
-  rmSync(linkPath, { recursive: true, force: true });
-  mkdirSync(dirname(linkPath), { recursive: true });
-  symlinkSync(targetPath, linkPath, 'dir');
-}
-
-function removePathIfExists(pathValue) {
-  rmSync(pathValue, { recursive: true, force: true });
-}
-
-function buildInstallRecord(repoRoot, packageDir, directTargetMap) {
-  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,
-  };
-}
-
-function rebuildInstallState(repoRoot, directTargetMap) {
-  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);
-    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;
-}
-
 export function installSkills(targets, { cwd = process.cwd() } = {}) {
   const repoRoot = findRepoRoot(cwd);
   const previousState = readInstallState(repoRoot);
@@ -1493,7 +1165,12 @@ export function installSkills(targets, { cwd = process.cwd() } = {}) {
     stdio: ['pipe', 'pipe', 'pipe'],
   });
 
-  return rebuildInstallState(repoRoot, directTargetMap);
+  return rebuildInstallState(repoRoot, directTargetMap, {
+    listInstalledPackageDirs,
+    parseSkillFrontmatterFile,
+    readPackageMetadata,
+    normalizeRelativePath,
+  });
 }
 
 export function inspectSkillsEnv({ cwd = process.cwd() } = {}) {
@@ -1809,7 +1486,12 @@ export function uninstallSkills(target, { cwd = process.cwd() } = {}) {
     });
   }
 
-  const nextState = rebuildInstallState(repoRoot, nextDirectTargetMap);
+  const nextState = rebuildInstallState(repoRoot, nextDirectTargetMap, {
+    listInstalledPackageDirs,
+    parseSkillFrontmatterFile,
+    readPackageMetadata,
+    normalizeRelativePath,
+  });
   const remainingTargets = new Set(
     Object.values(nextState.installs)
       .flatMap((install) => (install.materializations || []).map((entry) => entry.target))