ai-policy-pack-cli 0.1.0

package/README.md

@@ -0,0 +1,87 @@
+# AI Policy Pack CLI
+
+`ai-policy-pack-cli` is a multi-IDE policy generator that renders instruction files for:
+
+- Cursor (`.cursor/rules/*.mdc`)
+- GitHub Copilot (`.github/copilot-instructions.md`, `.github/instructions/*.instructions.md`)
+- Antigravity (`AGENTS.md`, optional `GEMINI.md`)
+- Claude-compatible tools (`CLAUDE.md`)
+
+The CLI uses one canonical policy preset and maps it into each target format.
+
+## Quick Start
+
+```bash
+npx ai-policy-pack-cli install
+```
+
+Non-interactive mode:
+
+```bash
+npx ai-policy-pack-cli install --targets cursor,copilot,antigravity,claude --yes
+```
+
+## Commands
+
+### Install
+
+```bash
+npx ai-policy-pack-cli install [--targets cursor,copilot,antigravity,claude] [--preset karpathy] [--yes] [--dry-run]
+```
+
+- Generates target files from preset
+- Writes `.ai-policy/manifest.json` for tracking
+
+### Verify
+
+```bash
+npx ai-policy-pack-cli verify
+```
+
+- Re-renders expected output from manifest
+- Fails if generated files drifted
+- Suitable for CI checks
+
+### Update
+
+```bash
+npx ai-policy-pack-cli update [--preset karpathy] [--yes] [--dry-run]
+```
+
+- Re-applies current targets from manifest
+- Refreshes files and manifest hashes
+
+## Presets
+
+Current default preset:
+
+- `presets/karpathy/policy.yml`
+
+Preset layout:
+
+- `globalRules`: shared guardrails
+- `fileRules`: per-pattern rules
+- `targetOverrides`: optional target-specific instructions
+
+## CI Integration
+
+Example GitHub Actions step:
+
+```yaml
+- name: Verify AI policy files
+  run: npx ai-policy-pack-cli verify
+```
+
+## Development
+
+```bash
+npm install
+npm run build
+npm test
+```
+
+## Release Guidance
+
+- Use semantic versioning for policy and renderer changes
+- Treat generated-file shape changes as minor or major depending on compatibility impact
+- Keep changelog entries grouped by target (`cursor`, `copilot`, `antigravity`, `claude`)

package/dist/src/adapters/antigravity.js

@@ -0,0 +1,41 @@
+export class AntigravityAdapter {
+    render(context) {
+        const { policy } = context;
+        const files = [];
+        const override = policy.targetOverrides?.antigravity;
+        const agentsContent = [
+            "# AGENTS",
+            "",
+            "Shared rules for all compatible AI coding tools.",
+            "",
+            "## Core Rules",
+            ...policy.globalRules.map((rule) => `- ${rule}`),
+            "",
+            "## Language-Specific Rules",
+            ...policy.fileRules.flatMap((rule) => [
+                `### ${rule.name}`,
+                `Applies to: ${rule.patterns.join(", ")}`,
+                ...rule.rules.map((item) => `- ${item}`),
+                ""
+            ])
+        ].join("\n");
+        files.push({
+            path: "AGENTS.md",
+            content: `${agentsContent}\n`
+        });
+        if (override?.geminiRules && override.geminiRules.length > 0) {
+            const geminiContent = [
+                "# GEMINI",
+                "",
+                "Antigravity-specific overrides.",
+                "",
+                ...override.geminiRules.map((rule) => `- ${rule}`)
+            ].join("\n");
+            files.push({
+                path: "GEMINI.md",
+                content: `${geminiContent}\n`
+            });
+        }
+        return files;
+    }
+}

package/dist/src/adapters/claude.js

