@alavida/agentpack 0.1.5 → 0.1.6

package/src/infrastructure/fs/user-npmrc-repository.js

@@ -0,0 +1,74 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+export function parseNpmrc(content) {
+  const config = {};
+  for (const rawLine of content.split('\n')) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith('#') || line.startsWith(';')) continue;
+    const eqIndex = line.indexOf('=');
+    if (eqIndex === -1) continue;
+    const key = line.slice(0, eqIndex).trim();
+    const value = line.slice(eqIndex + 1).trim();
+    config[key] = value;
+  }
+  return config;
+}
+
+export function getUserNpmrcPath({ env = process.env } = {}) {
+  return join(env.HOME || homedir(), '.npmrc');
+}
+
+export function readUserNpmrc({ env = process.env } = {}) {
+  const npmrcPath = getUserNpmrcPath({ env });
+  if (!existsSync(npmrcPath)) return {};
+  return parseNpmrc(readFileSync(npmrcPath, 'utf-8'));
+}
+
+function upsertLine(lines, key, value) {
+  const prefix = `${key}=`;
+  const nextLine = `${key}=${value}`;
+  const index = lines.findIndex((line) => line.trim().startsWith(prefix));
+  if (index === -1) {
+    lines.push(nextLine);
+    return;
+  }
+  lines[index] = nextLine;
+}
+
+function removeLine(lines, key) {
+  const prefix = `${key}=`;
+  return lines.filter((line) => !line.trim().startsWith(prefix));
+}
+
+export function writeManagedNpmrcEntries({
+  entries,
+  env = process.env,
+} = {}) {
+  const npmrcPath = getUserNpmrcPath({ env });
+  const lines = existsSync(npmrcPath)
+    ? readFileSync(npmrcPath, 'utf-8').split('\n').filter((line, index, all) => !(index === all.length - 1 && line === ''))
+    : [];
+
+  for (const [key, value] of Object.entries(entries)) {
+    upsertLine(lines, key, value);
+  }
+
+  writeFileSync(npmrcPath, `${lines.join('\n')}\n`);
+}
+
+export function removeManagedNpmrcEntries({
+  keys,
+  env = process.env,
+} = {}) {
+  const npmrcPath = getUserNpmrcPath({ env });
+  if (!existsSync(npmrcPath)) return;
+
+  let lines = readFileSync(npmrcPath, 'utf-8').split('\n').filter((line, index, all) => !(index === all.length - 1 && line === ''));
+  for (const key of keys) {
+    lines = removeLine(lines, key);
+  }
+
+  writeFileSync(npmrcPath, `${lines.join('\n')}\n`);
+}

package/src/infrastructure/runtime/inspect-materialized-skills.js

