@alavida/agentpack 0.1.1 → 0.1.3

package/src/application/skills/list-stale-skills.js

@@ -0,0 +1,9 @@
+import { inspectStaleSkill, listStaleSkills } from '../../lib/skills.js';
+
+export function listStaleSkillsUseCase(options) {
+  return listStaleSkills(options);
+}
+
+export function inspectStaleSkillUseCase(target, options) {
+  return inspectStaleSkill(target, options);
+}

package/src/application/skills/run-skill-workbench-action.js

@@ -0,0 +1,23 @@
+import { inspectSkillDependencies } from '../../lib/skills.js';
+import { inspectStaleSkillUseCase } from './list-stale-skills.js';
+import { validateSkillsUseCase } from './validate-skills.js';
+
+export function runSkillWorkbenchAction(action, context) {
+  if (action === 'check-stale') {
+    return inspectStaleSkillUseCase(context.packageName, { cwd: context.cwd });
+  }
+
+  if (action === 'show-dependencies') {
+    return inspectSkillDependencies(context.packageName, { cwd: context.cwd });
+  }
+
+  if (action === 'validate-skill') {
+    return validateSkillsUseCase(context.target, { cwd: context.cwd });
+  }
+
+  if (action === 'refresh') {
+    return { refreshed: true };
+  }
+
+  throw new Error(`Unsupported workbench action: ${action}`);
+}

package/src/application/skills/start-skill-dev-workbench.js