@@ -0,0 +1,27 @@
+export class ClaudeAdapter {
+    render(context) {
+        const { policy } = context;
+        const content = [
+            "# CLAUDE",
+            "",
+            "Project instructions for Claude-compatible agents.",
+            "",
+            "## Core Rules",
+            ...policy.globalRules.map((rule) => `- ${rule}`),
+            "",
+            "## File-Specific Rules",
+            ...policy.fileRules.flatMap((rule) => [
+                `### ${rule.name}`,
+                `Applies to: ${rule.patterns.join(", ")}`,
+                ...rule.rules.map((item) => `- ${item}`),
+                ""
+            ])
+        ].join("\n");
+        return [
+            {
+                path: "CLAUDE.md",
+                content: `${content}\n`
+            }
+        ];
+    }
+}

package/dist/src/adapters/copilot.js

@@ -0,0 +1,35 @@
+export class CopilotAdapter {
+    render(context) {
+        const files = [];
+        const { policy } = context;
+        const override = policy.targetOverrides?.copilot;
+        const repoWide = [
+            "# Copilot Instructions",
+            "",
+            ...(override?.repoIntro ?? []),
+            ...(override?.repoIntro?.length ? [""] : []),
+            "## Core Rules",
+            ...policy.globalRules.map((rule) => `- ${rule}`)
+        ].join("\n");
+        files.push({
+            path: ".github/copilot-instructions.md",
+            content: `${repoWide}\n`
+        });
+        for (const fileRule of policy.fileRules) {
+            const scoped = [
+                "---",
+                `applyTo: "${fileRule.patterns.join(",")}"`,
+                "---",
+                "",
+                `# ${fileRule.name}`,
+                "",
+                ...fileRule.rules.map((rule) => `- ${rule}`)
+            ].join("\n");
+            files.push({
+                path: `.github/instructions/${fileRule.name}.instructions.md`,
+                content: `${scoped}\n`
+            });
+        }
+        return files;
+    }
+}

package/dist/src/adapters/cursor.js

@@ -0,0 +1,44 @@
+export class CursorAdapter {
+    render(context) {
+        const files = [];
+        const { policy } = context;
+        const globalContent = [
+            "---",
+            "description: Global team rules generated by ai-policy-pack",
+            "alwaysApply: true",
+            "---",
+            "",
+            "# Team Global Rules",
+            "",
+            ...policy.globalRules.map((rule) => `- ${rule}`)
+        ].join("\n");
+        files.push({
+            path: ".cursor/rules/global-policy.mdc",
+            content: `${globalContent}\n`
+        });
+        for (const fileRule of policy.fileRules) {
+            const content = [
+                "---",
+                `description: ${fileRule.name} generated by ai-policy-pack`,
+                `globs: ${fileRule.patterns.join(",")}`,
+                "alwaysApply: false",
+                "---",
+                "",
+                `# ${toTitleCase(fileRule.name)}`,
+                "",
+                ...fileRule.rules.map((rule) => `- ${rule}`)
+            ].join("\n");
+            files.push({
+                path: `.cursor/rules/${fileRule.name}.mdc`,
+                content: `${content}\n`
+            });
+        }
+        return files;
+    }
+}
+function toTitleCase(value) {
+    return value
+        .split("-")
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(" ");
+}

package/dist/src/adapters/index.js

@@ -0,0 +1,21 @@
+import { AntigravityAdapter } from "./antigravity.js";
+import { ClaudeAdapter } from "./claude.js";
+import { CopilotAdapter } from "./copilot.js";
+import { CursorAdapter } from "./cursor.js";
+export function getAdapter(target) {
+    switch (target) {
+        case "cursor":
+            return new CursorAdapter();
+        case "copilot":
+            return new CopilotAdapter();
+        case "antigravity":
+            return new AntigravityAdapter();
+        case "claude":
+            return new ClaudeAdapter();
+        default:
+            return assertNever(target);
+    }
+}
+function assertNever(value) {
+    throw new Error(`Unhandled target: ${String(value)}`);
+}

