@bossmissing/agent-meta 0.1.0 → 0.3.0

package/dist/commands/config.js

@@ -5,6 +5,8 @@ import { loadConfig, CONFIG_FILENAME } from "../core/config.js";
 import { configSchema } from "../schemas/config.schema.js";
 import { logger } from "../core/logger.js";
 import { EXIT_CODES, MetaError } from "../core/errors.js";
+import { generateLefthookConfig } from "../generators/hook-generator.js";
+import { detectPackageManager } from "./init.js";
 function flatten(obj, prefix = "") {
     if (obj === null || typeof obj !== "object" || Array.isArray(obj)) {
         return [[prefix, obj]];
@@ -57,3 +59,51 @@ export function runConfigSet(root, key, value) {
     fs.writeFileSync(configPath, YAML.stringify(doc), "utf8");
     logger.ok(`Set ${key} = ${value}`);
 }
+/** `meta config hooks lefthook` — generate or extend the lefthook config. */
+export function runConfigHooks(root, tool, opts = {}) {
+    if (tool !== "lefthook") {
+        throw new MetaError(`Unsupported hook tool '${tool}'. Only 'lefthook' is supported in this version.`, EXIT_CODES.BAD_ARGS);
+    }
+    const dryRun = Boolean(opts.dryRun);
+    const result = generateLefthookConfig(root, dryRun);
+    if (result.action === "unchanged") {
+        logger.info(`- ${result.path} already has a pre-commit meta-check command (${result.command})`);
+    }
+    else if (dryRun) {
+        logger.info(`Would ${result.action === "created" ? "create" : "update"}: ${result.path}`);
+        logger.info(`  pre-commit meta-check: ${result.command}`);
+    }
+    else {
+        logger.ok(`${result.action === "created" ? "Created" : "Updated"} ${result.path}`);
+        logger.info(`  pre-commit meta-check: ${result.command}`);
+    }
+    // Record the choice in agent-meta.config.yaml when it exists.
+    const configPath = path.join(root, CONFIG_FILENAME);
+    if (!dryRun && fs.existsSync(configPath)) {
+        const doc = YAML.parse(fs.readFileSync(configPath, "utf8")) ?? {};
+        if (typeof doc.features !== "object" || doc.features === null)
+            doc.features = {};
+        if (doc.features.hooks !== true) {
+            doc.features.hooks = true;
+            fs.writeFileSync(configPath, YAML.stringify(doc), "utf8");
+            logger.ok("Set features.hooks = true");
+        }
+    }
+    if (result.action !== "unchanged") {
+        const pm = detectPackageManager(root);
+        logger.blank();
+        logger.info("Next steps:");
+        if (pm === "pnpm") {
+            logger.info("  pnpm add -D lefthook && pnpm exec lefthook install");
+        }
+        else if (pm === "yarn") {
+            logger.info("  yarn add -D lefthook && yarn exec lefthook install");
+        }
+        else if (pm === "npm") {
+            logger.info("  npm i -D lefthook && npx lefthook install");
+        }
+        else {
+            logger.info("  Install lefthook and run: lefthook install");
+        }
+    }
+}

package/dist/commands/doctor.d.ts

@@ -0,0 +1,14 @@
+export type DoctorStatus = "ok" | "warn" | "fail";
+export interface DoctorCheck {
+    name: string;
+    status: DoctorStatus;
+    message: string;
+    suggestion?: string;
+}
+export interface DoctorOptions {
+    json?: boolean;
+    /** Skip external binary probes (used by tests). */
+    execChecks?: boolean;
+}
+export declare function collectDoctorChecks(root: string, opts?: DoctorOptions): DoctorCheck[];
+export declare function runDoctor(root: string, opts?: DoctorOptions): number;

package/dist/commands/doctor.js

@@ -0,0 +1,187 @@
+import fs from "node:fs";
+import path from "node:path";
+import { execSync } from "node:child_process";
+import pc from "picocolors";
+import { loadConfig, CONFIG_FILENAME } from "../core/config.js";
+import { DEFAULT_CONFIG } from "../schemas/config.schema.js";
+import { detectPackageManager, detectProjectType } from "./init.js";
+import { MetaError } from "../core/errors.js";
+/** Version string of an external CLI, or null when it is not available. */
+function commandVersion(cmd) {
+    try {
+        const out = execSync(`${cmd} --version`, { stdio: ["ignore", "pipe", "ignore"] })
+            .toString()
+            .trim();
+        return out.split("\n")[0] || "installed";
+    }
+    catch {
+        return null;
+    }
+}
+export function collectDoctorChecks(root, opts = {}) {
+    const execChecks = opts.execChecks !== false;
+    const checks = [];
+    // Runtime
+    const nodeMajor = parseInt(process.versions.node.split(".")[0], 10);
+    checks.push(nodeMajor >= 20
+        ? { name: "node", status: "ok", message: `Node.js ${process.versions.node}` }
+        : {
+            name: "node",
+            status: "fail",
+            message: `Node.js ${process.versions.node} is too old`,
+            suggestion: "Agent Meta CLI requires Node.js >= 20.",
+        });
+    const pm = detectPackageManager(root);
+    checks.push({
+        name: "package-manager",
+        status: "ok",
+        message: pm === "none" ? "No package.json (bare repository)" : `Package manager: ${pm}`,
+    });
+    checks.push({
+        name: "project-type",
+        status: "ok",
+        message: `Project type: ${detectProjectType(root)}`,
+    });
+    // Config
+    let config = DEFAULT_CONFIG;
+    let configFound = false;
+    try {
+        const loaded = loadConfig(root);
+        config = loaded.config;
+        configFound = loaded.configPath !== null;
+        checks.push(configFound
+            ? { name: "config", status: "ok", message: `${CONFIG_FILENAME} is valid` }
+            : {
+                name: "config",
+                status: "warn",
+                message: `${CONFIG_FILENAME} not found (using built-in defaults)`,
+                suggestion: "Run `meta init` to create it.",
+            });
+    }
+    catch (e) {
+        checks.push({
+            name: "config",
+            status: "fail",
+            message: e instanceof MetaError ? e.message : `Cannot load ${CONFIG_FILENAME}`,
+            suggestion: `Fix or regenerate ${CONFIG_FILENAME}.`,
+        });
+    }
+    // Declared paths
+    const pathChecks = [
+        ["paths.root_agents", config.paths.root_agents, "Run `meta init` to create it."],
+        ["paths.docs", config.paths.docs, "Run `meta init` to create the docs skeleton."],
+        ["paths.domain_docs", config.paths.domain_docs, "Run `meta new-domain <name>` to create the first domain."],
+        ["paths.adr_docs", config.paths.adr_docs, "Run `meta new-adr <slug>` to create the first ADR."],
+    ];
+    for (const [name, rel, suggestion] of pathChecks) {
+        checks.push(fs.existsSync(path.join(root, rel))
+            ? { name, status: "ok", message: `${rel} exists` }
+            : { name, status: "warn", message: `${rel} does not exist`, suggestion });
+    }
+    const templatesAbs = path.join(root, config.paths.templates);
+    checks.push({
+        name: "paths.templates",
+        status: "ok",
+        message: fs.existsSync(templatesAbs)
+            ? `Project template overrides found at ${config.paths.templates}`
+            : "No template overrides (using built-in templates)",
+    });
+    // Git & hooks
+    const isGitRepo = fs.existsSync(path.join(root, ".git"));
+    checks.push(isGitRepo
+        ? { name: "git", status: "ok", message: "Git repository detected" }
+        : {
+            name: "git",
+            status: "warn",
+            message: "Not a git repository",
+            suggestion: "Run `git init` to enable git hooks and CI checks.",
+        });
+    const lefthookFile = ["lefthook.yml", "lefthook.yaml"].find((f) => fs.existsSync(path.join(root, f)));
+    if (lefthookFile) {
+        const version = execChecks ? commandVersion("lefthook") : "skipped";
+        checks.push(version
+            ? { name: "hooks", status: "ok", message: `${lefthookFile} present (lefthook: ${version})` }
+            : {
+                name: "hooks",
+                status: "warn",
+                message: `${lefthookFile} present but the lefthook CLI is not installed`,
+                suggestion: "Install it: pnpm add -D lefthook && pnpm exec lefthook install",
+            });
+    }
+    else if (fs.existsSync(path.join(root, ".husky"))) {
+        checks.push({ name: "hooks", status: "ok", message: ".husky directory detected" });
+    }
+    else if (config.features.hooks) {
+        checks.push({
+            name: "hooks",
+            status: "warn",
+            message: "features.hooks is enabled but no hook configuration was found",
+            suggestion: "Run `meta config hooks lefthook`.",
+        });
+    }
+    else {
+        checks.push({
+            name: "hooks",
+            status: "ok",
+            message: "Git hooks not configured (optional)",
+            suggestion: "Run `meta config hooks lefthook` to run `meta check` on pre-commit.",
+        });
+    }
+    // OpenSpec
+    const openspecAbs = path.join(root, config.paths.openspec);
+    if (fs.existsSync(openspecAbs)) {
+        const hasConfig = fs.existsSync(path.join(openspecAbs, "config.yaml"));
+        checks.push(hasConfig
+            ? { name: "openspec", status: "ok", message: `OpenSpec detected at ${config.paths.openspec}/` }
+            : {
+                name: "openspec",
+                status: "warn",
+                message: `${config.paths.openspec}/ exists but has no config.yaml`,
+                suggestion: "Initialize it with the OpenSpec CLI (`openspec init`).",
+            });
+        const version = execChecks ? commandVersion("openspec") : "skipped";
+        if (execChecks && !version) {
+            checks.push({
+                name: "openspec-cli",
+                status: "warn",
+                message: "OpenSpec directory exists but the `openspec` CLI is not installed",
+                suggestion: "`meta sync --openspec` needs the OpenSpec CLI on PATH.",
+            });
+        }
+    }
+    else if (config.features.openspec === true) {
+        checks.push({
+            name: "openspec",
+            status: "warn",
+            message: `features.openspec is enabled but ${config.paths.openspec}/ does not exist`,
+        });
+    }
+    else {
+        checks.push({ name: "openspec", status: "ok", message: "OpenSpec not detected (optional)" });
+    }
+    return checks;
+}
+export function runDoctor(root, opts = {}) {
+    const checks = collectDoctorChecks(root, opts);
+    const summary = {
+        ok: checks.filter((c) => c.status === "ok").length,
+        warnings: checks.filter((c) => c.status === "warn").length,
+        failures: checks.filter((c) => c.status === "fail").length,
+    };
+    if (opts.json) {
+        console.log(JSON.stringify({ checks, summary }, null, 2));
+    }
+    else {
+        console.log(pc.bold("Agent Meta Doctor"));
+        console.log();
+        for (const c of checks) {
+            const mark = c.status === "ok" ? pc.green("✓") : c.status === "warn" ? pc.yellow("WARN") : pc.red("✗");
+            console.log(`${mark} ${c.message}`);
+            if (c.suggestion && c.status !== "ok")
+                console.log(`  → ${c.suggestion}`);
+        }
+        console.log();
+        console.log(`Checks: ${checks.length}  OK: ${summary.ok}  Warnings: ${summary.warnings}  Failures: ${summary.failures}`);
+    }
+    return summary.failures > 0 ? 1 : 0;
+}

package/dist/commands/init.d.ts

@@ -1,6 +1,10 @@
 export interface InitOptions {
     yes?: boolean;
     type?: string;
+    /** Comma-separated MCP pack names to install, e.g. "ironbank,playwright". */
+    withMcp?: string;
+    /** Deployment integration: cloudflare | ansible | github-actions | none. */
+    withDeploy?: string;
     dryRun?: boolean;
 }
 export declare function detectProjectType(root: string): string;

package/dist/commands/init.js

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import YAML from "yaml";
-import { input, select } from "@inquirer/prompts";
+import { checkbox, input, select } from "@inquirer/prompts";
 import { FileWriter } from "../core/filesystem.js";
 import { logger } from "../core/logger.js";
 import { renderNamedTemplate } from "../core/templates.js";
@@ -9,6 +9,9 @@ import { todayISO } from "../core/paths.js";
 import { configSchema, DEFAULT_CONFIG } from "../schemas/config.schema.js";
 import { CONFIG_FILENAME, configExists } from "../core/config.js";
 import { padAdrNumber } from "../generators/adr-generator.js";
+import { installMcpPack } from "../generators/mcp-generator.js";
+import { getMcpPack, packServerSummary, MCP_PACKS } from "../core/mcp-packs.js";
+import { getDeployPack, DEPLOY_PACKS } from "../core/deploy-packs.js";
 import { EXIT_CODES, MetaError } from "../core/errors.js";
 const PROJECT_TYPES = ["node", "monorepo", "nextjs", "cocos", "backend", "other"];
 export function detectProjectType(root) {
@@ -73,6 +76,38 @@ export async function runInit(root, opts) {
             });
         }
     }
