npm - @alavida/agentpack - Versions diffs - 0.1.1 → 0.1.3 - Mend

@alavida/agentpack 0.1.1 → 0.1.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (57) hide show

package/README.md +16 -2
package/bin/intent.js +20 -0
package/package.json +11 -5
package/skills/agentpack-cli/SKILL.md +16 -1
package/skills/agentpack-cli/references/skill-lifecycle.md +21 -1
package/skills/authoring-skillgraphs-from-knowledge/SKILL.md +148 -0
package/skills/authoring-skillgraphs-from-knowledge/references/authored-metadata.md +6 -0
package/skills/developing-and-testing-skills/SKILL.md +109 -0
package/skills/developing-and-testing-skills/references/local-workbench.md +7 -0
package/skills/getting-started-skillgraphs/SKILL.md +115 -0
package/skills/getting-started-skillgraphs/references/command-routing.md +7 -0
package/skills/identifying-skill-opportunities/SKILL.md +119 -0
package/skills/identifying-skill-opportunities/references/capability-boundaries.md +6 -0
package/skills/maintaining-skillgraph-freshness/SKILL.md +110 -0
package/skills/repairing-broken-skill-or-plugin-state/SKILL.md +112 -0
package/skills/repairing-broken-skill-or-plugin-state/references/diagnostic-flows.md +6 -0
package/skills/shipping-production-plugins-and-packages/SKILL.md +123 -0
package/skills/shipping-production-plugins-and-packages/references/plugin-delivery.md +6 -0
package/src/application/plugins/build-plugin.js +5 -0
package/src/application/plugins/inspect-plugin-bundle.js +5 -0
package/src/application/plugins/validate-plugin-bundle.js +5 -0
package/src/application/skills/build-skill-workbench-model.js +194 -0
package/src/application/skills/inspect-skill.js +5 -0
package/src/application/skills/list-stale-skills.js +9 -0
package/src/application/skills/run-skill-workbench-action.js +23 -0
package/src/application/skills/start-skill-dev-workbench.js +192 -0
package/src/application/skills/validate-skills.js +5 -0
package/src/cli.js +1 -1
package/src/commands/plugin.js +7 -4
package/src/commands/skills.js +14 -9
package/src/dashboard/App.jsx +343 -0
package/src/dashboard/components/Breadcrumbs.jsx +45 -0
package/src/dashboard/components/ControlStrip.jsx +153 -0
package/src/dashboard/components/InspectorPanel.jsx +203 -0
package/src/dashboard/components/SkillGraph.jsx +567 -0
package/src/dashboard/components/Tooltip.jsx +111 -0
package/src/dashboard/dist/dashboard.js +26692 -0
package/src/dashboard/index.html +81 -0
package/src/dashboard/lib/api.js +19 -0
package/src/dashboard/lib/router.js +15 -0
package/src/dashboard/main.jsx +4 -0
package/src/domain/plugins/load-plugin-definition.js +163 -0
package/src/domain/plugins/plugin-diagnostic-error.js +18 -0
package/src/domain/plugins/plugin-requirements.js +15 -0
package/src/domain/skills/skill-graph.js +137 -0
package/src/domain/skills/skill-model.js +187 -0
package/src/domain/skills/skill-provenance.js +69 -0
package/src/infrastructure/fs/build-state-repository.js +16 -0
package/src/infrastructure/fs/install-state-repository.js +16 -0
package/src/infrastructure/runtime/materialize-skills.js +117 -0
package/src/infrastructure/runtime/open-browser.js +20 -0
package/src/infrastructure/runtime/skill-dev-workbench-server.js +96 -0
package/src/infrastructure/runtime/watch-skill-workbench.js +68 -0
package/src/infrastructure/runtime/watch-tree.js +44 -0
package/src/lib/plugins.js +46 -117
package/src/lib/skills.js +141 -459
package/src/utils/errors.js +33 -1

package/src/dashboard/index.html ADDED Viewed