package/dist/src/adapters/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/cli.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { parseArgs } from "./core/args.js";
+import { logger } from "./core/logger.js";
+import { CliError } from "./core/errors.js";
+import { runInstallCommand } from "./commands/install.js";
+import { runVerifyCommand } from "./commands/verify.js";
+import { runUpdateCommand } from "./commands/update.js";
+async function main() {
+    const cwd = process.cwd();
+    const packageVersion = await readPackageVersion(cwd);
+    const args = parseArgs(process.argv.slice(2));
+    switch (args.command) {
+        case "install":
+            await runInstallCommand(args, { cwd, packageVersion, logger });
+            return;
+        case "verify":
+            await runVerifyCommand(args, { cwd, logger });
+            return;
+        case "update":
+            await runUpdateCommand(args, { cwd, packageVersion, logger });
+            return;
+        default:
+            throw new CliError(`Unsupported command: ${String(args.command)}`);
+    }
+}
+async function readPackageVersion(cwd) {
+    const packagePath = path.join(cwd, "package.json");
+    const parsed = JSON.parse(await fs.readFile(packagePath, "utf8"));
+    return parsed.version ?? "0.0.0";
+}
+main().catch((error) => {
+    if (error instanceof CliError) {
+        logger.error(error.message);
+        process.exit(error.exitCode);
+    }
+    logger.error(error.message);
+    process.exit(1);
+});

package/dist/src/commands/install.js

@@ -0,0 +1,48 @@
+import { readFileIfExists, writeGeneratedFiles } from "../core/write-files.js";
+import { confirmAction, selectTargetsInteractive } from "../core/prompt.js";
+import { hashContent, writeManifest } from "../core/manifest.js";
+import { loadPolicyPreset } from "../core/load-policy.js";
+import { renderForTargets } from "../core/render.js";
+import { CliError } from "../core/errors.js";
+export async function runInstallCommand(args, deps) {
+    const targets = await resolveTargets(args);
+    const presetName = args.preset ?? "karpathy";
+    const policy = await loadPolicyPreset(deps.cwd, presetName);
+    const files = renderForTargets(policy, targets);
+    deps.logger.info(`Preset: ${policy.name}`);
+    deps.logger.info(`Targets: ${targets.join(", ")}`);
+    for (const file of files) {
+        const current = await readFileIfExists(deps.cwd, file.path);
+        const status = current === undefined ? "create" : current === file.content ? "unchanged" : "update";
+        deps.logger.info(`[${status}] ${file.path}`);
+    }
+    if (args.dryRun) {
+        deps.logger.info("Dry run complete. No files written.");
+        return;
+    }
+    if (!args.yes) {
+        const ok = await confirmAction("Apply generated files?");
+        if (!ok) {
+            throw new CliError("Aborted by user", 1);
+        }
+    }
+    await writeGeneratedFiles(deps.cwd, files);
+    await writeManifest(deps.cwd, {
+        schemaVersion: 1,
+        packageVersion: deps.packageVersion,
+        preset: presetName,
+        targets,
+        files: files.map((file) => ({ path: file.path, hash: hashContent(file.content) })),
+        generatedAt: new Date().toISOString()
+    });
+    deps.logger.info("Install complete.");
+}
+async function resolveTargets(args) {
+    if (args.targets && args.targets.length > 0) {
+        return args.targets;
+    }
+    if (args.yes) {
+        throw new CliError("Missing --targets in non-interactive mode. Example: --targets cursor,copilot");
+    }
+    return selectTargetsInteractive();
+}

package/dist/src/commands/update.js

@@ -0,0 +1,39 @@
+import { readManifest, writeManifest, hashContent } from "../core/manifest.js";
+import { loadPolicyPreset } from "../core/load-policy.js";
+import { renderForTargets } from "../core/render.js";
+import { writeGeneratedFiles } from "../core/write-files.js";
+import { confirmAction } from "../core/prompt.js";
+import { CliError } from "../core/errors.js";
+export async function runUpdateCommand(args, deps) {
+    const manifest = await readManifest(deps.cwd);
+    if (!manifest) {
+        throw new CliError("Manifest not found. Run install first.");
+    }
+    const presetName = args.preset || manifest.preset;
+    const preset = await loadPolicyPreset(deps.cwd, presetName);
+    const files = renderForTargets(preset, manifest.targets);
+    deps.logger.info(`Updating preset: ${preset.name}`);
+    for (const file of files) {
+        deps.logger.info(`[write] ${file.path}`);
+    }
+    if (args.dryRun) {
+        deps.logger.info("Dry run complete. No files written.");
+        return;
+    }
+    if (!args.yes) {
+        const ok = await confirmAction("Apply update?");
+        if (!ok) {
+            throw new CliError("Aborted by user", 1);
+        }
+    }
+    await writeGeneratedFiles(deps.cwd, files);
+    await writeManifest(deps.cwd, {
+        schemaVersion: 1,
+        packageVersion: deps.packageVersion,
+        preset: presetName,
+        targets: manifest.targets,
+        files: files.map((file) => ({ path: file.path, hash: hashContent(file.content) })),
+        generatedAt: new Date().toISOString()
+    });
+    deps.logger.info("Update complete.");
+}

