@bossmissing/agent-meta 0.1.0 → 0.3.0

package/dist/commands/review.d.ts

@@ -0,0 +1,18 @@
+import { type ResolvedDocScope } from "../core/doc-scopes.js";
+import { type ChecklistItem } from "../core/checklist.js";
+export interface ReviewOptions {
+    json?: boolean;
+    /** Interactively confirm which documentation scopes to tidy this round. */
+    pickDocs?: boolean;
+}
+/**
+ * Periodic repository review checklist. Items that map to deterministic
+ * `meta check` rules are evaluated live; the rest is a manual routine for
+ * the reviewing human (or agent) covering docs, code, tests and security.
+ */
+/**
+ * @param selectedScopes doc-scope keys confirmed by the human; undefined
+ *   means every scope is listed (missing ones marked as such).
+ */
+export declare function buildReviewChecklist(root: string, selectedScopes?: string[]): ChecklistItem[];
+export declare function runReview(root: string, opts?: ReviewOptions, pick?: (scopes: ResolvedDocScope[]) => Promise<string[]>): Promise<void>;

package/dist/commands/review.js

@@ -0,0 +1,102 @@
+import { checkbox } from "@inquirer/prompts";
+import { loadConfig } from "../core/config.js";
+import { runCheck } from "./check.js";
+import { listDomainDirs } from "../validators/domain-validator.js";
+import { isHighRisk } from "../core/risk.js";
+import { resolveDocScopes } from "../core/doc-scopes.js";
+import { printChecklist, checklistToJson } from "../core/checklist.js";
+import { logger } from "../core/logger.js";
+/**
+ * Periodic repository review checklist. Items that map to deterministic
+ * `meta check` rules are evaluated live; the rest is a manual routine for
+ * the reviewing human (or agent) covering docs, code, tests and security.
+ */
+/**
+ * @param selectedScopes doc-scope keys confirmed by the human; undefined
+ *   means every scope is listed (missing ones marked as such).
+ */
+export function buildReviewChecklist(root, selectedScopes) {
+    const { config } = loadConfig(root);
+    const result = runCheck(root, {});
+    const files = (codes) => result.issues
+        .filter((i) => codes.includes(i.code))
+        .map((i) => i.file ?? i.message);
+    const highRisk = listDomainDirs(root, config.paths.domain_docs).filter((d) => isHighRisk(d, config.risk_keywords));
+    const auto = (id, section, text, offending) => ({
+        id,
+        section,
+        text,
+        kind: "auto",
+        status: offending.length === 0 ? "pass" : "fail",
+        details: offending,
+    });
+    const manual = (id, section, text, details) => ({
+        id,
+        section,
+        text,
+        kind: "manual",
+        status: "pending",
+        details,
+    });
+    const DOCS = "Docs（优化文档）";
+    const CODE = "Code（review 代码）";
+    const TESTS = "Tests（review 测试用例）";
+    const SECURITY = "Security（review 安全）";
+    return [
+        // Docs
+        auto("doc-stale", DOCS, "All constrained docs reviewed within their interval", files(["DOC_STALE"])),
+        auto("doc-owner", DOCS, "Every constrained doc has an owner", files(["DOC_FRONTMATTER_MISSING_OWNER", "DOMAIN_NO_OWNER"])),
+        auto("doc-hard-constraints", DOCS, "Every high-risk domain declares hard constraints", files(["HIGH_RISK_DOMAIN_MISSING_HARD_CONSTRAINTS"])),
+        manual("doc-hard-drift", DOCS, "Check for constraint drift: hard constraints enforced in code but not declared in rules.md / constraints.md"),
+        auto("doc-agents-budget", DOCS, "AGENTS.md files are within their line budget", files(["AGENTS_TOO_LONG"])),
+        auto("doc-duplicates", DOCS, "No duplicated or conflicting agent rules", files(["AGENTS_DUPLICATE_RULE", "AGENTS_POTENTIAL_CONFLICT"])),
+        // One item per documentation scope; the human confirms which scopes to
+        // tidy this round via --pick-docs.
+        ...resolveDocScopes(root, config)
+            .filter((s) => !selectedScopes || selectedScopes.includes(s.key))
+            .map((s) => manual(`doc-scope-${s.key}`, DOCS, s.exists
+            ? `整理 ${s.title}：re-read, fix drift, bump last_reviewed（${s.files.length} file(s)）`
+            : `整理 ${s.title}：not present yet（${s.paths.join(" / ")}）— create it if this project needs it`, s.exists ? s.files : undefined)),
+        manual("doc-indexes", DOCS, "Run `meta sync --indexes` after the docs are tidied"),
+        // Code
+        manual("code-highrisk", CODE, "Review high-risk domain code against its rules.md", highRisk.length > 0 ? highRisk : undefined),
+        manual("code-local-agents", CODE, "Verify local AGENTS.md rules still match the code"),
+        manual("code-thirdparty", CODE, "Confirm no third-party or vendored code was modified"),
+        // Tests
+        manual("test-highrisk", TESTS, "High-risk domains have tests for normal, boundary, retry and idempotency paths", highRisk.length > 0 ? highRisk : undefined),
+        manual("test-flaky", TESTS, "Review skipped, flaky and long-quarantined tests"),
+        manual("test-conventions", TESTS, "Test suite still follows docs/engineering/testing.md"),
+        // Security
+        manual("sec-permissions", SECURITY, "Permission and authorization checks match the documented rules"),
+        manual("sec-audit-log", SECURITY, "Audit logging still covers all high-risk flows"),
+        manual("sec-deps", SECURITY, "Run a dependency audit (e.g. pnpm audit) and triage findings"),
+        manual("sec-secrets", SECURITY, "No secrets or credentials committed; .env handling reviewed"),
+        manual("sec-callbacks", SECURITY, "Webhook/callback signature validation and deduplication are intact"),
+    ];
+}
+export async function runReview(root, opts = {}, pick = (scopes) => checkbox({
+    message: "本轮整理哪些文档？（空格勾选，回车确认）",
+    choices: scopes.map((s) => ({
+        name: s.exists ? `${s.title}（${s.files.length} file(s)）` : `${s.title}（未创建）`,
+        value: s.key,
+        checked: s.exists,
+    })),
+})) {
+    let selected;
+    if (opts.pickDocs) {
+        const { config } = loadConfig(root);
+        selected = await pick(resolveDocScopes(root, config));
+        if (selected.length === 0)
+            logger.info("No doc scopes selected — docs items omitted.");
+    }
+    const items = buildReviewChecklist(root, selected);
+    if (opts.json) {
+        console.log(JSON.stringify(checklistToJson(items), null, 2));
+        return;
+    }
+    printChecklist("Periodic Repository Review Checklist", items);
+    const failed = items.filter((i) => i.status === "fail");
+    if (failed.length > 0) {
+        console.log(`Run \`meta check\` for details on the ${failed.length} failing item(s).`);
+    }
+}