@@ -0,0 +1,153 @@
+import { lstatSync, readlinkSync, readdirSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { readDevSession } from '../fs/dev-session-repository.js';
+
+function readPathType(pathValue) {
+  try {
+    const stat = lstatSync(pathValue);
+    return {
+      exists: true,
+      isSymlink: stat.isSymbolicLink(),
+      type: stat.isDirectory() ? 'directory' : stat.isFile() ? 'file' : 'other',
+    };
+  } catch {
+    return {
+      exists: false,
+      isSymlink: false,
+      type: null,
+    };
+  }
+}
+
+export function inspectRecordedMaterialization(repoRoot, {
+  target,
+  expectedSourcePath,
+  packageName,
+  runtimeName = null,
+} = {}) {
+  const absTarget = resolve(repoRoot, target);
+  const expectedTarget = resolve(repoRoot, expectedSourcePath);
+  const pathState = readPathType(absTarget);
+
+  if (!pathState.exists) {
+    return {
+      packageName,
+      runtimeName,
+      target,
+      expectedSourcePath,
+      code: 'missing_path',
+    };
+  }
+
+  if (!pathState.isSymlink) {
+    return {
+      packageName,
+      runtimeName,
+      target,
+      expectedSourcePath,
+      code: 'wrong_type',
+      actualType: pathState.type,
+    };
+  }
+
+  const rawLinkTarget = readlinkSync(absTarget);
+  const actualTarget = resolve(join(absTarget, '..'), rawLinkTarget);
+  if (actualTarget !== expectedTarget) {
+    return {
+      packageName,
+      runtimeName,
+      target,
+      expectedSourcePath,
+      code: 'wrong_target',
+      actualTarget,
+    };
+  }
+
+  const resolvedState = readPathType(actualTarget);
+  if (!resolvedState.exists) {
+    return {
+      packageName,
+      runtimeName,
+      target,
+      expectedSourcePath,
+      code: 'dangling_target',
+      actualTarget,
+    };
+  }
+
+  return null;
+}
+
+export function inspectMaterializedSkills(repoRoot, state) {
+  const runtimeDrift = [];
+  const ownedTargets = new Set();
+  const devSession = readDevSession(repoRoot);
+
+  if (devSession?.status === 'active') {
+    for (const target of devSession.links || []) {
+      ownedTargets.add(target);
+    }
+  }
+
+  for (const [packageName, install] of Object.entries(state.installs || {})) {
+    const issues = [];
+
+    for (const skill of install.skills || []) {
+      for (const materialization of skill.materializations || []) {
+        ownedTargets.add(materialization.target);
+        const issue = inspectRecordedMaterialization(repoRoot, {
+          target: materialization.target,
+          expectedSourcePath: skill.source_skill_path,
+          packageName,
+          runtimeName: skill.runtime_name,
+        });
+        if (issue) issues.push(issue);
+      }
+    }
+
+    if (issues.length > 0) {
+      runtimeDrift.push({
+        packageName,
+        issues,
+      });
+    }
+  }
+
+  const orphanedMaterializations = [];
+  for (const root of [
+    join(repoRoot, '.claude', 'skills'),
+    join(repoRoot, '.agents', 'skills'),
+  ]) {
+    let entries = [];
+    try {
+      entries = readdirSync(root, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      const relativeTarget = root.startsWith(join(repoRoot, '.claude'))
+        ? `.claude/skills/${entry.name}`
+        : `.agents/skills/${entry.name}`;
+      if (ownedTargets.has(relativeTarget)) continue;
+
+      const absPath = join(root, entry.name);
+      const pathState = readPathType(absPath);
+      orphanedMaterializations.push({
+        target: relativeTarget,
+        code: 'orphaned_materialization',
+        actualType: pathState.isSymlink ? 'symlink' : pathState.type,
+      });
+    }
+  }
+
+  runtimeDrift.sort((a, b) => a.packageName.localeCompare(b.packageName));
+  orphanedMaterializations.sort((a, b) => a.target.localeCompare(b.target));
+
+  return {
+    runtimeDriftCount: runtimeDrift.length,
+    runtimeDrift,
+    orphanedMaterializationCount: orphanedMaterializations.length,
+    orphanedMaterializations,
+  };
+}

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

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, rmSync, symlinkSync } from 'node:fs';
+import { existsSync, lstatSync, mkdirSync, rmSync, symlinkSync, unlinkSync } from 'node:fs';
 import { dirname, join, relative, resolve } from 'node:path';
 import { writeInstallState } from '../fs/install-state-repository.js';
 
@@ -7,7 +7,17 @@ function ensureDir(pathValue) {
 }
 
 export function removePathIfExists(pathValue) {
-  rmSync(pathValue, { recursive: true, force: true });
+  try {
+    const stat = lstatSync(pathValue);
+    if (stat.isSymbolicLink() || stat.isFile()) {
+      unlinkSync(pathValue);
+      return;
+    }
+    rmSync(pathValue, { recursive: true, force: true });
+  } catch (error) {
+    if (error?.code === 'ENOENT') return;
+    throw error;
+  }
 }
 
 export function ensureSkillLink(repoRoot, baseDir, skillName, skillDir, normalizeDisplayPath) {
@@ -25,9 +35,13 @@ export function removeSkillLinks(repoRoot, name, normalizeDisplayPath) {
     join(repoRoot, '.claude', 'skills', name),
     join(repoRoot, '.agents', 'skills', name),
   ]) {
-    if (!existsSync(pathValue)) continue;
-    removePathIfExists(pathValue);
-    removed.push(normalizeDisplayPath(repoRoot, pathValue));
+    try {
+      removePathIfExists(pathValue);
+      removed.push(normalizeDisplayPath(repoRoot, pathValue));
+    } catch (error) {
+      if (error?.code === 'ENOENT') continue;
+      throw error;
+    }
   }
   return removed;
 }
@@ -50,9 +64,13 @@ export function removeSkillLinksByPaths(repoRoot, paths, normalizeDisplayPath) {
     const pathValue = resolve(repoRoot, relativePath);
     const inAllowedRoot = allowedRoots.some((root) => pathValue === root || pathValue.startsWith(`${root}/`));
     if (!inAllowedRoot) continue;
-    if (!existsSync(pathValue)) continue;
-    removePathIfExists(pathValue);
-    removed.push(normalizeDisplayPath(repoRoot, pathValue));
+    try {
+      removePathIfExists(pathValue);
+      removed.push(normalizeDisplayPath(repoRoot, pathValue));
+    } catch (error) {
+      if (error?.code === 'ENOENT') continue;
+      throw error;
+    }
   }
   return [...new Set(removed)];
 }
@@ -63,31 +81,62 @@ function ensureSymlink(targetPath, linkPath) {
   symlinkSync(targetPath, linkPath, 'dir');
 }
 