package/dist/src/commands/verify.js

@@ -0,0 +1,46 @@
+import path from "node:path";
+import { promises as fs } from "node:fs";
+import { readManifest, hashContent } from "../core/manifest.js";
+import { loadPolicyPreset } from "../core/load-policy.js";
+import { renderForTargets } from "../core/render.js";
+import { CliError } from "../core/errors.js";
+export async function runVerifyCommand(args, deps) {
+    const manifest = await readManifest(deps.cwd);
+    if (!manifest) {
+        throw new CliError("Manifest not found. Run install first.");
+    }
+    const preset = await loadPolicyPreset(deps.cwd, manifest.preset);
+    const rendered = renderForTargets(preset, manifest.targets);
+    const renderedMap = new Map(rendered.map((file) => [file.path, file.content]));
+    const mismatches = [];
+    for (const entry of manifest.files) {
+        const expectedContent = renderedMap.get(entry.path);
+        if (!expectedContent) {
+            mismatches.push(`${entry.path} (missing from rendered output)`);
+            continue;
+        }
+        const filePath = path.join(deps.cwd, entry.path);
+        let actual = "";
+        try {
+            actual = await fs.readFile(filePath, "utf8");
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                mismatches.push(`${entry.path} (file missing)`);
+                continue;
+            }
+            throw error;
+        }
+        if (hashContent(actual) !== hashContent(expectedContent) || hashContent(expectedContent) !== entry.hash) {
+            mismatches.push(`${entry.path} (content drift)`);
+        }
+    }
+    if (mismatches.length > 0) {
+        for (const item of mismatches) {
+            deps.logger.error(item);
+        }
+        throw new CliError(`Verify failed with ${mismatches.length} mismatch(es)`, 2);
+    }
+    deps.logger.info("Verify passed.");
+    void args;
+}

package/dist/src/core/args.js

@@ -0,0 +1,74 @@
+import { CliError } from "./errors.js";
+const VALID_TARGETS = ["cursor", "copilot", "antigravity", "claude"];
+export function parseArgs(argv) {
+    const [commandRaw, ...flags] = argv;
+    if (!commandRaw) {
+        throw new CliError("Missing command. Use: install | verify | update");
+    }
+    if (!isCommand(commandRaw)) {
+        throw new CliError(`Unknown command: ${commandRaw}`);
+    }
+    let preset;
+    let targets;
+    let yes = false;
+    let dryRun = false;
+    let force = false;
+    for (let index = 0; index < flags.length; index += 1) {
+        const flag = flags[index];
+        if (flag === "--yes") {
+            yes = true;
+            continue;
+        }
+        if (flag === "--dry-run") {
+            dryRun = true;
+            continue;
+        }
+        if (flag === "--force") {
+            force = true;
+            continue;
+        }
+        if (flag === "--preset") {
+            const next = flags[index + 1];
+            if (!next) {
+                throw new CliError("--preset requires a value");
+            }
+            preset = next;
+            index += 1;
+            continue;
+        }
+        if (flag === "--targets") {
+            const next = flags[index + 1];
+            if (!next) {
+                throw new CliError("--targets requires a comma-separated value");
+            }
+            targets = parseTargets(next);
+            index += 1;
+            continue;
+        }
+        throw new CliError(`Unknown flag: ${flag}`);
+    }
+    return {
+        command: commandRaw,
+        preset,
+        targets,
+        yes,
+        dryRun,
+        force
+    };
+}
+function parseTargets(value) {
+    const raw = value.split(",").map((item) => item.trim()).filter(Boolean);
+    if (raw.length === 0) {
+        throw new CliError("--targets must not be empty");
+    }
+    const deduped = [...new Set(raw)];
+    for (const target of deduped) {
+        if (!VALID_TARGETS.includes(target)) {
+            throw new CliError(`Unsupported target: ${target}`);
+        }
+    }
+    return deduped;
+}
+function isCommand(value) {
+    return value === "install" || value === "verify" || value === "update";
+}