@@ -0,0 +1,81 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>Skill Dev Workbench</title>
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Crimson+Pro:ital,wght@0,400;0,500;0,600;1,400;1,500&family=Noto+Sans+Mono:wght@400;500;600&display=swap" rel="stylesheet">
+    <style>
+      :root {
+        color-scheme: dark;
+        --bg: #1a1916;
+        --surface: #252320;
+        --border: rgba(255, 255, 255, 0.06);
+        --border-bright: rgba(255, 255, 255, 0.12);
+        --text: #e8e4dc;
+        --text-dim: #9a9488;
+        --text-faint: #6b655c;
+        --status-current: #8fa67e;
+        --status-stale: #d4a45e;
+        --status-affected: #c4956e;
+        --status-unknown: #9a9488;
+        --edge-provenance: #7a9abb;
+        --edge-requires: #8fa67e;
+        --accent: #ffbf47;
+        --font-body: 'Crimson Pro', Georgia, 'Times New Roman', serif;
+        --font-mono: 'Noto Sans Mono', 'Courier New', monospace;
+      }
+      [data-theme="light"] {
+        color-scheme: light;
+        --bg: #f5f2ed;
+        --surface: #e8e4dc;
+        --border: rgba(0, 0, 0, 0.10);
+        --border-bright: rgba(0, 0, 0, 0.20);
+        --text: #1a1816;
+        --text-dim: #3d3830;
+        --text-faint: #6b655c;
+        --status-current: #3d6e2c;
+        --status-stale: #a07020;
+        --status-affected: #8c5530;
+        --status-unknown: #6b655c;
+        --edge-provenance: #2e6080;
+        --edge-requires: #3d6e2c;
+        --accent: #a07020;
+      }
+      * { box-sizing: border-box; margin: 0; padding: 0; }
+      body {
+        font-family: var(--font-body);
+        background: var(--bg);
+        color: var(--text);
+        overflow: hidden;
+        height: 100vh;
+        -webkit-font-smoothing: antialiased;
+      }
+      #app {
+        height: 100vh;
+        display: flex;
+        flex-direction: column;
+      }
+      @keyframes stale-pulse {
+        0%, 100% { opacity: 0.4; }
+        50% { opacity: 0.8; }
+      }
+    </style>
+  </head>
+  <body>
+    <div id="app" data-app-root></div>
+    <script type="module" src="/assets/dashboard.js"></script>
+  </body>
+</html>

package/src/dashboard/lib/api.js ADDED Viewed