@@ -0,0 +1,192 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { parseSkillFrontmatterFile, readPackageMetadata, normalizeDisplayPath } from '../../domain/skills/skill-model.js';
+import { readBuildState, compareRecordedSources } from '../../domain/skills/skill-provenance.js';
+import { buildSkillGraph, buildSkillStatusMap } from '../../domain/skills/skill-graph.js';
+import { buildTransitiveSkillWorkbenchModel } from './build-skill-workbench-model.js';
+import { startSkillDevWorkbenchServer } from '../../infrastructure/runtime/skill-dev-workbench-server.js';
+import { openBrowser } from '../../infrastructure/runtime/open-browser.js';
+import { watchSkillWorkbench } from '../../infrastructure/runtime/watch-skill-workbench.js';
+import { runSkillWorkbenchAction } from './run-skill-workbench-action.js';
+
+function listPackagedSkillDirs(repoRoot) {
+  const stack = [repoRoot];
+  const results = [];
+
+  while (stack.length > 0) {
+    const current = stack.pop();
+    let entries = [];
+    try {
+      entries = readdirSync(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    let hasSkillFile = false;
+    let hasPackageFile = false;
+
+    for (const entry of entries) {
+      if (entry.name === '.git' || entry.name === 'node_modules' || entry.name === '.agentpack') continue;
+      const fullPath = join(current, entry.name);
+
+      if (entry.isDirectory()) {
+        stack.push(fullPath);
+        continue;
+      }
+
+      if (entry.name === 'SKILL.md') hasSkillFile = true;
+      if (entry.name === 'package.json') hasPackageFile = true;
+    }
+
+    if (hasSkillFile && hasPackageFile) {
+      results.push(current);
+    }
+  }
+
+  return results.sort();
+}
+
+function findPackageDirByName(repoRoot, packageName) {
+  const stack = [repoRoot];
+
+  while (stack.length > 0) {
+    const current = stack.pop();
+    let entries = [];
+    try {
+      entries = readdirSync(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      if (entry.name === '.git' || entry.name === 'node_modules') continue;
+      const fullPath = join(current, entry.name);
+
+      if (entry.isDirectory()) {
+        stack.push(fullPath);
+        continue;
+      }
+
+      if (entry.name !== 'package.json') continue;
+
+      try {
+        const pkg = JSON.parse(readFileSync(fullPath, 'utf-8'));
+        if (pkg.name === packageName) return dirname(fullPath);
+      } catch {
+        // skip
+      }
+    }
+  }
+
+  const nodeModulesPath = join(repoRoot, 'node_modules', ...packageName.split('/'));
+  if (existsSync(join(nodeModulesPath, 'SKILL.md'))) return nodeModulesPath;
+
+  return null;
+}
+
+function buildModelForSkill(repoRoot, targetPackageName) {
+  const packageDirs = listPackagedSkillDirs(repoRoot);
+  const skillGraph = buildSkillGraph(repoRoot, packageDirs, {
+    parseSkillFrontmatterFile,
+    readPackageMetadata,
+    findPackageDirByName: (root, name) => findPackageDirByName(root, name),
+    normalizeDisplayPath,
+  });
+
+  const buildState = readBuildState(repoRoot);
+  const staleSkills = new Set();
+  const changedSources = new Set(); // track individual changed source paths
+
+  for (const [packageName, record] of Object.entries(buildState.skills || buildState)) {
+    if (typeof record !== 'object' || !record.sources) continue;
+    try {
+      const changes = compareRecordedSources(repoRoot, record);
+      if (changes.length > 0) {
+        staleSkills.add(packageName);
+        for (const change of changes) changedSources.add(change.path);
+      }
+    } catch {
+      // skip
+    }
+  }
+
+  const statusMap = buildSkillStatusMap(skillGraph, staleSkills);
+
+  function resolveSkillSources(packageName) {
+    const graphNode = skillGraph.get(packageName);
+    if (!graphNode) return [];
+
+    const skillFilePath = join(repoRoot, graphNode.skillFile);
+    try {
+      const metadata = parseSkillFrontmatterFile(skillFilePath);
+      return metadata.sources || [];
+    } catch {
+      return [];
+    }
+  }
+
+  function resolveSkillRequires(packageName) {
+    const graphNode = skillGraph.get(packageName);
+    if (!graphNode) return [];
+
+    const skillFilePath = join(repoRoot, graphNode.skillFile);
+    try {
+      const metadata = parseSkillFrontmatterFile(skillFilePath);
+      return metadata.requires || [];
+    } catch {
+      return [];
+    }
+  }
+
+  return buildTransitiveSkillWorkbenchModel({
+    repoRoot,
+    targetPackageName,
+    skillGraph,
+    statusMap,
+    changedSources,
+    resolveSkillSources,
+    resolveSkillRequires,
+  });
+}
+
+export async function startSkillDevWorkbench({
+  repoRoot,
+  skillDir,
+  open = true,
+  disableBrowser = false,
+}) {
+  const packageMetadata = readPackageMetadata(skillDir);
+  const defaultSkill = packageMetadata.packageName;
+
+  const server = await startSkillDevWorkbenchServer({
+    buildModel: (skillPackageName) => buildModelForSkill(repoRoot, skillPackageName),
+    defaultSkill,
+    onAction(action) {
+      return runSkillWorkbenchAction(action, {
+        cwd: repoRoot,
+        target: skillDir,
+        packageName: defaultSkill,
+      });
+    },
+  });
+
+  const watcher = watchSkillWorkbench(repoRoot, skillDir, () => {
+    // Model is rebuilt on each request, so no cache to invalidate
+  });
+
+  if (open && !disableBrowser) {
+    openBrowser(server.url);
+  }
+
+  return {
+    url: server.url,
+    port: server.port,
+    refresh() {
+      // no-op: models are built on demand per request
+    },
+    close() {
+      watcher.close();
+      server.close();
+    },
+  };
+}

package/src/application/skills/validate-skills.js

@@ -0,0 +1,5 @@
+import { validateSkills } from '../../lib/skills.js';
+
+export function validateSkillsUseCase(target, options) {
+  return validateSkills(target, options);
+}

package/src/cli.js

@@ -68,7 +68,7 @@ export function run(argv) {
     if (err instanceof AgentpackError) {
       const opts = program.opts?.() || {};
       if (opts.json) {
-        output.json({ error: err.code, message: err.message });
+        output.json(err.toJSON());
       } else {
         output.error(formatError(err));
       }

package/src/commands/plugin.js

@@ -1,5 +1,8 @@
 import { Command } from 'commander';
-import { buildPlugin, inspectPluginBundle, startPluginDev, validatePluginBundle } from '../lib/plugins.js';
+import { buildPluginUseCase } from '../application/plugins/build-plugin.js';
+import { inspectPluginBundleUseCase } from '../application/plugins/inspect-plugin-bundle.js';
+import { validatePluginBundleUseCase } from '../application/plugins/validate-plugin-bundle.js';
+import { startPluginDev } from '../lib/plugins.js';
 import { output } from '../utils/output.js';
 import { EXIT_CODES } from '../utils/errors.js';
 
@@ -13,7 +16,7 @@ export function pluginCommand() {
     .argument('<target>', 'Plugin directory path')
     .action((target, opts, command) => {
       const globalOpts = command.optsWithGlobals();
-      const result = inspectPluginBundle(target);
+      const result = inspectPluginBundleUseCase(target);
 
       if (globalOpts.json) {
         output.json(result);
@@ -76,7 +79,7 @@ export function pluginCommand() {
     .argument('<target>', 'Plugin directory path')
     .action((target, opts, command) => {
       const globalOpts = command.optsWithGlobals();
-      const result = validatePluginBundle(target);
+      const result = validatePluginBundleUseCase(target);
 
       if (globalOpts.json) {
         output.json(result);
@@ -114,7 +117,7 @@ export function pluginCommand() {
     .argument('<target>', 'Plugin directory path')
     .action((target, opts, command) => {
       const globalOpts = command.optsWithGlobals();
-      const result = buildPlugin(target, { clean: opts.clean });
+      const result = buildPluginUseCase(target, { clean: opts.clean });
 
       if (globalOpts.json) {
         output.json(result);

package/src/commands/skills.js

@@ -1,20 +1,19 @@
 import { Command } from 'commander';
+import { inspectSkillUseCase } from '../application/skills/inspect-skill.js';
+import { inspectStaleSkillUseCase, listStaleSkillsUseCase } from '../application/skills/list-stale-skills.js';
+import { validateSkillsUseCase } from '../application/skills/validate-skills.js';
 import {
   inspectSkillDependencies,
   inspectMissingSkillDependencies,
   inspectSkillsStatus,
   inspectRegistryConfig,
-  inspectSkill,
   inspectSkillsEnv,
-  inspectStaleSkill,
   installSkills,
   listOutdatedSkills,
-  listStaleSkills,
   resolveInstallTargets,
   startSkillDev,
   unlinkSkill,
   uninstallSkills,
-  validateSkills,
 } from '../lib/skills.js';
 import { output } from '../utils/output.js';
 import { EXIT_CODES } from '../utils/errors.js';
@@ -27,11 +26,13 @@ export function skillsCommand() {
     .command('dev')
     .description('Link one local packaged skill for local Claude and agent discovery')
     .option('--no-sync', 'Skip syncing managed package dependencies from requires')
+    .option('--no-dashboard', 'Skip starting the local skill development workbench')
     .argument('<target>', 'Packaged skill directory or SKILL.md path')
-    .action((target, opts, command) => {
+    .action(async (target, opts, command) => {
       const globalOpts = command.optsWithGlobals();
       const session = startSkillDev(target, {
         sync: opts.sync,
+        dashboard: opts.dashboard,
         onStart(result) {
           if (globalOpts.json) {
             output.json(result);
@@ -46,6 +47,9 @@ export function skillsCommand() {
           for (const link of result.links) {
             output.write(`Linked: ${link}`);
           }
+          if (result.workbench?.enabled) {
+            output.write(`Workbench URL: ${result.workbench.url}`);
+          }
           output.write('Note: if your current agent session was already running, start a fresh session to pick up newly linked skills.');
           if (result.unresolved.length > 0) {
             output.write('Unresolved Dependencies:');
@@ -73,6 +77,7 @@ export function skillsCommand() {
 
       process.once('SIGTERM', stop);
       process.once('SIGINT', stop);
+      await session.ready;
     });
 
   cmd
@@ -250,7 +255,7 @@ export function skillsCommand() {
     .argument('<target>', 'Skill directory, SKILL.md path, or package name')
     .action((target, opts, command) => {
       const globalOpts = command.optsWithGlobals();
-      const result = inspectSkill(target);
+      const result = inspectSkillUseCase(target);
 
       if (globalOpts.json) {
         output.json(result);
@@ -291,7 +296,7 @@ export function skillsCommand() {
       const globalOpts = command.optsWithGlobals();
 
       if (target) {
-        const result = inspectStaleSkill(target);
+        const result = inspectStaleSkillUseCase(target);
 
         if (globalOpts.json) {
           output.json(result);
@@ -310,7 +315,7 @@ export function skillsCommand() {
         return;
       }
 
-      const results = listStaleSkills();
+      const results = listStaleSkillsUseCase();
 
       if (globalOpts.json) {
         output.json({
@@ -337,7 +342,7 @@ export function skillsCommand() {
     .argument('[target]', 'Optional packaged skill directory, SKILL.md path, or package name')
     .action((target, opts, command) => {
       const globalOpts = command.optsWithGlobals();
-      const result = validateSkills(target);
+      const result = validateSkillsUseCase(target);
 
       if (globalOpts.json) {
         output.json(