package/dist/src/core/errors.js

@@ -0,0 +1,8 @@
+export class CliError extends Error {
+    exitCode;
+    constructor(message, exitCode = 1) {
+        super(message);
+        this.name = "CliError";
+        this.exitCode = exitCode;
+    }
+}

package/dist/src/core/load-policy.js

@@ -0,0 +1,10 @@
+import path from "node:path";
+import { promises as fs } from "node:fs";
+import yaml from "js-yaml";
+import { validatePolicyPreset } from "./policy-schema.js";
+export async function loadPolicyPreset(cwd, presetName) {
+    const presetPath = path.join(cwd, "presets", presetName, "policy.yml");
+    const raw = await fs.readFile(presetPath, "utf8");
+    const parsed = yaml.load(raw);
+    return validatePolicyPreset(parsed);
+}

package/dist/src/core/logger.js

@@ -0,0 +1,11 @@
+export const logger = {
+    info(message) {
+        process.stdout.write(`${message}\n`);
+    },
+    warn(message) {
+        process.stderr.write(`WARN: ${message}\n`);
+    },
+    error(message) {
+        process.stderr.write(`ERROR: ${message}\n`);
+    }
+};

package/dist/src/core/manifest.js

@@ -0,0 +1,29 @@
+import { createHash } from "node:crypto";
+import path from "node:path";
+import { promises as fs } from "node:fs";
+export const MANIFEST_PATH = ".ai-policy/manifest.json";
+export function hashContent(content) {
+    return createHash("sha256").update(content).digest("hex");
+}
+export async function readManifest(cwd) {
+    const manifestPath = path.join(cwd, MANIFEST_PATH);
+    try {
+        const raw = await fs.readFile(manifestPath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (parsed.schemaVersion !== 1) {
+            throw new Error(`Unsupported manifest schemaVersion: ${String(parsed.schemaVersion)}`);
+        }
+        return parsed;
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return undefined;
+        }
+        throw error;
+    }
+}
+export async function writeManifest(cwd, manifest) {
+    const manifestPath = path.join(cwd, MANIFEST_PATH);
+    await fs.mkdir(path.dirname(manifestPath), { recursive: true });
+    await fs.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
+}

package/dist/src/core/policy-schema.js

