artifact-chain-assistant 0.8.0

package/scripts/build-adapters.mjs

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+// @scenario S-05 @feature ACA5
+// @feature ACA17
+// @scenario S-56
+import { access, chmod, mkdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
+import { spawnSync } from 'node:child_process';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = dirname(dirname(fileURLToPath(import.meta.url)));
+const check = process.argv.includes('--check');
+
+if (check) {
+  const skillCheck = spawnSync(process.execPath, ['scripts/sync-skills.mjs', '--check'], {
+    cwd: root,
+    encoding: 'utf8',
+  });
+  if (skillCheck.status !== 0) {
+    if (skillCheck.stdout) process.stderr.write(skillCheck.stdout);
+    if (skillCheck.stderr) process.stderr.write(skillCheck.stderr);
+    process.exitCode = 1;
+  }
+}
+const packageJson = JSON.parse(await readFile(join(root, 'package.json'), 'utf-8'));
+const vars = {
+  pluginName: 'artifact-chain-assistant',
+  version: packageJson.version,
+};
+
+const shellResolver = `artifact_graph() {
+  if [ -x ./node_modules/.bin/artifact-graph ]; then
+    ./node_modules/.bin/artifact-graph "$@"
+    return $?
+  fi
+  if command -v artifact-graph >/dev/null 2>&1; then
+    artifact-graph "$@"
+    return $?
+  fi
+  if [ -n "\${ARTIFACT_GRAPH_LEGACY_CLI:-}" ] && [ -f "$ARTIFACT_GRAPH_LEGACY_CLI" ]; then
+    node "$ARTIFACT_GRAPH_LEGACY_CLI" "$@"
+    return $?
+  fi
+  echo "artifact-chain-assistant: artifact-graph CLI not found; install it in the project or PATH." >&2
+  return 127
+}
+`;
+
+const outputs = [
+  {
+    template: 'templates/codex/marketplace.json.tpl',
+    path: '.agents/plugins/marketplace.json',
+  },
+  {
+    template: 'templates/claude/marketplace.json.tpl',
+    path: '.claude-plugin/marketplace.json',
+  },
+  {
+    template: 'templates/codex/plugin.json.tpl',
+    path: 'adapters/codex/.codex-plugin/plugin.json',
+  },
+  {
+    template: 'templates/claude/plugin.json.tpl',
+    path: 'adapters/claude/.claude-plugin/plugin.json',
+  },
+  {
+    template: 'templates/claude/settings.json.tpl',
+    path: 'adapters/claude/hooks/hooks.json',
+  },
+  {
+    path: 'adapters/claude/hooks/version-lock-stop.mjs',
+    content: await readFile(join(root, 'runtime/claude/version-lock-stop.mjs'), 'utf-8'),
+  },
+  {
+    path: 'adapters/claude/bin/version-lock-audit.sh',
+    content: `#!/bin/sh
+set -u
+
+${shellResolver}
+artifact_graph version-lock audit --strict-missing-lock "$@"
+`,
+    executable: true,
+  },
+  {
+    path: 'adapters/claude/bin/version-lock-refresh.sh',
+    content: `#!/bin/sh
+set -u
+
+${shellResolver}
+artifact_graph version-lock refresh --changed-only --staged "$@"
+`,
+    executable: true,
+  },
+  {
+    path: 'adapters/claude/commands/version-lock-audit.md',
+    content: '---\ndescription: Run strict artifact-chain version lock audit\n---\n\nRun this command from the project root:\n\n```bash\nartifact-graph version-lock audit --strict-missing-lock\n```\n',
+  },
+  {
+    path: 'adapters/claude/commands/version-lock-refresh.md',
+    content: '---\ndescription: Refresh staged artifact-chain version locks\n---\n\nRun this command from the project root, then review and stage the lock file if it changes:\n\n```bash\nartifact-graph version-lock refresh --changed-only --staged --format markdown\n```\n',
+  },
+];
+
+let drift = false;
+const stalePaths = [
+  'adapters/claude/.claude-plugin/marketplace.json',
+  'adapters/codex/commands',
+  'adapters/codex/commands/version-lock-audit.sh',
+  'adapters/codex/commands/version-lock-refresh.sh',
+];
+for (const stalePath of stalePaths) {
+  const target = join(root, stalePath);
+  if (check) {
+    try {
+      await access(target);
+      drift = true;
+      console.error(`Generated adapter stale path: ${stalePath}`);
+    } catch {}
+  } else {
+    await rm(target, { force: true, recursive: stalePath === 'adapters/codex/commands' });
+  }
+}
+
+const generatedContent = new Map();
+for (const output of outputs) {
+  const target = join(root, output.path);
+  const content = output.content ?? render(await readFile(join(root, output.template), 'utf-8'), vars);
+  generatedContent.set(output.path, content);
+  if (check) {
+    let current = '';
+    try {
+      current = await readFile(target, 'utf-8');
+    } catch {
+      current = '';
+    }
+    if (current !== content) {
+      drift = true;
+      console.error(`Generated adapter drift: ${output.path}`);
+    }
+    if (output.executable) {
+      const mode = (await stat(target)).mode;
+      if ((mode & 0o111) === 0) {
+        drift = true;
+        console.error(`Generated adapter mode drift: ${output.path}`);
+      }
+    }
+  } else {
+    await mkdir(dirname(target), { recursive: true });
+    await writeFile(target, content);
+    if (output.executable) {
+      await chmod(target, 0o755);
+    }
+  }
+}
+
+// Root plugin manifests required by release-skill assess. They are deterministic copies of the
+// generated adapter manifests above, so the adapter template render stays the single version source.
+// The marketplace plugin source still points at ./adapters/claude and ./adapters/codex; these root
+// files are release metadata only, not an alternate install root and not a host installation surface.
+const rootManifestCopies = [
+  { from: 'adapters/claude/.claude-plugin/plugin.json', path: '.claude-plugin/plugin.json' },
+  { from: 'adapters/codex/.codex-plugin/plugin.json', path: '.codex-plugin/plugin.json' },
+];
+for (const copy of rootManifestCopies) {
+  const target = join(root, copy.path);
+  const content =
+    generatedContent.get(copy.from) ?? (await readFile(join(root, copy.from), 'utf-8'));
+  if (check) {
+    let current = '';
+    try {
+      current = await readFile(target, 'utf-8');
+    } catch {
+      current = '';
+    }
+    if (current !== content) {
+      drift = true;
+      console.error(`Generated root manifest drift: ${copy.path}`);
+    }
+  } else {
+    await mkdir(dirname(target), { recursive: true });
+    await writeFile(target, content);
+  }
+}
+
+if (drift) {
+  process.exitCode = 1;
+}
+
+function render(source, variables) {
+  return `${source.replace(/\{\{(\w+)\}\}/g, (_, key) => {
+    if (!(key in variables)) {
+      throw new Error(`Unknown template variable: ${key}`);
+    }
+    return variables[key];
+  }).trimEnd()}\n`;
+}

package/scripts/build-runtime-bundles.mjs

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+import { chmod, mkdir, readFile, readdir, rm, stat, writeFile } from 'node:fs/promises';
+import { dirname, join, relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = dirname(dirname(fileURLToPath(import.meta.url)));
+const check = process.argv.includes('--check');
+const hosts = ['codex', 'claude'];
+const sharedFiles = [
+  'INSTALL.md',
+  'EXTENDED-ARTIFACT-CATALOG.md',
+  'EXTENDED-ARTIFACT-CATALOG.zh-CN.md',
+  'templates/README.md',
+  'compatibility.json',
+  'scripts/doctor.mjs',
+  'scripts/check-workflow-profile.mjs',
+  'scripts/run-artifact-workflow.mjs',
+  'scripts/batch-split.mjs',
+  'scripts/batch-merge.mjs',
+  'scripts/check-family-api.mjs',
+  'scripts/family-compile.mjs',
+  'scripts/family-help-render.mjs',
+  'scripts/method-query.mjs',
+  'scripts/export-family-api.mjs',
+];
+const sharedDirectories = ['templates/core', 'templates/extended', 'scripts/lib', 'schemas', 'agent-methods', 'family-apis', 'families-src'];
+
+let drift = false;
+
+for (const host of hosts) {
+  for (const path of sharedFiles) {
+    await syncFile(join(root, path), join(root, 'adapters', host, path));
+  }
+  for (const path of sharedDirectories) {
+    await syncTree(join(root, path), join(root, 'adapters', host, path));
+  }
+}
+
+if (drift) {
+  process.exitCode = 1;
+}
+
+async function syncFile(source, target) {
+  const [sourceContent, sourceStat] = await Promise.all([readFile(source), stat(source)]);
+  const expectedContent = runtimeContent(source, sourceContent);
+
+  if (!check) {
+    await mkdir(dirname(target), { recursive: true });
+    await writeFile(target, expectedContent);
+    await chmod(target, sourceStat.mode & 0o777);
+    return;
+  }
+
+  try {
+    const [targetContent, targetStat] = await Promise.all([readFile(target), stat(target)]);
+    if (
+      !expectedContent.equals(targetContent) ||
+      executableMode(sourceStat) !== executableMode(targetStat)
+    ) {
+      reportFileDrift(target);
+    }
+  } catch {
+    reportFileDrift(target);
+  }
+}
+
+async function syncTree(source, target) {
+  const sourceFiles = await collectFiles(source);
+
+  if (!check) {
+    await rm(target, { recursive: true, force: true });
+    for (const sourceFile of sourceFiles) {
+      await syncFile(join(source, sourceFile), join(target, sourceFile));
+    }
+    return;
+  }
+
+  let targetFiles = [];
+  try {
+    targetFiles = await collectFiles(target);
+  } catch {
+    reportTreeDrift(target);
+  }
+  if (!samePaths(sourceFiles, targetFiles)) {
+    reportTreeDrift(target);
+  }
+  for (const sourceFile of sourceFiles) {
+    await syncFile(join(source, sourceFile), join(target, sourceFile));
+  }
+}
+
+async function collectFiles(directory, current = directory) {
+  const entries = await readdir(current, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const path = join(current, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await collectFiles(directory, path));
+    } else if (entry.isFile()) {
+      files.push(relative(directory, path));
+    }
+  }
+  return files.sort();
+}
+
+function runtimeContent(source, content) {
+  const sourcePath = relative(root, source);
+  let runtime = content.toString('utf8');
+  if (/^EXTENDED-ARTIFACT-CATALOG(?:\.zh-CN)?\.md$/.test(sourcePath)) {
+    runtime = runtime.replaceAll('](README.md)', '](templates/README.md)');
+  }
+  if (/^templates(?:\/.*)?\/README\.md$/.test(sourcePath)) {
+    runtime = runtime.replaceAll('skills-src/', 'skills/');
+  }
+  return Buffer.from(runtime);
+}
+
+function executableMode(fileStat) {
+  return fileStat.mode & 0o111;
+}
+
+function samePaths(left, right) {
+  return left.length === right.length && left.every((path, index) => path === right[index]);
+}
+
+function reportFileDrift(path) {
+  drift = true;
+  console.error(`Runtime bundle drift: ${relative(root, path)}`);
+}
+
+function reportTreeDrift(path) {
+  drift = true;
+  console.error(`Runtime bundle tree drift: ${relative(root, path)}`);
+}

package/scripts/check-compatibility.mjs

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+// @scenario S-44 @feature ACA13
+// @decision D-ACA-15
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { validateCompatibilityPolicy } from './lib/compatibility-policy.mjs';
+
+const pluginRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+
+const issues = await validateCompatibilityPolicy(pluginRoot);
+
+if (issues.length > 0) {
+  for (const issue of issues) {
+    process.stderr.write(`compatibility: ${issue}\n`);
+  }
+  process.exitCode = 1;
+} else {
+  process.stdout.write('compatibility: all checks passed\n');
+}