arckit-cli 6.1.1__py3-none-any.whl

arckit_cli-6.1.1.data/data/share/arckit/scripts/sync-claude-plugin-layout.py

@@ -0,0 +1,159 @@
+#!/usr/bin/env python3
+"""Mirror Claude overlay plugins into the local standalone repo layout."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+import shutil
+import sys
+
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+CORE_PLUGIN_DIR = REPO_ROOT / "plugins" / "arckit-claude"
+PLUGIN_LAYOUT = (
+    ("plugins/arckit-uae", "plugins/uae"),
+    ("plugins/arckit-fr", "plugins/fr"),
+    ("plugins/arckit-ca", "plugins/ca"),
+    ("plugins/arckit-eu", "plugins/eu"),
+    ("plugins/arckit-at", "plugins/at"),
+    ("plugins/arckit-au", "plugins/au"),
+    ("plugins/arckit-au-energy", "plugins/au/energy"),
+    ("plugins/arckit-us", "plugins/us"),
+    ("plugins/arckit-uk-finance", "plugins/uk/finance"),
+    ("plugins/arckit-uk-nhs", "plugins/uk/nhs"),
+    ("plugins/arckit-fde", "plugins/fde"),
+    ("plugins/arckit-uk-gcloud", "plugins/uk/gcloud"),
+    ("plugins/arckit-togaf-adm", "plugins/togaf/adm"),
+    ("plugins/arckit-agent-architecture", "plugins/agent/architecture"),
+)
+IGNORED_NAMES = {
+    ".git",
+    "node_modules",
+    ".npm",
+    ".pnpm-store",
+}
+
+
+def ignore_generated(_directory: str, names: list[str]) -> set[str]:
+    return {name for name in names if name in IGNORED_NAMES}
+
+
+def copy_tree(source: Path, destination: Path) -> None:
+    if destination.exists():
+        shutil.rmtree(destination)
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copytree(source, destination, ignore=ignore_generated)
+
+
+def expected_files() -> dict[Path, Path]:
+    expected: dict[Path, Path] = {}
+
+    for source_rel, destination_rel in PLUGIN_LAYOUT:
+        source = REPO_ROOT / source_rel
+        destination = CORE_PLUGIN_DIR / destination_rel
+        if not source.is_dir():
+            raise FileNotFoundError(f"Source plugin directory not found: {source_rel}")
+
+        for path in source.rglob("*"):
+            if not path.is_file() or any(part in IGNORED_NAMES for part in path.parts):
+                continue
+            relative = path.relative_to(source)
+            target = destination / relative
+            if target in expected:
+                previous = expected[target].relative_to(REPO_ROOT)
+                raise RuntimeError(
+                    f"Duplicate Claude standalone target {target.relative_to(REPO_ROOT)} "
+                    f"from {previous} and {path.relative_to(REPO_ROOT)}"
+                )
+            expected[target] = path
+
+    return expected
+
+
+def actual_files() -> set[Path]:
+    plugin_root = CORE_PLUGIN_DIR / "plugins"
+    if not plugin_root.exists():
+        return set()
+    return {
+        path
+        for path in plugin_root.rglob("*")
+        if path.is_file() and not any(part in IGNORED_NAMES for part in path.parts)
+    }
+
+
+def check_layout() -> list[str]:
+    expected = expected_files()
+    actual = actual_files()
+    failures: list[str] = []
+
+    for missing in sorted(set(expected) - actual):
+        failures.append(f"missing: {missing.relative_to(REPO_ROOT)}")
+
+    for extra in sorted(actual - set(expected)):
+        failures.append(f"extra: {extra.relative_to(REPO_ROOT)}")
+
+    for target, source in sorted(expected.items()):
+        if target not in actual:
+            continue
+        if target.read_bytes() != source.read_bytes():
+            failures.append(
+                "changed: "
+                f"{target.relative_to(REPO_ROOT)} differs from {source.relative_to(REPO_ROOT)}"
+            )
+
+    return failures
+
+
+def sync_layout() -> int:
+    plugin_root = CORE_PLUGIN_DIR / "plugins"
+    if plugin_root.exists():
+        shutil.rmtree(plugin_root)
+
+    for source_rel, destination_rel in PLUGIN_LAYOUT:
+        source = REPO_ROOT / source_rel
+        destination = CORE_PLUGIN_DIR / destination_rel
+        if not source.is_dir():
+            print(f"Source plugin directory not found: {source_rel}", file=sys.stderr)
+            return 1
+        copy_tree(source, destination)
+
+    synced_count = len(expected_files())
+    print(
+        "Synced "
+        f"{synced_count} files into {plugin_root.relative_to(REPO_ROOT)}/"
+    )
+    return 0
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Synchronize plugins/arckit-claude/plugins/... with the published "
+            "tractorjuice/arckit-claude standalone repository layout."
+        )
+    )
+    parser.add_argument(
+        "--check",
+        action="store_true",
+        help="verify the local standalone layout without modifying files",
+    )
+    args = parser.parse_args()
+
+    if args.check:
+        failures = check_layout()
+        if failures:
+            print("Claude standalone plugin layout is out of sync:", file=sys.stderr)
+            for failure in failures[:50]:
+                print(f"  {failure}", file=sys.stderr)
+            if len(failures) > 50:
+                print(f"  ... {len(failures) - 50} more", file=sys.stderr)
+            return 1
+        print("Claude standalone plugin layout is in sync")
+        return 0
+
+    return sync_layout()
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

arckit_cli-6.1.1.data/data/share/arckit/scripts/sync-shared-assets.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+"""Sync shared template partials and references from plugins/arckit-claude/ (core) into
+every community plugin tree.
+
+Background: community-overlay commands reference partials and references via
+`${CLAUDE_PLUGIN_ROOT}/templates/_partials/...` and `${CLAUDE_PLUGIN_ROOT}/
+references/...`. `${CLAUDE_PLUGIN_ROOT}` resolves to each plugin's own root, so
+those files must exist inside each community plugin tree — not just in core.
+Closes #520.
+
+Usage:
+
+    scripts/sync-shared-assets.py             # write copies
+    scripts/sync-shared-assets.py --check     # exit 1 if any drift (CI guard)
+"""
+
+from __future__ import annotations
+
+import argparse
+import filecmp
+import shutil
+import sys
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+CORE_PLUGIN = REPO_ROOT / "plugins" / "arckit-claude"
+SHARED_DIRS = ("templates/_partials", "references")
+
+
+# Plugins exempt from the shared-asset sync: the core plugin itself (the source
+# of truth), and `arckit-fde` — a Claude-only tooling plugin (white-label FDE
+# site generator) that has no governance commands and references none of the
+# shared partials/references, so it must not carry them.
+SYNC_EXEMPT_PLUGINS = {"arckit-claude", "arckit-fde"}
+
+
+def discover_community_plugins() -> list[Path]:
+    """Return every arckit-*/ directory with a Claude Code plugin manifest,
+    excluding the core arckit-claude plugin and any other sync-exempt plugin."""
+    return sorted(
+        p.parent.parent
+        for p in REPO_ROOT.glob("plugins/arckit-*/.claude-plugin/plugin.json")
+        if p.parent.parent.name not in SYNC_EXEMPT_PLUGINS
+    )
+
+
+def iter_shared_files() -> list[Path]:
+    """Return every shared-asset file under the core plugin tree."""
+    files: list[Path] = []
+    for rel in SHARED_DIRS:
+        src_dir = CORE_PLUGIN / rel
+        if not src_dir.exists():
+            continue
+        files.extend(sorted(p for p in src_dir.rglob("*") if p.is_file()))
+    return files
+
+
+def relative_to_core(path: Path) -> Path:
+    return path.relative_to(CORE_PLUGIN)
+
+
+def check(community_plugins: list[Path], shared: list[Path]) -> int:
+    drift: list[tuple[Path, str]] = []  # (path, reason)
+    for plugin in community_plugins:
+        for src in shared:
+            dst = plugin / relative_to_core(src)
+            if not dst.exists():
+                drift.append((dst, "missing"))
+            elif not filecmp.cmp(src, dst, shallow=False):
+                drift.append((dst, "drifted from core"))
+    if drift:
+        print("Shared-asset drift detected:", file=sys.stderr)
+        for path, reason in drift:
+            print(f"  {path.relative_to(REPO_ROOT)} — {reason}", file=sys.stderr)
+        print(
+            "\nRun `scripts/sync-shared-assets.py` to regenerate.",
+            file=sys.stderr,
+        )
+        return 1
+    print(
+        f"All {len(shared)} shared assets present in "
+        f"{len(community_plugins)} community plugins."
+    )
+    return 0
+
+
+def write(community_plugins: list[Path], shared: list[Path]) -> int:
+    written = 0
+    for plugin in community_plugins:
+        for src in shared:
+            dst = plugin / relative_to_core(src)
+            dst.parent.mkdir(parents=True, exist_ok=True)
+            if dst.exists() and filecmp.cmp(src, dst, shallow=False):
+                continue
+            shutil.copy2(src, dst)
+            written += 1
+            print(f"  {dst.relative_to(REPO_ROOT)}")
+    print(
+        f"\nSynced {written} file(s) into {len(community_plugins)} community plugin(s)."
+    )
+    return 0
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--check",
+        action="store_true",
+        help="Exit non-zero on drift; do not write.",
+    )
+    args = parser.parse_args()
+
+    community_plugins = discover_community_plugins()
+    shared = iter_shared_files()
+
+    if not community_plugins:
+        print("No community plugins discovered.", file=sys.stderr)
+        return 1
+    if not shared:
+        print(
+            f"No shared assets discovered under {CORE_PLUGIN}/{{{','.join(SHARED_DIRS)}}}",
+            file=sys.stderr,
+        )
+        return 1
+
+    if args.check:
+        return check(community_plugins, shared)
+    return write(community_plugins, shared)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

arckit_cli-6.1.1.data/data/share/arckit/scripts/tag-plugins.sh

@@ -0,0 +1,65 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# tag-plugins.sh — Create per-plugin Claude Code native tags after the umbrella tag.
+#
+# The umbrella tag `vX.Y.Z` triggers `.github/workflows/release.yml`. Each
+# individual plugin also gets a native tag `<plugin-name>--vX.Y.Z` for the
+# Claude Code plugin system's bookkeeping (resolving exact versions from
+# marketplace history, etc.).
+#
+# Usage: ./scripts/tag-plugins.sh <version>
+# Example: ./scripts/tag-plugins.sh 5.0.0
+
+VERSION="${1:-}"
+if [[ -z "$VERSION" ]]; then
+  echo "Usage: $0 <version>" >&2
+  echo "Example: $0 5.0.0" >&2
+  exit 1
+fi
+
+if ! [[ "$VERSION" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+  echo "Error: version must be semver (X.Y.Z), got: $VERSION" >&2
+  exit 1
+fi
+
+# Auto-discover plugin directories: anything containing a Claude Code manifest.
+# Avoids the manual-edit gotcha caught mid-v5.4.0 release where a new plugin
+# (arckit-uk-nhs) shipped without its tag because the array wasn't updated.
+mapfile -t PLUGINS < <(
+  find . -maxdepth 4 -path '*/.claude-plugin/plugin.json' -not -path '*/node_modules/*' \
+    | sed -E 's|^\./||; s|/\.claude-plugin/plugin\.json$||' \
+    | sort
+)
+
+if [[ ${#PLUGINS[@]} -eq 0 ]]; then
+  echo "Error: no plugins discovered (no */.claude-plugin/plugin.json files found)" >&2
+  exit 1
+fi
+
+CREATED=0
+SKIPPED=0
+
+for plugin_dir in "${PLUGINS[@]}"; do
+  manifest="$plugin_dir/.claude-plugin/plugin.json"
+  if [[ ! -f "$manifest" ]]; then
+    echo "Skipping $plugin_dir (no manifest)" >&2
+    continue
+  fi
+  plugin_name=$(python3 -c "import json; print(json.load(open('$manifest'))['name'])")
+  tag="${plugin_name}--v${VERSION}"
+
+  if git rev-parse "$tag" >/dev/null 2>&1; then
+    echo "Tag $tag already exists, skipping"
+    SKIPPED=$((SKIPPED + 1))
+    continue
+  fi
+
+  echo "Creating tag $tag"
+  git tag -a "$tag" -m "$plugin_name $VERSION"
+  git push origin "$tag"
+  CREATED=$((CREATED + 1))
+done
+
+echo ""
+echo "Done — created $CREATED native plugin tag(s), skipped $SKIPPED already-existing tag(s)."

arckit_cli-6.1.1.data/data/share/arckit/scripts/tests/test-doc-types-dual-registration.mjs

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+/**
+ * Dual-registration test for ArcKit doc-type codes.
+ *
+ * Asserts that every code in `plugins/arckit-claude/config/doc-types.mjs` also appears
+ * in the document-types allow-list table inside `plugins/arckit-claude/commands/pages.md`,
+ * and vice versa. The two registries must stay in sync; without this test the
+ * silent-omission failure mode (PR #317) recurs whenever a new overlay lands.
+ *
+ * Exit 0 = sync. Exit 1 = mismatch (prints the diff).
+ *
+ * Note on regex: pages.md uses the table format `| | CODE | \`ARC-*-CODE-*.md\` | Name |`
+ * (empty first column for grouping). We extract CODE from the second cell when the
+ * first cell is empty AND the third cell looks like an `ARC-*-CODE-*.md` glob, which
+ * uniquely identifies type-code rows and excludes section headers / unrelated tables.
+ */
+
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { dirname, resolve } from 'node:path';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const repoRoot = resolve(__dirname, '..', '..');
+
+const docTypesPath = resolve(repoRoot, 'plugins/arckit-claude/config/doc-types.mjs');
+const pagesPath = resolve(repoRoot, 'plugins/arckit-claude/commands/pages.md');
+
+const { DOC_TYPES } = await import(pathToFileURL(docTypesPath).href);
+const docTypesCodes = new Set(Object.keys(DOC_TYPES));
+
+const pagesContent = await readFile(pagesPath, 'utf8');
+// Match `| | CODE | `ARC-*-CODE-*.{md,html}` | ... |` rows in the document-types allow-list table.
+// CODE may include hyphens (e.g. PRIN-COMP, SECD-MOD).
+const codeRowRe = /^\|\s*\|\s*([A-Z][A-Z0-9]*(?:-[A-Z][A-Z0-9]*)*)\s*\|\s*`ARC-\*-\1-\*\.(?:md|html)`\s*\|/gm;
+const pagesCodes = new Set();
+for (const m of pagesContent.matchAll(codeRowRe)) pagesCodes.add(m[1]);
+
+const inDocTypesNotPages = [...docTypesCodes].filter((c) => !pagesCodes.has(c)).sort();
+const inPagesNotDocTypes = [...pagesCodes].filter((c) => !docTypesCodes.has(c)).sort();
+
+let ok = true;
+if (inDocTypesNotPages.length > 0) {
+  ok = false;
+  console.error('[FAIL] Codes in doc-types.mjs but missing from pages.md table:');
+  for (const c of inDocTypesNotPages) console.error('  -', c);
+}
+if (inPagesNotDocTypes.length > 0) {
+  ok = false;
+  console.error('[FAIL] Codes in pages.md table but missing from doc-types.mjs:');
+  for (const c of inPagesNotDocTypes) console.error('  -', c);
+}
+
+if (ok) {
+  console.log(`[PASS] ${docTypesCodes.size} codes registered consistently across both registries.`);
+  process.exit(0);
+}
+process.exit(1);

arckit_cli-6.1.1.data/data/share/arckit/scripts/tests/test-fde-templates.mjs

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+/**
+ * Consistency guard for the arckit-fde site-generator templates.
+ *
+ * 1. Every scalar {{TOKEN}} used in templates/ is documented in the fenced
+ *    ```tokens block of references/config-schema.md, and vice versa.
+ *    Item-scoped tokens ({{ITEM_*}}) are excluded.
+ * 2. Every <!-- BEGIN: x --> (or # BEGIN: x) has a matching END per file.
+ * 3. Both presets carry every required top-level key, with no leftover
+ *    <verbatim>/<from source> placeholders.
+ *
+ * Exit 0 = consistent. Exit 1 = drift. No external dependencies.
+ */
+import { fileURLToPath } from 'node:url';
+import { dirname, resolve } from 'node:path';
+import { readFileSync, readdirSync, statSync } from 'node:fs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const repoRoot = resolve(__dirname, '..', '..');
+const plugin = resolve(repoRoot, 'plugins/arckit-fde');
+const templatesDir = resolve(plugin, 'templates');
+const schemaPath = resolve(plugin, 'references/config-schema.md');
+
+function walk(dir) {
+  const out = [];
+  for (const name of readdirSync(dir)) {
+    const p = resolve(dir, name);
+    if (statSync(p).isDirectory()) out.push(...walk(p));
+    else out.push(p);
+  }
+  return out;
+}
+
+const templateFiles = walk(templatesDir);
+const templateText = templateFiles
+  .filter((p) => /\.(html|css|txt|xml)$/.test(p) || p.endsWith('nojekyll'))
+  .map((p) => readFileSync(p, 'utf8'))
+  .join('\n');
+
+const usedTokens = new Set(
+  [...templateText.matchAll(/\{\{([A-Z0-9_]+)\}\}/g)]
+    .map((m) => m[1])
+    .filter((t) => !t.startsWith('ITEM_')),
+);
+
+const schema = readFileSync(schemaPath, 'utf8');
+const tokensBlock = schema.match(/```tokens\n([\s\S]*?)```/);
+if (!tokensBlock) {
+  console.error('[FAIL] no ```tokens block in config-schema.md');
+  process.exit(1);
+}
+const documented = new Set(
+  [...tokensBlock[1].matchAll(/\{\{([A-Z0-9_]+)\}\}/g)].map((m) => m[1]),
+);
+
+let ok = true;
+const usedNotDocumented = [...usedTokens].filter((t) => !documented.has(t)).sort();
+const documentedNotUsed = [...documented].filter((t) => !usedTokens.has(t)).sort();
+if (usedNotDocumented.length) {
+  ok = false;
+  console.error('[FAIL] tokens used in templates but not documented:', usedNotDocumented);
+}
+if (documentedNotUsed.length) {
+  ok = false;
+  console.error('[FAIL] tokens documented but never used in templates:', documentedNotUsed);
+}
+
+for (const file of templateFiles) {
+  if (!/\.(html|txt)$/.test(file)) continue;
+  const t = readFileSync(file, 'utf8');
+  const begins = [...t.matchAll(/BEGIN:\s*([a-z-]+)/g)].map((m) => m[1]).sort();
+  const ends = [...t.matchAll(/END:\s*([a-z-]+)/g)].map((m) => m[1]).sort();
+  if (JSON.stringify(begins) !== JSON.stringify(ends)) {
+    ok = false;
+    console.error(`[FAIL] BEGIN/END mismatch in ${file}:`, { begins, ends });
+  }
+}
+
+const requiredKeys = [
+  'market_preset', 'area_served', 'eyebrow', 'page_title_suffix', 'meta_description',
+  'hero_alt', 'footer_tagline', 'cta_eyebrow', 'cta_headline', 'examples_heading',
+  'powered_by_arckit', 'tagline', 'cta_primary', 'pricing', 'signal_band', 'value_props',
+  'offer_pack', 'public_sector_benefits', 'follow_on_areas', 'policy_frameworks',
+  'worked_examples', 'bootstrap_cadence',
+];
+for (const preset of ['uk-public-sector.yaml', 'generic.yaml']) {
+  const text = readFileSync(resolve(plugin, 'presets', preset), 'utf8');
+  const missing = requiredKeys.filter((k) => !new RegExp(`^${k}:`, 'm').test(text));
+  if (missing.length) {
+    ok = false;
+    console.error(`[FAIL] ${preset} missing keys:`, missing);
+  }
+  if (/<verbatim|<from source/.test(text)) {
+    ok = false;
+    console.error(`[FAIL] ${preset} still contains placeholder markers`);
+  }
+}
+
+if (ok) console.log('[OK] arckit-fde templates, schema and presets are consistent');
+process.exit(ok ? 0 : 1);

arckit_cli-6.1.1.data/data/share/arckit/scripts/tests/test-regime-registration.mjs

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+/**
+ * Regime-registration test for ArcKit doc-type regimes.
+ *
+ * Every `regime:` value declared on an entry in
+ * `plugins/arckit-claude/config/doc-types.mjs` MUST also be registered in the exported
+ * `REGIMES` array AND have a label in `REGIME_LABELS`. Consumers that iterate
+ * `REGIMES` (e.g. `hooks/graph-inject.mjs`: compliance-presence listing and
+ * readiness scorecard) silently skip any jurisdiction whose regime code is
+ * declared on doc-types but absent from `REGIMES` — the artefacts validate on
+ * disk but never surface in the injected governance context.
+ *
+ * This invariant is invisible to the dual-registration test (which checks
+ * code ↔ pages.md), and the gap has recurred twice: `CA` (12 doc-types shipped
+ * before `'CA'` was added to `REGIMES`, fixed in #441) and `US` (10 doc-types,
+ * fixed in #545). This guard exists so it cannot recur silently again.
+ *
+ * Exit 0 = every declared regime is registered + labelled. Exit 1 = mismatch.
+ */
+
+import { fileURLToPath } from 'node:url';
+import { dirname, resolve } from 'node:path';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const repoRoot = resolve(__dirname, '..', '..');
+const docTypesPath = resolve(repoRoot, 'plugins/arckit-claude/config/doc-types.mjs');
+
+const { DOC_TYPES, REGIMES, REGIME_LABELS } = await import(docTypesPath);
+
+const declaredRegimes = new Set(
+  Object.values(DOC_TYPES)
+    .map((info) => info.regime)
+    .filter(Boolean),
+);
+const registered = new Set(REGIMES);
+const labelled = new Set(Object.keys(REGIME_LABELS));
+
+const declaredNotRegistered = [...declaredRegimes].filter((r) => !registered.has(r)).sort();
+const registeredNotLabelled = [...registered].filter((r) => !labelled.has(r)).sort();
+const labelledNotRegistered = [...labelled].filter((r) => !registered.has(r)).sort();
+
+let ok = true;
+if (declaredNotRegistered.length > 0) {
+  ok = false;
+  console.error('[FAIL] regime codes declared on doc-types but missing from REGIMES:');
+  for (const r of declaredNotRegistered) console.error('  -', r);
+}
+if (registeredNotLabelled.length > 0) {
+  ok = false;
+  console.error('[FAIL] regimes in REGIMES but missing a REGIME_LABELS entry:');
+  for (const r of registeredNotLabelled) console.error('  -', r);
+}
+if (labelledNotRegistered.length > 0) {
+  ok = false;
+  console.error('[FAIL] regimes in REGIME_LABELS but missing from REGIMES:');
+  for (const r of labelledNotRegistered) console.error('  -', r);
+}
+
+if (ok) {
+  console.log(
+    `[PASS] ${declaredRegimes.size} declared regime(s) all registered in REGIMES (${REGIMES.length}) and labelled.`,
+  );
+  process.exit(0);
+}
+process.exit(1);