@@ -0,0 +1,87 @@
+export function validatePolicyPreset(input) {
+    if (!isObject(input)) {
+        throw new Error("Policy preset must be an object");
+    }
+    const name = expectString(input.name, "name");
+    const description = optionalString(input.description, "description");
+    const globalRules = expectStringArray(input.globalRules, "globalRules");
+    const fileRules = expectFileRules(input.fileRules);
+    const targetOverrides = expectTargetOverrides(input.targetOverrides);
+    return {
+        name,
+        description,
+        globalRules,
+        fileRules,
+        targetOverrides
+    };
+}
+function expectFileRules(value) {
+    if (!Array.isArray(value)) {
+        throw new Error("fileRules must be an array");
+    }
+    return value.map((item, index) => {
+        if (!isObject(item)) {
+            throw new Error(`fileRules[${index}] must be an object`);
+        }
+        return {
+            name: expectString(item.name, `fileRules[${index}].name`),
+            patterns: expectStringArray(item.patterns, `fileRules[${index}].patterns`),
+            rules: expectStringArray(item.rules, `fileRules[${index}].rules`)
+        };
+    });
+}
+function expectTargetOverrides(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!isObject(value)) {
+        throw new Error("targetOverrides must be an object");
+    }
+    const targets = ["cursor", "copilot", "antigravity", "claude"];
+    const result = {};
+    for (const target of targets) {
+        const rawOverride = value[target];
+        if (rawOverride === undefined) {
+            continue;
+        }
+        if (!isObject(rawOverride)) {
+            throw new Error(`targetOverrides.${target} must be an object`);
+        }
+        result[target] = {
+            repoIntro: optionalStringArray(rawOverride.repoIntro, `targetOverrides.${target}.repoIntro`),
+            geminiRules: optionalStringArray(rawOverride.geminiRules, `targetOverrides.${target}.geminiRules`)
+        };
+    }
+    return result;
+}
+function expectString(value, key) {
+    if (typeof value !== "string" || !value.trim()) {
+        throw new Error(`${key} must be a non-empty string`);
+    }
+    return value.trim();
+}
+function optionalString(value, key) {
+    if (value === undefined) {
+        return undefined;
+    }
+    return expectString(value, key);
+}
+function expectStringArray(value, key) {
+    if (!Array.isArray(value)) {
+        throw new Error(`${key} must be an array`);
+    }
+    const normalized = value.map((item, index) => expectString(item, `${key}[${index}]`));
+    if (normalized.length === 0) {
+        throw new Error(`${key} must not be empty`);
+    }
+    return normalized;
+}
+function optionalStringArray(value, key) {
+    if (value === undefined) {
+        return undefined;
+    }
+    return expectStringArray(value, key);
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null;
+}

package/dist/src/core/prompt.js

@@ -0,0 +1,30 @@
+import { CliError } from "./errors.js";
+const ALL_TARGETS = ["cursor", "copilot", "antigravity", "claude"];
+export async function selectTargetsInteractive() {
+    process.stdout.write("Select targets (comma-separated numbers):\n1) cursor\n2) copilot\n3) antigravity\n4) claude\n> ");
+    const input = await readLine();
+    const tokens = input.split(",").map((part) => part.trim()).filter(Boolean);
+    if (tokens.length === 0) {
+        throw new CliError("No targets selected");
+    }
+    const indices = [...new Set(tokens.map((token) => Number(token)))];
+    if (indices.some((value) => Number.isNaN(value) || value < 1 || value > ALL_TARGETS.length)) {
+        throw new CliError("Invalid selection. Expected numbers 1-4");
+    }
+    return indices.map((index) => ALL_TARGETS[index - 1]);
+}
+export async function confirmAction(message) {
+    process.stdout.write(`${message} [y/N]: `);
+    const input = (await readLine()).trim().toLowerCase();
+    return input === "y" || input === "yes";
+}
+function readLine() {
+    return new Promise((resolve) => {
+        process.stdin.resume();
+        process.stdin.setEncoding("utf8");
+        process.stdin.once("data", (data) => {
+            process.stdin.pause();
+            resolve(data.toString().trim());
+        });
+    });
+}

package/dist/src/core/render.js

@@ -0,0 +1,19 @@
+import { getAdapter } from "../adapters/index.js";
+export function renderForTargets(policy, targets) {
+    const files = [];
+    for (const target of targets) {
+        const adapter = getAdapter(target);
+        files.push(...adapter.render({ policy }));
+    }
+    return dedupeGeneratedFiles(files);
+}
+function dedupeGeneratedFiles(files) {
+    const map = new Map();
+    for (const file of files) {
+        map.set(file.path, file.content);
+    }
+    return [...map.entries()].map(([filePath, content]) => ({
+        path: filePath,
+        content
+    }));
+}

package/dist/src/core/write-files.js

@@ -0,0 +1,21 @@
+import path from "node:path";
+import { promises as fs } from "node:fs";
+export async function writeGeneratedFiles(cwd, files) {
+    for (const file of files) {
+        const targetPath = path.join(cwd, file.path);
+        await fs.mkdir(path.dirname(targetPath), { recursive: true });
+        await fs.writeFile(targetPath, file.content, "utf8");
+    }
+}
+export async function readFileIfExists(cwd, relativePath) {
+    const targetPath = path.join(cwd, relativePath);
+    try {
+        return await fs.readFile(targetPath, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return undefined;
+        }
+        throw error;
+    }
+}