+    // Optional MCP packs (project-scoped .mcp.json + .claude/skills/).
+    let mcpPacks = [
+        ...new Set((opts.withMcp ?? "")
+            .split(",")
+            .map((s) => s.trim())
+            .filter(Boolean)),
+    ].map(getMcpPack);
+    if (mcpPacks.length === 0 && !opts.yes) {
+        const picks = await checkbox({
+            message: "选择要安装的工具包（MCP / 插件 / skills，全部项目级，回车跳过）：",
+            choices: Object.values(MCP_PACKS).map((p) => ({ name: p.title, value: p.name })),
+        });
+        mcpPacks = picks.map(getMcpPack);
+    }
+    // Deployment integration: installs a deploy skill into .claude/skills/.
+    let deployTarget = opts.withDeploy?.trim();
+    if (deployTarget && deployTarget !== "none") {
+        getDeployPack(deployTarget); // fail fast on unknown targets, before any write
+    }
+    if (!deployTarget && !opts.yes) {
+        deployTarget = await select({
+            message: "部署方式（安装对应的部署 skill，可稍后再加）：",
+            choices: [
+                ...Object.entries(DEPLOY_PACKS).map(([value, p]) => ({ name: p.title, value })),
+                { name: "暂时不集成部署", value: "none" },
+            ],
+            default: "none",
+        });
+    }
+    const deployPack = deployTarget && deployTarget !== "none" ? getDeployPack(deployTarget) : null;
+    const allPacks = deployPack ? [...mcpPacks, deployPack] : mcpPacks;
+    const packRules = allPacks.flatMap((p) => p.agentRules ?? []);
     // Existing AGENTS.md handling.
     const agentsRel = DEFAULT_CONFIG.paths.root_agents;
     let agentsAction = writer.exists(agentsRel) ? "keep" : "create";
