ai-policy-pack-cli 0.1.0 → 0.1.2

package/README.md

@@ -26,7 +26,7 @@ npx ai-policy-pack-cli install --targets cursor,copilot,antigravity,claude --yes
 ### Install
 
 ```bash
-npx ai-policy-pack-cli install [--targets cursor,copilot,antigravity,claude] [--preset karpathy] [--yes] [--dry-run]
+npx ai-policy-pack-cli install [--targets cursor,copilot,antigravity,claude] [--preset anhtdq] [--yes] [--dry-run]
 ```
 
 - Generates target files from preset
@@ -45,7 +45,7 @@ npx ai-policy-pack-cli verify
 ### Update
 
 ```bash
-npx ai-policy-pack-cli update [--preset karpathy] [--yes] [--dry-run]
+npx ai-policy-pack-cli update [--preset anhtdq] [--yes] [--dry-run]
 ```
 
 - Re-applies current targets from manifest
@@ -55,7 +55,7 @@ npx ai-policy-pack-cli update [--preset karpathy] [--yes] [--dry-run]
 
 Current default preset:
 
-- `presets/karpathy/policy.yml`
+- `presets/anhtdq/policy.yml`
 
 Preset layout:
 

package/dist/src/cli.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { promises as fs } from "node:fs";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { parseArgs } from "./core/args.js";
 import { logger } from "./core/logger.js";
 import { CliError } from "./core/errors.js";
