ai-policy-pack-cli 0.1.0 → 0.1.1

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

@@ -7,7 +7,7 @@ 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 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, "karpathy", 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/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.1",
   "description": "Multi-IDE AI policy pack generator for Cursor, Copilot, Antigravity, and Claude",
   "type": "module",
   "bin": {