package/dist/commands/sync.js

@@ -5,6 +5,7 @@ import { FileWriter } from "../core/filesystem.js";
 import { logger } from "../core/logger.js";
 import { loadConfig } from "../core/config.js";
 import { updateAdrIndex, updateDomainIndex } from "../generators/index-generator.js";
+import { EXIT_CODES, MetaError } from "../core/errors.js";
 export function runSync(root, opts) {
     const { config } = loadConfig(root);
     const all = !opts.indexes && !opts.openspec && !opts.templates;
@@ -35,8 +36,16 @@ export function runSync(root, opts) {
                 execSync("openspec update", { cwd: root, stdio: "inherit" });
                 logger.ok("OpenSpec updated");
             }
-            catch {
-                logger.warn("Could not run `openspec update` (is the OpenSpec CLI installed?). Skipped.");
+            catch (e) {
+                const err = e;
+                // ENOENT / exit 127: the binary is missing. Anything else is a real
+                // failure of an installed CLI and must fail the sync.
+                if (err.code === "ENOENT" || err.status === 127) {
+                    logger.warn("Could not run `openspec update` (is the OpenSpec CLI installed?). Skipped.");
+                }
+                else {
+                    throw new MetaError(`\`openspec update\` failed${typeof err.status === "number" ? ` with exit code ${err.status}` : ""}. Fix the OpenSpec errors above and re-run \`meta sync\`.`, EXIT_CODES.CHECK_FAILED);
+                }
             }
         }
     }