+function inferPackageRuntimeNamespace(packageName) {
+  return packageName?.split('/').pop() || null;
+}
+
+function buildRuntimeName(packageName, exportedSkills, entry) {
+  if (exportedSkills.length <= 1) return entry.name;
+
+  const namespace = inferPackageRuntimeNamespace(packageName);
+  if (!namespace) return entry.name;
+  if (entry.name === namespace) return namespace;
+  return `${namespace}:${entry.name}`;
+}
+
 export function buildInstallRecord(repoRoot, packageDir, directTargetMap, {
-  parseSkillFrontmatterFile,
   readPackageMetadata,
+  readInstalledSkillExports,
   normalizeRelativePath,
 } = {}) {
   const packageMetadata = readPackageMetadata(packageDir);
   if (!packageMetadata.packageName) return null;
-
-  const skillMetadata = parseSkillFrontmatterFile(join(packageDir, 'SKILL.md'));
-  const skillDirName = skillMetadata.name;
+  const exportedSkills = readInstalledSkillExports(packageDir);
+  if (exportedSkills.length === 0) return null;
   const materializations = [];
+  const skills = [];
 
-  const claudeTargetAbs = join(repoRoot, '.claude', 'skills', skillDirName);
-  ensureSymlink(packageDir, claudeTargetAbs);
-  materializations.push({
-    target: normalizeRelativePath(relative(repoRoot, claudeTargetAbs)),
-    mode: 'symlink',
-  });
+  for (const entry of exportedSkills) {
+    const runtimeName = buildRuntimeName(packageMetadata.packageName, exportedSkills, entry);
+    const skillMaterializations = [];
 
-  const agentsTargetAbs = join(repoRoot, '.agents', 'skills', skillDirName);
-  ensureSymlink(packageDir, agentsTargetAbs);
-  materializations.push({
-    target: normalizeRelativePath(relative(repoRoot, agentsTargetAbs)),
-    mode: 'symlink',
-  });
+    const claudeTargetAbs = join(repoRoot, '.claude', 'skills', runtimeName);
+    ensureSymlink(entry.skillDir, claudeTargetAbs);
+    skillMaterializations.push({
+      target: normalizeRelativePath(relative(repoRoot, claudeTargetAbs)),
+      mode: 'symlink',
+    });
+
+    const agentsTargetAbs = join(repoRoot, '.agents', 'skills', runtimeName);
+    ensureSymlink(entry.skillDir, agentsTargetAbs);
+    skillMaterializations.push({
+      target: normalizeRelativePath(relative(repoRoot, agentsTargetAbs)),
+      mode: 'symlink',
+    });
+
+    materializations.push(...skillMaterializations);
+    skills.push({
+      name: entry.name,
+      runtime_name: runtimeName,
+      source_skill_path: normalizeRelativePath(relative(repoRoot, entry.skillDir)),
+      source_skill_file: normalizeRelativePath(relative(repoRoot, entry.skillFile)),
+      requires: entry.requires,
+      status: entry.status,
+      replacement: entry.replacement,
+      message: entry.message,
+      materializations: skillMaterializations,
+    });
+  }
 
   return {
     packageName: packageMetadata.packageName,
@@ -95,26 +144,23 @@ export function buildInstallRecord(repoRoot, packageDir, directTargetMap, {
     requestedTarget: directTargetMap.get(packageMetadata.packageName) || null,
     packageVersion: packageMetadata.packageVersion,
     sourcePackagePath: normalizeRelativePath(relative(repoRoot, packageDir)),
+    skills,
     materializations,
   };
 }
 
 export function rebuildInstallState(repoRoot, directTargetMap, {
-  listInstalledPackageDirs,
-  parseSkillFrontmatterFile,
+  packageDirs = [],
   readPackageMetadata,
+  readInstalledSkillExports,
   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,
+      readInstalledSkillExports,
       normalizeRelativePath,
     });
     if (!record) continue;
@@ -124,6 +170,7 @@ export function rebuildInstallState(repoRoot, directTargetMap, {
       requested_target: record.requestedTarget,
       package_version: record.packageVersion,
       source_package_path: record.sourcePackagePath,
+      skills: record.skills,
       materializations: record.materializations,
     };
   }

package/src/infrastructure/runtime/open-browser.js

@@ -1,6 +1,12 @@
+import { writeFileSync } from 'node:fs';
 import { spawn } from 'node:child_process';
 
 export function openBrowser(url) {
+  if (process.env.AGENTPACK_BROWSER_CAPTURE_PATH) {
+    writeFileSync(process.env.AGENTPACK_BROWSER_CAPTURE_PATH, `${url}\n`);
+    return;
+  }
+
   if (process.env.AGENTPACK_DISABLE_BROWSER === '1') return;
 
   const command = process.platform === 'darwin'