@@ -110,6 +145,7 @@ export async function runInit(root, opts) {
         project_type: projectType,
         package_manager: packageManager,
         main_paths: "src/",
+        extra_rules: packRules.length > 0 ? packRules.map((r) => `- ${r}`).join("\n") + "\n" : "",
     };
     if (agentsAction === "backup") {
         writer.backup(agentsRel);
@@ -132,10 +168,14 @@ export async function runInit(root, opts) {
     writer.write("docs/architecture/system-overview.md", renderNamedTemplate("system-overview.md", root, templatesDir, vars));
     writer.write("docs/api/conventions.md", renderNamedTemplate("api-conventions.md", root, templatesDir, vars));
     writer.write("docs/engineering/testing.md", renderNamedTemplate("engineering-testing.md", root, templatesDir, vars));
+    writer.write("docs/engineering/constraints.md", renderNamedTemplate("engineering-constraints.md", root, templatesDir, vars));
     writer.write("docs/runbooks/README.md", renderNamedTemplate("runbooks-readme.md", root, templatesDir, vars));
     // 4. First ADR
     const adrNumber = padAdrNumber(1, DEFAULT_CONFIG.defaults.adr_padding);
     writer.write(`docs/adr/${adrNumber}-repository-conventions.md`, renderNamedTemplate("adr-0001.md", root, templatesDir, { adr_number: adrNumber, owner, date }));
+    // 5. Optional MCP packs and deploy skill
+    for (const pack of allPacks)
+        installMcpPack(writer, root, pack);
     // Report
     if (dryRun) {
         const created = writer.created();
@@ -171,6 +211,22 @@ export async function runInit(root, opts) {
     if (fs.existsSync(path.join(root, DEFAULT_CONFIG.paths.openspec))) {
         logger.ok(`OpenSpec detected at ${DEFAULT_CONFIG.paths.openspec}/`);
     }
+    for (const pack of allPacks) {
+        logger.ok(`Pack '${pack.name}' installed: ${packServerSummary(pack)}`);
+    }
+    if (allPacks.length > 0) {
+        const artifacts = [
+            allPacks.some((p) => p.server) ? ".mcp.json" : "",
+            allPacks.some((p) => p.settings) ? ".claude/settings.json" : "",
+            allPacks.some((p) => p.hasSkills) ? ".claude/skills/" : "",
+        ].filter(Boolean);
+        logger.info(`  Commit ${artifacts.join(", ")} so the whole team gets the same tools.`);
+    }
+    if (packRules.length > 0 && agentsAction === "keep") {
+        logger.warn("AGENTS.md was kept unchanged. Add the pack rules to it manually:");
+        for (const r of packRules)
+            logger.info(`  - ${r}`);
+    }
     logger.blank();
     logger.info("Next steps:");
     logger.info("1. Fill in AGENTS.md project commands.");

package/dist/commands/new-adr.js

@@ -46,7 +46,8 @@ export function runNewAdr(root, name, opts) {
         throw new MetaError(e.message, EXIT_CODES.CHECK_FAILED);
     }
     if (config.features.generate_indexes && !opts.dryRun) {
-        updateAdrIndex(writer, root, config);
+        // Keep the index next to the ADRs, including when --path overrides the directory.
+        updateAdrIndex(writer, root, config, relDir);
     }
     if (opts.dryRun) {
         logger.info("Would create:");

package/dist/commands/new-change.d.ts

@@ -0,0 +1,12 @@
+export interface NewChangeOptions {
+    domain?: string;
+    schema?: string;
+    dryRun?: boolean;
+}
+/**
+ * Lightweight OpenSpec entry point: creates a change directory compatible
+ * with the OpenSpec layout (proposal.md / design.md / tasks.md / specs/) and
+ * adds risk-review material for high-risk domains. It never rewrites files
+ * that already exist.
+ */
+export declare function runNewChange(root: string, name: string, opts: NewChangeOptions): void;

package/dist/commands/new-change.js

@@ -0,0 +1,125 @@
+import fs from "node:fs";
+import path from "node:path";
+import { FileWriter } from "../core/filesystem.js";
+import { logger } from "../core/logger.js";
+import { loadConfig } from "../core/config.js";
+import { renderNamedTemplate } from "../core/templates.js";
+import { slugify, todayISO } from "../core/paths.js";
+import { matchRiskKeywords } from "../core/risk.js";
+import { extractSection, parseDocFile, HARD_CONSTRAINT_HEADINGS } from "../core/frontmatter.js";
+import { EXIT_CODES, MetaError } from "../core/errors.js";
+const RISK_REVIEW_POINTS = [
+    "Money representation",
+    "Idempotency",
+    "Retry behavior",
+    "Callback deduplication",
+    "Audit logging",
+    "Permission boundaries",
+    "Rollback plan",
+];
+/**
+ * Lightweight OpenSpec entry point: creates a change directory compatible
+ * with the OpenSpec layout (proposal.md / design.md / tasks.md / specs/) and
+ * adds risk-review material for high-risk domains. It never rewrites files
+ * that already exist.
+ */
+export function runNewChange(root, name, opts) {
+    const { config } = loadConfig(root);
+    if (config.features.openspec === false) {
+        throw new MetaError("features.openspec is disabled in agent-meta.config.yaml. Enable it before creating changes.", EXIT_CODES.BAD_ARGS);
+    }
+    const slug = slugify(name);
+    if (!slug) {
+        throw new MetaError(`Cannot derive a kebab-case change name from '${name}'. Use an ASCII name, e.g. add-withdrawal-review.`, EXIT_CODES.BAD_ARGS);
+    }
+    const domainSlug = opts.domain ? slugify(opts.domain) : "";
+    const openspecRel = config.paths.openspec;
+    const changeRel = path.join(openspecRel, "changes", slug);
+    const riskHits = [
+        ...new Set([
+            ...matchRiskKeywords(slug, config.risk_keywords),
+            ...matchRiskKeywords(domainSlug, config.risk_keywords),
+        ]),
+    ];
+    const withRiskReview = Boolean(opts.schema) || riskHits.length > 0;
+    const vars = {
+        change_name: slug,
+        change_title: slug,
+        domain: domainSlug,
+        date: todayISO(),
+    };
+    const writer = new FileWriter(root, Boolean(opts.dryRun));
+    const templatesDir = config.paths.templates;
+    // Existing files are skipped, never overwritten (FileWriter default).
+    writer.write(path.join(changeRel, "proposal.md"), renderNamedTemplate("change-proposal.md", root, templatesDir, vars));
+    writer.write(path.join(changeRel, "design.md"), renderNamedTemplate("change-design.md", root, templatesDir, vars));
+    writer.write(path.join(changeRel, "tasks.md"), renderNamedTemplate("change-tasks.md", root, templatesDir, vars));
+    writer.write(path.join(changeRel, "specs", ".gitkeep"), "");
+    if (withRiskReview) {
+        writer.write(path.join(changeRel, "risk-review.md"), renderNamedTemplate("change-risk-review.md", root, templatesDir, vars));
+    }
+    if (opts.schema) {
+        writer.write(path.join(changeRel, ".openspec.yaml"), `schema: ${opts.schema}\n${domainSlug ? `domain: ${domainSlug}\n` : ""}`);
+    }
+    if (opts.dryRun) {
+        logger.info("Would create:");
+        for (const a of writer.created())
+            logger.info(`  ${a.path}`);
+        for (const a of writer.skipped())
+            logger.info(`  (skip, exists) ${a.path}`);
+    }
+    else {
+        for (const a of writer.created())
+            logger.ok(`Created ${a.path}`);
+        for (const a of writer.skipped())
+            logger.info(`- Skipped ${a.path} (already exists)`);
+    }
+    if (!fs.existsSync(path.join(root, openspecRel, "config.yaml"))) {
+        logger.blank();
+        logger.warn(`${openspecRel}/config.yaml not found. If this project uses OpenSpec, initialize it with the OpenSpec CLI (\`openspec init\`).`);
+    }
+    // Domain association: point the author at the required reading.
+    if (domainSlug) {
+        const domainRel = path.join(config.paths.domain_docs, domainSlug);
+        const domainAbs = path.join(root, domainRel);
+        logger.blank();
+        if (!fs.existsSync(domainAbs)) {
+            logger.warn(`Domain directory not found: ${domainRel}\nCreate it first: meta new-domain ${domainSlug}`);
+        }
+        else {
+            const reading = ["README.md", "rules.md", "state-machine.md", "AGENTS.md"].filter((f) => fs.existsSync(path.join(domainAbs, f)));
+            logger.info("Required reading before implementing this change:");
+            for (const f of reading)
+                logger.info(`  ${path.join(domainRel, f)}`);
+            // Feed the declared hard constraints straight into the author's context.
+            const rulesAbs = path.join(domainAbs, "rules.md");
+            if (fs.existsSync(rulesAbs)) {
+                const hard = extractSection(parseDocFile(rulesAbs).content, HARD_CONSTRAINT_HEADINGS);
+                const hardLines = (hard ?? "")
+                    .split("\n")
+                    .map((l) => l.trim())
+                    .filter((l) => l && l !== "-");
+                if (hardLines.length > 0) {
+                    logger.blank();
+                    logger.info(`Declared hard constraints for '${domainSlug}' (must not be violated):`);
+                    for (const l of hardLines)
+                        logger.info(`  ${l}`);
+                }
+                else {
+                    logger.blank();
+                    logger.warn(`Domain '${domainSlug}' declares no hard constraints in rules.md (## 硬限制). Declare them before implementing this change.`);
+                }
+            }
+        }
+    }
+    if (riskHits.length > 0) {
+        logger.blank();
+        logger.warn(`⚠ Change is associated with high-risk domain: ${riskHits.join(", ")}`);
+        logger.blank();
+        logger.info("Recommended review points:");
+        for (const p of RISK_REVIEW_POINTS)
+            logger.info(`  - ${p}`);
+        logger.blank();
+        logger.info(`A risk-review.md checklist was ${opts.dryRun ? "included" : "created"} in the change directory.`);
+    }
+}

package/dist/commands/new-domain.js

@@ -95,6 +95,8 @@ export function runNewDomain(root, name, opts) {
                 logger.info(m);
             logger.blank();
         }
+        logger.info("Declare the domain's hard constraints in rules.md (## 硬限制) before implementation — undeclared limits will be treated as negotiable.");
+        logger.blank();
         logger.info("Also consider creating ADRs for:");
         logger.info("  - idempotency");
         logger.info("  - audit logging");

package/dist/commands/preflight.d.ts

@@ -0,0 +1,14 @@
+import { type ChecklistItem } from "../core/checklist.js";
+export interface PreflightOptions {
+    json?: boolean;
+    /** Interactively require a human to confirm each manual item. */
+    confirm?: boolean;
+}
+/**
+ * Pre-release checklist. `meta check --strict` runs for real; the manual
+ * items — most importantly a human confirming the code review — stay
+ * pending unless walked through with --confirm.
+ */
+export declare function buildPreflightChecklist(root: string): ChecklistItem[];
+/** Returns the process exit code. */
+export declare function runPreflight(root: string, opts?: PreflightOptions, ask?: (item: ChecklistItem) => Promise<boolean>): Promise<number>;

package/dist/commands/preflight.js

@@ -0,0 +1,103 @@
+import fs from "node:fs";
+import path from "node:path";
+import { confirm } 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 { parseDocFile, sectionHasContent, HARD_CONSTRAINT_HEADINGS, } from "../core/frontmatter.js";
+import { printChecklist, checklistToJson } from "../core/checklist.js";
+import { logger } from "../core/logger.js";
+const AUTO = "Deterministic checks";
+const MANUAL = "Human sign-off required";
+/**
+ * Pre-release checklist. `meta check --strict` runs for real; the manual
+ * items — most importantly a human confirming the code review — stay
+ * pending unless walked through with --confirm.
+ */
+export function buildPreflightChecklist(root) {
+    const { config } = loadConfig(root);
+    const result = runCheck(root, {});
+    const strictPass = result.summary.errors === 0 && result.summary.warnings === 0;
+    const domains = listDomainDirs(root, config.paths.domain_docs);
+    const highRisk = domains.filter((d) => isHighRisk(d, config.risk_keywords));
+    // Files that declare hard constraints — the reviewer checks the release
+    // against exactly these.
+    const hardConstraintFiles = [];
+    for (const d of domains) {
+        const rel = path.join(config.paths.domain_docs, d, "rules.md");
+        const abs = path.join(root, rel);
+        if (fs.existsSync(abs) && sectionHasContent(parseDocFile(abs).content, HARD_CONSTRAINT_HEADINGS)) {
+            hardConstraintFiles.push(rel);
+        }
+    }
+    const constraintsRel = path.join(config.paths.docs, "engineering", "constraints.md");
+    const constraintsAbs = path.join(root, constraintsRel);
+    if (fs.existsSync(constraintsAbs) &&
+        sectionHasContent(parseDocFile(constraintsAbs).content, HARD_CONSTRAINT_HEADINGS)) {
+        hardConstraintFiles.push(constraintsRel);
+    }
+    const manual = (id, text, details) => ({
+        id,
+        section: MANUAL,
+        text,
+        kind: "manual",
+        status: "pending",
+        details,
+    });
+    return [
+        {
+            id: "pre-meta-check",
+            section: AUTO,
+            text: "`meta check --strict` passes",
+            kind: "auto",
+            status: strictPass ? "pass" : "fail",
+            details: strictPass
+                ? []
+                : [`errors: ${result.summary.errors}, warnings: ${result.summary.warnings}`],
+        },
+        manual("pre-code-review", "A human has reviewed and approved the code changes (not only an AI review)"),
+        manual("pre-tests", "Full test suite passes (CI is green on the release commit)"),
+        manual("pre-hard-constraints", "No change violates a declared hard constraint", hardConstraintFiles.length > 0 ? hardConstraintFiles : undefined),
+        manual("pre-highrisk", "Domain rules re-read for every touched high-risk domain", highRisk.length > 0 ? highRisk : undefined),
+        manual("pre-docs", "Docs and OpenSpec specs updated for externally observable changes"),
+        manual("pre-adr", "Long-term decisions made during this release are recorded as ADRs"),
+        manual("pre-rollback", "Rollback plan and failure paths are prepared"),
+        manual("pre-monitoring", "Monitoring, alerts and audit logging are in place for new behavior"),
+    ];
+}
+/** Returns the process exit code. */
+export async function runPreflight(root, opts = {}, ask = (item) => confirm({ message: item.text, default: false })) {
+    const items = buildPreflightChecklist(root);
+    const autoFailed = items.some((i) => i.kind === "auto" && i.status === "fail");
+    if (opts.confirm) {
+        printChecklist("Pre-release Checklist", items);
+        if (autoFailed) {
+            logger.error("Deterministic checks failed — fix them before asking for human sign-off.");
+            return 1;
+        }
+        let declined = false;
+        for (const item of items.filter((i) => i.kind === "manual")) {
+            const yes = await ask(item);
+            item.status = yes ? "confirmed" : "declined";
+            if (!yes)
+                declined = true;
+        }
+        console.log();
+        printChecklist("Pre-release Checklist — result", items);
+        if (declined) {
+            logger.error("Not ready to release: some items were not confirmed.");
+            return 1;
+        }
+        logger.ok("All items confirmed. Ready to release.");
+        return 0;
+    }
+    if (opts.json) {
+        console.log(JSON.stringify(checklistToJson(items), null, 2));
+    }
+    else {
+        printChecklist("Pre-release Checklist", items);
+        console.log("Run `meta preflight --confirm` to walk through human sign-off.");
+    }
+    return autoFailed ? 1 : 0;
+}