package/dist/core/checklist.d.ts

@@ -0,0 +1,31 @@
+/**
+ * A checklist mixes two kinds of items: "auto" items are evaluated by the
+ * CLI against the repository (pass/fail), "manual" items require a human
+ * and stay pending until confirmed.
+ */
+export interface ChecklistItem {
+    id: string;
+    section: string;
+    text: string;
+    kind: "auto" | "manual";
+    status: "pass" | "fail" | "pending" | "confirmed" | "declined";
+    /** Supporting evidence, e.g. offending files for a failed auto item. */
+    details?: string[];
+}
+export declare function printChecklist(title: string, items: ChecklistItem[]): void;
+export declare function checklistToJson(items: ChecklistItem[]): {
+    items: {
+        id: string;
+        section: string;
+        text: string;
+        kind: "auto" | "manual";
+        status: "fail" | "pass" | "pending" | "confirmed" | "declined";
+        details: string[];
+    }[];
+    summary: {
+        total: number;
+        auto_passed: number;
+        auto_failed: number;
+        pending: number;
+    };
+};

package/dist/core/checklist.js

@@ -0,0 +1,43 @@
+import pc from "picocolors";
+const MAX_DETAILS = 10;
+export function printChecklist(title, items) {
+    console.log(pc.bold(title));
+    const sections = [...new Set(items.map((i) => i.section))];
+    for (const section of sections) {
+        console.log();
+        console.log(pc.bold(section));
+        for (const item of items.filter((i) => i.section === section)) {
+            const mark = item.status === "pass" || item.status === "confirmed"
+                ? pc.green("✓")
+                : item.status === "fail" || item.status === "declined"
+                    ? pc.red("✗")
+                    : pc.yellow("☐");
+            console.log(`  ${mark} ${item.text}`);
+            const details = item.details ?? [];
+            for (const d of details.slice(0, MAX_DETAILS))
+                console.log(`      - ${d}`);
+            if (details.length > MAX_DETAILS) {
+                console.log(`      … and ${details.length - MAX_DETAILS} more`);
+            }
+        }
+    }
+    console.log();
+}
+export function checklistToJson(items) {
+    return {
+        items: items.map(({ id, section, text, kind, status, details }) => ({
+            id,
+            section,
+            text,
+            kind,
+            status,
+            details: details ?? [],
+        })),
+        summary: {
+            total: items.length,
+            auto_passed: items.filter((i) => i.status === "pass").length,
+            auto_failed: items.filter((i) => i.status === "fail").length,
+            pending: items.filter((i) => i.status === "pending").length,
+        },
+    };
+}

package/dist/core/deploy-packs.d.ts

@@ -0,0 +1,11 @@
+import type { McpPack } from "./mcp-packs.js";
+/**
+ * Deployment packs are skills-only packs (no MCP server, no plugin settings):
+ * installing one copies a deploy skill into `.claude/skills/` and appends its
+ * working rules to a freshly generated AGENTS.md. They reuse the McpPack
+ * shape so `installMcpPack` / `listPackSkillFiles` work unchanged.
+ */
+export declare const DEPLOY_PACKS: Record<string, McpPack>;
+/** Valid values for `--with-deploy`; 'none' means skip deployment integration. */
+export declare const DEPLOY_TARGETS: string[];
+export declare function getDeployPack(target: string): McpPack;

package/dist/core/deploy-packs.js