@@ -0,0 +1,19 @@
+export async function fetchWorkbenchModel(skillPackageName) {
+  const params = skillPackageName ? `?skill=${encodeURIComponent(skillPackageName)}` : '';
+  const response = await fetch(`/api/model${params}`);
+  if (!response.ok) {
+    const body = await response.json().catch(() => ({}));
+    throw new Error(body.error || `Failed to load workbench model: ${response.status}`);
+  }
+  return response.json();
+}
+export async function runWorkbenchAction(action) {
+  const response = await fetch(`/api/actions/${action}`, {
+    method: 'POST',
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to run ${action}: ${response.status}`);
+  }
+  return response.json();
+}

package/src/dashboard/lib/router.js ADDED Viewed

@@ -0,0 +1,15 @@
+export function getSkillFromHash() {
+  const hash = window.location.hash;
+  const match = hash.match(/^#\/skill\/(.+)$/);
+  return match ? decodeURIComponent(match[1]) : null;
+}
+export function setSkillHash(packageName) {
+  window.location.hash = `#/skill/${encodeURIComponent(packageName)}`;
+}
+export function onHashChange(callback) {
+  window.addEventListener('hashchange', () => {
+    callback(getSkillFromHash());
+  });
+}

package/src/dashboard/main.jsx ADDED Viewed

@@ -0,0 +1,4 @@
+import { createRoot } from 'react-dom/client';
+import { App } from './App.jsx';
+createRoot(document.getElementById('app')).render(<App />);

package/src/domain/plugins/load-plugin-definition.js ADDED Viewed

@@ -0,0 +1,163 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { basename, join, resolve } from 'node:path';
+import { normalizeRepoPath } from '../skills/skill-model.js';
+import { findRepoRoot } from '../../lib/context.js';
+import { NotFoundError } from '../../utils/errors.js';
+import { PluginDiagnosticError } from './plugin-diagnostic-error.js';
+import { getPluginRequirementLevel } from './plugin-requirements.js';
+function resolvePluginDir(repoRoot, target) {
+  const absoluteTarget = resolve(repoRoot, target);
+  if (!existsSync(absoluteTarget)) {
+    throw new NotFoundError('plugin not found', {
+      code: 'plugin_not_found',
+      suggestion: `Target: ${target}`,
+    });
+  }
+  return absoluteTarget;
+}
+function inferPluginPackageName(pluginDir) {
+  return `@alavida-ai/plugin-${basename(pluginDir)}`;
+}
+function readPluginPackageJson(repoRoot, pluginDir, requirementLevel) {
+  const packageJsonPath = join(pluginDir, 'package.json');
+  const displayPath = normalizeRepoPath(repoRoot, packageJsonPath);
+  const example = {
+    name: inferPluginPackageName(pluginDir),
+    version: '0.1.0',
+  };
+  if (!existsSync(packageJsonPath)) {
+    throw new PluginDiagnosticError('No package.json found for plugin target', {
+      code: 'missing_plugin_package_json',
+      path: displayPath,
+      nextSteps: [
+        {
+          action: 'create_file',
+          path: displayPath,
+          reason: 'A plugin must declare package metadata before it can be inspected',
+          example,
+        },
+      ],
+      details: {
+        requirementLevel,
+        missing: ['package.json'],
+      },
+    });
+  }
+  let pkg;
+  try {
+    pkg = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+  } catch {
+    throw new PluginDiagnosticError('Plugin package.json contains invalid JSON', {
+      code: 'invalid_plugin_package_json',
+      path: displayPath,
+      nextSteps: [
+        {
+          action: 'edit_file',
+          path: displayPath,
+          reason: 'Inspect and validate require a readable package.json file',
+          example,
+        },
+      ],
+      details: {
+        requirementLevel,
+      },
+    });
+  }
+  const missingFields = ['name', 'version'].filter((field) => !pkg[field]);
+  if (missingFields.length > 0) {
+    throw new PluginDiagnosticError(`Plugin package.json missing required fields: ${missingFields.join(', ')}`, {
+      code: 'missing_plugin_package_fields',
+      path: displayPath,
+      nextSteps: [
+        {
+          action: 'edit_file',
+          path: displayPath,
+          reason: 'A plugin package.json must include required package metadata before inspection can continue',
+          example: {
+            ...example,
+            ...('name' in pkg ? { name: pkg.name } : {}),
+            ...('version' in pkg ? { version: pkg.version } : {}),
+          },
+        },
+      ],
+      details: {
+        requirementLevel,
+        missingFields,
+      },
+    });
+  }
+  return {
+    packageJsonPath,
+    packageJson: pkg,
+    packageName: pkg.name,
+    packageVersion: pkg.version,
+  };
+}
+function readPluginManifest(repoRoot, pluginDir, requirementLevel) {
+  const pluginManifestPath = join(pluginDir, '.claude-plugin', 'plugin.json');
+  const displayPath = normalizeRepoPath(repoRoot, pluginManifestPath);
+  if (!existsSync(pluginManifestPath)) {
+    throw new PluginDiagnosticError('Plugin manifest is missing', {
+      code: 'missing_plugin_manifest',
+      path: displayPath,
+      nextSteps: [
+        {
+          action: 'create_file',
+          path: displayPath,
+          reason: 'Plugin commands require .claude-plugin/plugin.json to describe the runtime plugin entrypoint',
+          example: {
+            name: basename(pluginDir),
+            description: 'Describe what this plugin provides.',
+          },
+        },
+      ],
+      details: {
+        requirementLevel,
+        missing: ['.claude-plugin/plugin.json'],
+      },
+    });
+  }
+  return {
+    pluginManifestPath,
+    pluginManifest: JSON.parse(readFileSync(pluginManifestPath, 'utf-8')),
+  };
+}
+export function loadPluginDefinition(target, {
+  cwd = process.cwd(),
+  requirementLevel = 'inspect',
+} = {}) {
+  const repoRoot = findRepoRoot(cwd);
+  const pluginDir = resolvePluginDir(repoRoot, target);
+  const requirements = getPluginRequirementLevel(requirementLevel);
+  const packageData = readPluginPackageJson(repoRoot, pluginDir, requirementLevel);
+  const manifestData = requirements.pluginManifest
+    ? readPluginManifest(repoRoot, pluginDir, requirementLevel)
+    : {
+      pluginManifestPath: join(pluginDir, '.claude-plugin', 'plugin.json'),
+      pluginManifest: null,
+    };
+  return {
+    repoRoot,
+    pluginDir,
+    packageJsonPath: packageData.packageJsonPath,
+    packageJson: packageData.packageJson,
+    packageName: packageData.packageName,
+    packageVersion: packageData.packageVersion,
+    pluginManifestPath: manifestData.pluginManifestPath,
+    pluginManifest: manifestData.pluginManifest,
+  };
+}

package/src/domain/plugins/plugin-diagnostic-error.js ADDED Viewed

@@ -0,0 +1,18 @@
+import { ValidationError } from '../../utils/errors.js';
+export class PluginDiagnosticError extends ValidationError {
+  constructor(message, {
+    code,
+    path,
+    nextSteps = [],
+    details = {},
+  } = {}) {
+    super(message, {
+      code,
+      path,
+      nextSteps,
+      details,
+    });
+    this.name = 'PluginDiagnosticError';
+  }
+}

package/src/domain/plugins/plugin-requirements.js ADDED Viewed

@@ -0,0 +1,15 @@
+export const PLUGIN_REQUIREMENTS = {
+  inspect: {
+    pluginManifest: true,
+  },
+  validate: {
+    pluginManifest: true,
+  },
+  build: {
+    pluginManifest: true,
+  },
+};
+export function getPluginRequirementLevel(level = 'inspect') {
+  return PLUGIN_REQUIREMENTS[level] || PLUGIN_REQUIREMENTS.inspect;
+}

package/src/domain/skills/skill-graph.js ADDED Viewed

@@ -0,0 +1,137 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+export function readSkillGraphNode(repoRoot, packageDir, {
+  directInstallNames = new Set(),
+  parseSkillFrontmatterFile,
+  readPackageMetadata,
+  findPackageDirByName,
+  normalizeDisplayPath,
+} = {}) {
+  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,
+    description: skillMetadata.description,
+    packageName: packageMetadata.packageName,
+    packageVersion: packageMetadata.packageVersion,
+    skillPath: normalizeDisplayPath(repoRoot, packageDir),
+    skillFile: normalizeDisplayPath(repoRoot, skillFile),
+    direct: directInstallNames.has(packageMetadata.packageName),
+    dependencies: dependencyNames,
+  };
+}
+export function buildSkillGraph(repoRoot, packageDirs, options) {
+  const nodes = new Map();
+  for (const packageDir of packageDirs) {
+    const node = readSkillGraphNode(repoRoot, packageDir, options);
+    if (!node) continue;
+    nodes.set(node.packageName, node);
+  }
+  return nodes;
+}
+export 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;
+}
+export function buildSkillStatusMap(nodes, staleSkills = new Set()) {
+  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;
+}
+export function readNodeStatus(statusMap, packageName) {
+  if (!statusMap) return null;
+  return statusMap.get(packageName) || null;
+}
+export function resolveDependencyClosure(initialRequires, { resolveNode }) {
+  const seen = new Set();
+  const queue = [...initialRequires];
+  const resolved = [];
+  const unresolved = [];
+  while (queue.length > 0) {
+    const packageName = queue.shift();
+    if (seen.has(packageName)) continue;
+    seen.add(packageName);
+    const node = resolveNode(packageName);
+    if (!node) {
+      unresolved.push(packageName);
+      continue;
+    }
+    resolved.push(node);
+    for (const requirement of node.requires || []) {
+      if (!seen.has(requirement)) queue.push(requirement);
+    }
+  }
+  resolved.sort((a, b) => a.packageName.localeCompare(b.packageName));
+  unresolved.sort((a, b) => a.localeCompare(b));
+  return { resolved, unresolved };
+}

package/src/domain/skills/skill-model.js ADDED Viewed

@@ -0,0 +1,187 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { NotFoundError, ValidationError } from '../../utils/errors.js';
+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,
+  };
+}
+export function normalizeDisplayPath(repoRoot, absolutePath) {
+  return relative(repoRoot, absolutePath).split('\\').join('/');
+}
+export function normalizeRepoPath(repoRoot, absolutePath) {
+  return normalizeDisplayPath(repoRoot, absolutePath);
+}
+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,
+  };
+}