@@ -9,17 +10,18 @@ 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 packageRoot = resolvePackageRoot();
+    const packageVersion = await readPackageVersion(packageRoot);
     const args = parseArgs(process.argv.slice(2));
     switch (args.command) {
         case "install":
-            await runInstallCommand(args, { cwd, packageVersion, logger });
+            await runInstallCommand(args, { cwd, packageRoot, packageVersion, logger });
             return;
         case "verify":
-            await runVerifyCommand(args, { cwd, logger });
+            await runVerifyCommand(args, { cwd, packageRoot, logger });
             return;
         case "update":
-            await runUpdateCommand(args, { cwd, packageVersion, logger });
+            await runUpdateCommand(args, { cwd, packageRoot, packageVersion, logger });
             return;
         default:
             throw new CliError(`Unsupported command: ${String(args.command)}`);
@@ -30,6 +32,10 @@ async function readPackageVersion(cwd) {
     const parsed = JSON.parse(await fs.readFile(packagePath, "utf8"));
     return parsed.version ?? "0.0.0";
 }
+function resolvePackageRoot() {
+    const currentFile = fileURLToPath(import.meta.url);
+    return path.resolve(path.dirname(currentFile), "..", "..");
+}
 main().catch((error) => {
     if (error instanceof CliError) {
         logger.error(error.message);

package/dist/src/commands/install.js

@@ -6,8 +6,8 @@ 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 presetName = args.preset ?? "anhtdq";
+    const policy = await loadPolicyPreset(deps.cwd, presetName, deps.packageRoot);
     const files = renderForTargets(policy, targets);
     deps.logger.info(`Preset: ${policy.name}`);
     deps.logger.info(`Targets: ${targets.join(", ")}`);

package/dist/src/commands/update.js

@@ -10,7 +10,7 @@ export async function runUpdateCommand(args, deps) {
         throw new CliError("Manifest not found. Run install first.");
     }
     const presetName = args.preset || manifest.preset;
-    const preset = await loadPolicyPreset(deps.cwd, presetName);
+    const preset = await loadPolicyPreset(deps.cwd, presetName, deps.packageRoot);
     const files = renderForTargets(preset, manifest.targets);
     deps.logger.info(`Updating preset: ${preset.name}`);
     for (const file of files) {

package/dist/src/commands/verify.js

@@ -9,7 +9,7 @@ export async function runVerifyCommand(args, deps) {
     if (!manifest) {
         throw new CliError("Manifest not found. Run install first.");
     }
-    const preset = await loadPolicyPreset(deps.cwd, manifest.preset);
+    const preset = await loadPolicyPreset(deps.cwd, manifest.preset, deps.packageRoot);
     const rendered = renderForTargets(preset, manifest.targets);
     const renderedMap = new Map(rendered.map((file) => [file.path, file.content]));
     const mismatches = [];

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

@@ -2,9 +2,28 @@ 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);
+import { CliError } from "./errors.js";
+export async function loadPolicyPreset(projectCwd, presetName, packageRoot) {
+    const projectPresetPath = path.join(projectCwd, "presets", presetName, "policy.yml");
+    const packagePresetPath = path.join(packageRoot, "presets", presetName, "policy.yml");
+    const source = await readFirstExisting([projectPresetPath, packagePresetPath]);
+    if (!source) {
+        throw new CliError(`Preset '${presetName}' not found. Checked: ${projectPresetPath} and ${packagePresetPath}`);
+    }
+    const parsed = yaml.load(source);
     return validatePolicyPreset(parsed);
 }
+async function readFirstExisting(paths) {
+    for (const filePath of paths) {
+        try {
+            return await fs.readFile(filePath, "utf8");
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                continue;
+            }
+            throw error;
+        }
+    }
+    return undefined;
+}

package/dist/test/adapters.spec.js

@@ -4,7 +4,7 @@ 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 policy = await loadPolicyPreset(CWD, "anhtdq", CWD);
         const files = renderForTargets(policy, ["cursor", "copilot", "antigravity", "claude"]);
         const paths = files.map((item) => item.path).sort();
         expect(paths).toContain(".cursor/rules/global-policy.mdc");

package/dist/test/args.spec.js

@@ -8,7 +8,7 @@ describe("parseArgs", () => {
             "--targets",
             "cursor,copilot",
             "--preset",
-            "karpathy",
+            "anhtdq",
             "--yes",
             "--dry-run",
             "--force"
@@ -16,7 +16,7 @@ describe("parseArgs", () => {
         expect(parsed).toEqual({
             command: "install",
             targets: ["cursor", "copilot"],
-            preset: "karpathy",
+            preset: "anhtdq",
             yes: true,
             dryRun: true,
             force: true

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

@@ -18,25 +18,30 @@ describe("install -> verify -> drift -> update flow", () => {
         await copyFixtureSourceToWorkspace(root, workspace);
         await runInstallCommand(parseArgs(["install", "--targets", "cursor,copilot,antigravity,claude", "--yes"]), {
             cwd: workspace,
+            packageRoot: workspace,
             packageVersion: "0.1.0",
             logger: silentLogger
         });
         await runVerifyCommand(parseArgs(["verify"]), {
             cwd: workspace,
+            packageRoot: workspace,
             logger: silentLogger
         });
         await fs.appendFile(path.join(workspace, "AGENTS.md"), "\nmanual drift\n", "utf8");
         await expect(runVerifyCommand(parseArgs(["verify"]), {
             cwd: workspace,
+            packageRoot: workspace,
             logger: silentLogger
         })).rejects.toThrow();
         await runUpdateCommand(parseArgs(["update", "--yes"]), {
             cwd: workspace,
+            packageRoot: workspace,
             packageVersion: "0.1.1",
             logger: silentLogger
         });
         await runVerifyCommand(parseArgs(["verify"]), {
             cwd: workspace,
+            packageRoot: workspace,
             logger: silentLogger
         });
     });

package/dist/test/npx-runtime.spec.js

@@ -0,0 +1,29 @@
+import path from "node:path";
+import { promises as fs } from "node:fs";
+import { describe, expect, it } from "vitest";
+import { runInstallCommand } from "../src/commands/install.js";
+import { parseArgs } from "../src/core/args.js";
+import { createTempWorkspace, copyFixtureSourceToWorkspace } from "./helpers.js";
+const silentLogger = {
+    info: (_message) => undefined,
+    warn: (_message) => undefined,
+    error: (_message) => undefined
+};
+describe("runtime path behavior", () => {
+    it("installs into workspace without local package.json or presets", async () => {
+        const sourceRoot = "d:/ATS/Project/AI/rulecusor";
+        const packageRoot = await createTempWorkspace("policy-pack-runtime");
+        const projectWorkspace = await createTempWorkspace("policy-pack-project");
+        // Simulate npm package root with presets available.
+        await copyFixtureSourceToWorkspace(sourceRoot, packageRoot);
+        await fs.rm(path.join(projectWorkspace, "presets"), { recursive: true, force: true });
+        await fs.rm(path.join(projectWorkspace, "package.json"), { force: true });
+        await runInstallCommand(parseArgs(["install", "--targets", "cursor", "--yes"]), {
+            cwd: projectWorkspace,
+            packageRoot,
+            packageVersion: "0.1.0",
+            logger: silentLogger
+        });
+        await expect(fs.readFile(path.join(projectWorkspace, ".cursor/rules/global-policy.mdc"), "utf8")).resolves.toContain("Team Global Rules");
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-policy-pack-cli",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Multi-IDE AI policy pack generator for Cursor, Copilot, Antigravity, and Claude",
   "type": "module",
   "bin": {

package/presets/anhtdq/policy.yml

@@ -0,0 +1,38 @@
+name: anhtdq
+description: Behavioral guardrails to reduce common LLM coding mistakes across all code
+globalRules:
+  - Before implementing, state assumptions explicitly. If uncertain, ask instead of guessing.
+  - If multiple interpretations exist, surface them and confirm direction before coding.
+  - If a simpler approach exists, recommend it and explain the tradeoff.
+  - If requirements are unclear or contradictory, stop and ask a focused clarification question.
+  - Implement the minimum code that solves the requested problem.
+  - Do not add speculative features or future-proof abstractions unless explicitly requested.
+  - Do not add configurability that is not required by the task.
+  - Do not add error handling for impossible scenarios.
+  - If implementation feels overcomplicated, simplify until it is easy to reason about.
+  - Touch only lines required by the requested change.
+  - Do not refactor unrelated modules or formatting during focused tasks.
+  - Match existing project patterns and style unless user asks to change conventions.
+  - If unrelated dead code is discovered, mention it but do not delete it automatically.
+  - Remove only orphaned code introduced by your own change.
+  - Define clear success criteria before implementation.
+  - Convert requests into verifiable goals with checks or tests.
+  - For bug fixes, reproduce with a failing test/check first, then fix, then verify pass.
+  - For refactors, verify behavior before and after with stable checks.
+  - For multi-step work, provide a short step plan with explicit verification at each step.
+  - Do not claim completion until verification actually passes.
+fileRules:
+  - name: universal-code-rules
+    patterns:
+      - "**/*"
+    rules:
+      - Apply these standards to all code and configuration files unless the user explicitly narrows scope.
+      - Prefer readable, straightforward code and avoid hidden magic.
+      - Keep changes cohesive, easy to review, and directly traceable to the request.
+targetOverrides:
+  antigravity:
+    geminiRules:
+      - Keep AGENTS.md as shared cross-tool policy and use GEMINI.md only for Antigravity-specific overrides.
+  copilot:
+    repoIntro:
+      - Follow repository build, test, and lint commands from project documentation before submitting changes.

package/presets/karpathy/policy.yml

@@ -1,30 +0,0 @@
-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.