@@ -0,0 +1,42 @@
+import { EXIT_CODES, MetaError } from "./errors.js";
+/**
+ * Deployment packs are skills-only packs (no MCP server, no plugin settings):
+ * installing one copies a deploy skill into `.claude/skills/` and appends its
+ * working rules to a freshly generated AGENTS.md. They reuse the McpPack
+ * shape so `installMcpPack` / `listPackSkillFiles` work unchanged.
+ */
+export const DEPLOY_PACKS = {
+    cloudflare: {
+        name: "deploy-cloudflare",
+        title: "Cloudflare（本地 wrangler CLI）",
+        hasSkills: true,
+        agentRules: [
+            "Deploy via the deploy-cloudflare skill (local wrangler CLI). Run the project's build and tests before any deploy; manage secrets with `wrangler secret put`, never commit them.",
+        ],
+    },
+    ansible: {
+        name: "deploy-ansible",
+        title: "云主机（Ansible playbook；Windows 下用 Docker 运行 Ansible）",
+        hasSkills: true,
+        agentRules: [
+            "Deploy to cloud hosts via the deploy-ansible skill (ansible-playbook; on Windows run Ansible through Docker). Always dry-run with `--check` first; keep secrets in ansible-vault.",
+        ],
+    },
+    "github-actions": {
+        name: "deploy-github-actions",
+        title: "GitHub Workflow（GitHub Actions CI/CD）",
+        hasSkills: true,
+        agentRules: [
+            "Deploy via the deploy-github-actions skill (GitHub Actions). The deploy job must depend on passing build and tests; repository secrets belong in GitHub Actions secrets, never in workflow files.",
+        ],
+    },
+};
+/** Valid values for `--with-deploy`; 'none' means skip deployment integration. */
+export const DEPLOY_TARGETS = [...Object.keys(DEPLOY_PACKS), "none"];
+export function getDeployPack(target) {
+    const pack = DEPLOY_PACKS[target];
+    if (!pack) {
+        throw new MetaError(`Unknown deploy target '${target}'. Valid targets: ${DEPLOY_TARGETS.join(", ")}`, EXIT_CODES.BAD_ARGS);
+    }
+    return pack;
+}

package/dist/core/doc-scopes.d.ts

@@ -0,0 +1,18 @@
+import type { MetaConfig } from "../schemas/config.schema.js";
+/**
+ * Named documentation scopes for repository maintenance. The human confirms
+ * which scopes to tidy in a given review round (`meta review --pick-docs`).
+ */
+export interface DocScope {
+    key: string;
+    title: string;
+    /** Paths relative to the repo root (resolved from config where possible). */
+    paths: string[];
+}
+export interface ResolvedDocScope extends DocScope {
+    exists: boolean;
+    /** Markdown files currently in the scope. */
+    files: string[];
+}
+export declare function docScopes(config: MetaConfig): DocScope[];
+export declare function resolveDocScopes(root: string, config: MetaConfig): ResolvedDocScope[];

package/dist/core/doc-scopes.js

@@ -0,0 +1,55 @@
+import fs from "node:fs";
+import path from "node:path";
+import { listDomainDirs } from "../validators/domain-validator.js";
+function listMarkdownFiles(abs) {
+    if (!fs.existsSync(abs))
+        return [];
+    if (fs.statSync(abs).isFile())
+        return abs.endsWith(".md") ? [abs] : [];
+    const out = [];
+    for (const entry of fs.readdirSync(abs, { withFileTypes: true })) {
+        const child = path.join(abs, entry.name);
+        if (entry.isDirectory())
+            out.push(...listMarkdownFiles(child));
+        else if (entry.name.endsWith(".md"))
+            out.push(child);
+    }
+    return out;
+}
+export function docScopes(config) {
+    const docs = config.paths.docs;
+    return [
+        {
+            key: "product",
+            title: "产品文档（PRD / 需求）",
+            paths: [path.join(docs, "product"), path.join(docs, "prd.md")],
+        },
+        { key: "architecture", title: "技术架构文档", paths: [path.join(docs, "architecture")] },
+        { key: "api", title: "接口文档（API）", paths: [path.join(docs, "api")] },
+        { key: "domain", title: "领域文档（业务规则）", paths: [config.paths.domain_docs] },
+        { key: "adr", title: "架构决策记录（ADR）", paths: [config.paths.adr_docs] },
+        {
+            key: "engineering",
+            title: "工程规范（测试 / 硬限制）",
+            paths: [path.join(docs, "engineering")],
+        },
+        { key: "runbooks", title: "运维手册（Runbooks）", paths: [path.join(docs, "runbooks")] },
+        { key: "agents", title: "Agent 规则（AGENTS.md）", paths: [config.paths.root_agents] },
+        { key: "openspec", title: "OpenSpec specs", paths: [path.join(config.paths.openspec, "specs")] },
+    ];
+}
+export function resolveDocScopes(root, config) {
+    return docScopes(config).map((scope) => {
+        const files = scope.paths.flatMap((rel) => listMarkdownFiles(path.join(root, rel)).map((abs) => path.relative(root, abs)));
+        // Local AGENTS.md files belong to the agents scope.
+        if (scope.key === "agents") {
+            for (const domain of listDomainDirs(root, config.paths.domain_docs)) {
+                const rel = path.join(config.paths.domain_docs, domain, "AGENTS.md");
+                if (fs.existsSync(path.join(root, rel)))
+                    files.push(rel);
+            }
+        }
+        const exists = scope.paths.some((rel) => fs.existsSync(path.join(root, rel)));
+        return { ...scope, exists, files: files.sort() };
+    });
+}