package/dist/test/adapters.spec.js

@@ -0,0 +1,15 @@
+import { describe, expect, it } from "vitest";
+import { loadPolicyPreset } from "../src/core/load-policy.js";
+import { renderForTargets } from "../src/core/render.js";
+const CWD = "d:/ATS/Project/AI/rulecusor";
+describe("adapters render", () => {
+    it("renders target-specific files", async () => {
+        const policy = await loadPolicyPreset(CWD, "karpathy");
+        const files = renderForTargets(policy, ["cursor", "copilot", "antigravity", "claude"]);
+        const paths = files.map((item) => item.path).sort();
+        expect(paths).toContain(".cursor/rules/global-policy.mdc");
+        expect(paths).toContain(".github/copilot-instructions.md");
+        expect(paths).toContain("AGENTS.md");
+        expect(paths).toContain("CLAUDE.md");
+    });
+});

package/dist/test/args.spec.js

@@ -0,0 +1,28 @@
+import { describe, expect, it } from "vitest";
+import { parseArgs } from "../src/core/args.js";
+import { CliError } from "../src/core/errors.js";
+describe("parseArgs", () => {
+    it("parses install args with all flags", () => {
+        const parsed = parseArgs([
+            "install",
+            "--targets",
+            "cursor,copilot",
+            "--preset",
+            "karpathy",
+            "--yes",
+            "--dry-run",
+            "--force"
+        ]);
+        expect(parsed).toEqual({
+            command: "install",
+            targets: ["cursor", "copilot"],
+            preset: "karpathy",
+            yes: true,
+            dryRun: true,
+            force: true
+        });
+    });
+    it("throws on unsupported target", () => {
+        expect(() => parseArgs(["install", "--targets", "foo"])).toThrow(CliError);
+    });
+});

package/dist/test/helpers.js

@@ -0,0 +1,26 @@
+import path from "node:path";
+import os from "node:os";
+import { promises as fs } from "node:fs";
+export async function createTempWorkspace(prefix) {
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), `${prefix}-`));
+    return dir;
+}
+export async function copyFixtureSourceToWorkspace(sourceRoot, workspace) {
+    await copyDir(path.join(sourceRoot, "src"), path.join(workspace, "src"));
+    await copyDir(path.join(sourceRoot, "presets"), path.join(workspace, "presets"));
+    await fs.writeFile(path.join(workspace, "package.json"), JSON.stringify({ name: "fixture", version: "0.1.0" }, null, 2), "utf8");
+}
+async function copyDir(src, dest) {
+    await fs.mkdir(dest, { recursive: true });
+    const entries = await fs.readdir(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            await copyDir(srcPath, destPath);
+        }
+        else {
+            await fs.copyFile(srcPath, destPath);
+        }
+    }
+}

package/dist/test/install-verify-update.spec.js

@@ -0,0 +1,43 @@
+import path from "node:path";
+import { promises as fs } from "node:fs";
+import { describe, expect, it } from "vitest";
+import { parseArgs } from "../src/core/args.js";
+import { runInstallCommand } from "../src/commands/install.js";
+import { runVerifyCommand } from "../src/commands/verify.js";
+import { runUpdateCommand } from "../src/commands/update.js";
+import { createTempWorkspace, copyFixtureSourceToWorkspace } from "./helpers.js";
+const silentLogger = {
+    info: (_message) => undefined,
+    warn: (_message) => undefined,
+    error: (_message) => undefined
+};
+describe("install -> verify -> drift -> update flow", () => {
+    it("handles end-to-end lifecycle", async () => {
+        const root = "d:/ATS/Project/AI/rulecusor";
+        const workspace = await createTempWorkspace("ai-policy-pack");
+        await copyFixtureSourceToWorkspace(root, workspace);
+        await runInstallCommand(parseArgs(["install", "--targets", "cursor,copilot,antigravity,claude", "--yes"]), {
+            cwd: workspace,
+            packageVersion: "0.1.0",
+            logger: silentLogger
+        });
+        await runVerifyCommand(parseArgs(["verify"]), {
+            cwd: workspace,
+            logger: silentLogger
+        });
+        await fs.appendFile(path.join(workspace, "AGENTS.md"), "\nmanual drift\n", "utf8");
+        await expect(runVerifyCommand(parseArgs(["verify"]), {
+            cwd: workspace,
+            logger: silentLogger
+        })).rejects.toThrow();
+        await runUpdateCommand(parseArgs(["update", "--yes"]), {
+            cwd: workspace,
+            packageVersion: "0.1.1",
+            logger: silentLogger
+        });
+        await runVerifyCommand(parseArgs(["verify"]), {
+            cwd: workspace,
+            logger: silentLogger
+        });
+    });
+});