package/dist/core/filesystem.js

@@ -1,5 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
+import { EXIT_CODES, MetaError } from "./errors.js";
 /**
  * All file writes go through this class so that --dry-run can report the
  * exact set of files that would be created or updated without touching disk.
@@ -16,7 +17,14 @@ export class FileWriter {
         return path.isAbsolute(p) ? path.relative(this.root, p) : p;
     }
     abs(p) {
-        return path.isAbsolute(p) ? p : path.join(this.root, p);
+        const abs = path.resolve(this.root, p);
+        const root = path.resolve(this.root);
+        // Paths come from user config (paths.*) and CLI flags; never let a
+        // `../`-style value escape the project root.
+        if (abs !== root && !abs.startsWith(root + path.sep)) {
+            throw new MetaError(`Path '${p}' resolves outside the project root. Check paths.* in agent-meta.config.yaml.`, EXIT_CODES.BAD_ARGS);
+        }
+        return abs;
     }
     exists(p) {
         return fs.existsSync(this.abs(p));

package/dist/core/frontmatter.d.ts

@@ -1,3 +1,5 @@
+/** Heading names (contains-match, case-insensitive) that declare hard constraints. */
+export declare const HARD_CONSTRAINT_HEADINGS: string[];
 export interface ParsedDoc {
     file: string;
     data: Record<string, unknown>;
@@ -10,6 +12,11 @@ export declare function parseDocFile(absPath: string): ParsedDoc;
 export declare function extractHeadings(content: string): string[];
 /** True if any heading contains one of the given texts (case-insensitive). */
 export declare function hasSection(content: string, names: string[]): boolean;
+/**
+ * Body text of the first section whose heading matches one of the given
+ * names (HTML comments stripped, trimmed). Null when no heading matches.
+ */
+export declare function extractSection(content: string, names: string[]): string | null;
 /**
  * True if there is any non-empty, non-comment body text under a matching
  * heading. Sub-headings (deeper levels) belong to the section, so their body

package/dist/core/frontmatter.js

@@ -1,5 +1,7 @@
 import fs from "node:fs";
 import matter from "gray-matter";
+/** Heading names (contains-match, case-insensitive) that declare hard constraints. */
+export const HARD_CONSTRAINT_HEADINGS = ["硬限制", "hard constraint"];
 export function parseDocFile(absPath) {
     const raw = fs.readFileSync(absPath, "utf8");
     const hasFrontmatter = /^---\r?\n/.test(raw);
@@ -45,6 +47,39 @@ export function hasSection(content, names) {
     const headings = extractHeadings(content).map((h) => h.toLowerCase());
     return names.some((n) => headings.some((h) => h.includes(n.toLowerCase())));
 }
+/**
+ * Body text of the first section whose heading matches one of the given
+ * names (HTML comments stripped, trimmed). Null when no heading matches.
+ */
+export function extractSection(content, names) {
+    const lines = content.split(/\r?\n/);
+    let capturing = false;
+    let sectionLevel = 0;
+    let inFence = false;
+    let found = false;
+    const out = [];
+    for (const line of lines) {
+        if (/^\s*(```|~~~)/.test(line))
+            inFence = !inFence;
+        const m = !inFence ? /^(#{1,6})\s+(.+?)\s*$/.exec(line) : null;
+        if (m) {
+            const level = m[1].length;
+            if (!found && names.some((n) => m[2].toLowerCase().includes(n.toLowerCase()))) {
+                capturing = true;
+                found = true;
+                sectionLevel = level;
+                continue;
+            }
+            if (capturing && level <= sectionLevel)
+                capturing = false;
+        }
+        if (capturing)
+            out.push(line);
+    }
+    if (!found)
+        return null;
+    return out.join("\n").replace(/<!--[\s\S]*?-->/g, "").trim();
+}
 /**
  * True if there is any non-empty, non-comment body text under a matching
  * heading. Sub-headings (deeper levels) belong to the section, so their body
@@ -56,6 +91,7 @@ export function sectionHasContent(content, names) {
     let capturing = false;
     let sectionLevel = 0;
     let inFence = false;
+    const captured = [];
     for (const line of lines) {
         if (/^\s*(```|~~~)/.test(line))
             inFence = !inFence;
@@ -71,14 +107,14 @@ export function sectionHasContent(content, names) {
             }
             continue;
         }
-        if (!capturing)
-            continue;
-        const text = line
-            .replace(/<!--[\s\S]*?-->/g, "")
-            .replace(/^[-*+]\s*/, "")
-            .trim();
-        if (text.length > 0 && !/^<!--/.test(line.trim()))
-            return true;
+        if (capturing)
+            captured.push(line);
     }
-    return false;
+    // Strip comments across line boundaries (like extractSection does), so a
+    // comment spanning multiple lines never counts as content.
+    return captured
+        .join("\n")
+        .replace(/<!--[\s\S]*?-->/g, "")
+        .split(/\r?\n/)
+        .some((line) => line.replace(/^[-*+]\s*/, "").trim().length > 0);
 }

package/dist/core/mcp-packs.d.ts

@@ -0,0 +1,26 @@
+/**
+ * An MCP pack bundles a remote MCP server endpoint with the project-level
+ * skills that teach agents how to use it. Installing a pack writes the
+ * server into `.mcp.json` and copies the skills into `.claude/skills/`,
+ * keeping everything repository-scoped (no user-level/global tooling).
+ */
+export interface McpPack {
+    name: string;
+    title: string;
+    /** Entry written verbatim into `.mcp.json` under mcpServers[name]. */
+    server?: Record<string, unknown>;
+    /** Whether the pack bundles skills under assets/skills/<name>/. */
+    hasSkills: boolean;
+    /** Merged into `.claude/settings.json` (existing values always win). */
+    settings?: Record<string, unknown>;
+    /** Rules appended to the root AGENTS.md Working Rules when installed via init. */
+    agentRules?: string[];
+}
+export declare const MCP_PACKS: Record<string, McpPack>;
+/** Human-readable one-liner of what the pack installs. */
+export declare function packServerSummary(pack: McpPack): string;
+export declare function getMcpPack(name: string): McpPack;
+/** Bundled skills live under <package root>/assets/skills/<pack>/. */
+export declare function packSkillsDir(pack: McpPack): string;
+/** Skill files of a pack as [relative path under .claude/skills/, absolute source path]. */
+export declare function listPackSkillFiles(pack: McpPack): [string, string][];

package/dist/core/mcp-packs.js

@@ -0,0 +1,86 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { EXIT_CODES, MetaError } from "./errors.js";
+export const MCP_PACKS = {
+    ironbank: {
+        name: "ironbank",
+        title: "IronBank MCP (hillinsight)",
+        server: { type: "http", url: "https://test-ib-mcp.hillinsight.tech/mcp" },
+        hasSkills: true,
+        agentRules: [
+            "Project docs and bug reports live in IronBank and are referenced by `hillinsight://ib_note?...` deep links. When you encounter one, resolve it with the IronBank MCP (see the ironbank-note-links skill) instead of skipping it; when citing IronBank notes in docs or replies, emit links in the same format.",
+        ],
+    },
+    playwright: {
+        name: "playwright",
+        title: "Playwright MCP (browser automation, microsoft/playwright-mcp)",
+        server: { command: "npx", args: ["@playwright/mcp@latest"] },
+        hasSkills: false,
+    },
+    superpowers: {
+        name: "superpowers",
+        title: "Superpowers (obra/superpowers, Claude Code plugin: planning/TDD/debugging skills)",
+        hasSkills: false,
+        settings: {
+            extraKnownMarketplaces: {
+                "superpowers-marketplace": {
+                    source: { source: "github", repo: "obra/superpowers-marketplace" },
+                },
+            },
+            enabledPlugins: {
+                "superpowers@superpowers-marketplace": true,
+            },
+        },
+        agentRules: [
+            "Do not use the Superpowers brainstorming skill during development unless the human explicitly asks for it.",
+        ],
+    },
+};
+/** Human-readable one-liner of what the pack installs. */
+export function packServerSummary(pack) {
+    if (pack.server) {
+        const { url, command, args } = pack.server;
+        if (url)
+            return url;
+        return [command, ...(args ?? [])].filter(Boolean).join(" ");
+    }
+    if (pack.settings)
+        return "Claude Code plugin (.claude/settings.json)";
+    return "skills only";
+}
+export function getMcpPack(name) {
+    const pack = MCP_PACKS[name];
+    if (!pack) {
+        throw new MetaError(`Unknown MCP pack '${name}'. Available packs: ${Object.keys(MCP_PACKS).join(", ")}`, EXIT_CODES.BAD_ARGS);
+    }
+    return pack;
+}
+/** Bundled skills live under <package root>/assets/skills/<pack>/. */
+export function packSkillsDir(pack) {
+    return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../assets/skills", pack.name);
+}
+/** Skill files of a pack as [relative path under .claude/skills/, absolute source path]. */
+export function listPackSkillFiles(pack) {
+    if (!pack.hasSkills)
+        return [];
+    const dir = packSkillsDir(pack);
+    if (!fs.existsSync(dir)) {
+        throw new MetaError(`Bundled skills for MCP pack '${pack.name}' not found at ${dir}. The CLI installation may be corrupted.`, EXIT_CODES.TEMPLATE_ERROR);
+    }
+    const out = [];
+    const walk = (abs, rel) => {
+        for (const entry of fs.readdirSync(abs, { withFileTypes: true })) {
+            if (entry.name === ".DS_Store")
+                continue;
+            const childAbs = path.join(abs, entry.name);
+            const childRel = rel ? path.join(rel, entry.name) : entry.name;
+            if (entry.isDirectory())
+                walk(childAbs, childRel);
+            else
+                out.push([childRel, childAbs]);
+        }
+    };
+    walk(dir, "");
+    return out.sort((a, b) => a[0].localeCompare(b[0]));
+}

package/dist/generators/adr-generator.js

@@ -1,6 +1,8 @@
 import fs from "node:fs";
 import path from "node:path";
-export const ADR_FILE_RE = /^(\d{4,})-(.+)\.md$/;
+// Any digit count, so files generated under a custom defaults.adr_padding
+// (schema minimum: 1) are recognized by numbering, indexing and validation.
+export const ADR_FILE_RE = /^(\d+)-(.+)\.md$/;
 export function listAdrFiles(adrDirAbs) {
     if (!fs.existsSync(adrDirAbs))
         return [];

package/dist/generators/hook-generator.d.ts

@@ -0,0 +1,14 @@
+/** The `meta check` invocation appropriate for the project's package manager. */
+export declare function metaCheckCommand(root: string): string;
+export interface LefthookResult {
+    action: "created" | "updated" | "unchanged";
+    /** Path relative to root. */
+    path: string;
+    command: string;
+}
+/**
+ * Create lefthook.yml with a pre-commit meta-check command, or add the
+ * command to an existing file. An existing meta-check entry is never
+ * overwritten.
+ */
+export declare function generateLefthookConfig(root: string, dryRun: boolean): LefthookResult;