package/docs/migration.md

@@ -0,0 +1,39 @@
+# Migration and Rollout
+
+This guide helps teams adopt `ai-policy-pack-cli` across multiple repositories.
+
+## Initial Rollout
+
+1. Install and generate files:
+   ```bash
+   npx ai-policy-pack-cli install --targets cursor,copilot,antigravity,claude --yes
+   ```
+2. Commit generated files and `.ai-policy/manifest.json`.
+3. Add `npx ai-policy-pack-cli verify` to CI.
+
+## Updating Existing Repositories
+
+1. Upgrade package version in your toolchain.
+2. Run:
+   ```bash
+   npx ai-policy-pack-cli update --yes
+   ```
+3. Review generated diff.
+4. Run:
+   ```bash
+   npx ai-policy-pack-cli verify
+   ```
+
+## Drift Policy
+
+If users edit generated files manually:
+
+- CI `verify` will fail with mismatch details.
+- Run `update` to restore generated state.
+
+## Target Mapping Reference
+
+- Cursor: `.cursor/rules/*.mdc`
+- Copilot: `.github/copilot-instructions.md`, `.github/instructions/*.instructions.md`
+- Antigravity: `AGENTS.md`, `GEMINI.md` (if configured by override)
+- Claude: `CLAUDE.md`

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "ai-policy-pack-cli",
+  "version": "0.1.0",
+  "description": "Multi-IDE AI policy pack generator for Cursor, Copilot, Antigravity, and Claude",
+  "type": "module",
+  "bin": {
+    "ai-policy-pack": "dist/src/cli.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "tsc -p tsconfig.json --noEmit"
+  },
+  "files": [
+    "dist",
+    "presets",
+    "README.md",
+    "docs"
+  ],
+  "keywords": [
+    "cursor",
+    "copilot",
+    "antigravity",
+    "claude",
+    "ai-rules"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "js-yaml": "^4.1.0"
+  },
+  "devDependencies": {
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^22.15.18",
+    "typescript": "^5.8.3",
+    "vitest": "^2.1.9"
+  }
+}

package/presets/karpathy/policy.yml

@@ -0,0 +1,30 @@
+name: karpathy
+description: Karpathy-inspired guardrails adapted for multi-IDE agents
+globalRules:
+  - State assumptions and ask clarifying questions before coding when requirements are ambiguous.
+  - Prefer the simplest implementation that solves the user's request; avoid speculative abstractions.
+  - Keep changes surgical and scoped to the requested task; avoid unrelated refactors.
+  - Define explicit success criteria and verify changes with tests or commands before claiming completion.
+  - Remove dead code created by your own change but do not clean unrelated legacy code unless asked.
+fileRules:
+  - name: typescript-standards
+    patterns:
+      - "**/*.ts"
+      - "**/*.tsx"
+    rules:
+      - Favor strict typing and avoid any unless there is a documented reason.
+      - Keep functions focused and small; split logic when a function mixes responsibilities.
+      - Add concise comments only when code intent is not obvious.
+  - name: python-standards
+    patterns:
+      - "**/*.py"
+    rules:
+      - Prefer explicit names over abbreviations and keep functions single-purpose.
+      - Handle expected exceptions explicitly and include actionable error messages.
+targetOverrides:
+  antigravity:
+    geminiRules:
+      - Use GEMINI.md for tool-specific overrides and AGENTS.md for shared team policy.
+  copilot:
+    repoIntro:
+      - Follow repository build, test, and lint commands from project docs before submitting changes.