@slowdini/slow-powers-opencode 0.2.0 → 0.4.0

package/skills/evaluating-skills/runner/guard/install.test.ts

@@ -1,92 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  rmSync,
-  writeFileSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import {
-  GUARD_MANIFEST,
-  GUARD_MARKER,
-  installGuard,
-  teardownGuard,
-} from "./install";
-
-const ROOT = join(tmpdir(), `guard-install-test-${process.pid}`);
-
-afterEach(() => rmSync(ROOT, { recursive: true, force: true }));
-
-function setup() {
-  const stageRoot = join(ROOT, `case-${Math.random().toString(36).slice(2)}`);
-  mkdirSync(stageRoot, { recursive: true });
-  const workspaceRoot = join(stageRoot, "skills-workspace");
-  return { stageRoot, workspaceRoot };
-}
-
-const skillsDir = (s: string) => join(s, ".claude", "skills");
-const settingsPath = (s: string) => join(s, ".claude", "settings.local.json");
-
-describe("installGuard / teardownGuard", () => {
-  test("install writes an active marker, hook, and manifest", () => {
-    const { stageRoot, workspaceRoot } = setup();
-    installGuard({ stageRoot, workspaceRoot, guardScriptPath: "/g/guard.ts" });
-
-    const marker = JSON.parse(
-      readFileSync(join(skillsDir(stageRoot), GUARD_MARKER), "utf8"),
-    );
-    expect(marker.active).toBe(true);
-    expect(Date.parse(marker.expiresAt)).toBeGreaterThan(Date.now());
-    expect(
-      marker.allowedRoots.some((r: string) => r.includes("skills-workspace")),
-    ).toBe(true);
-
-    const settings = JSON.parse(readFileSync(settingsPath(stageRoot), "utf8"));
-    expect(settings.hooks.PreToolUse[0].matcher).toContain("Write");
-    expect(settings.hooks.PreToolUse[0].hooks[0].command).toContain("guard.ts");
-
-    expect(existsSync(join(skillsDir(stageRoot), GUARD_MANIFEST))).toBe(true);
-  });
-
-  test("teardown deletes settings.local.json it created", () => {
-    const { stageRoot, workspaceRoot } = setup();
-    installGuard({ stageRoot, workspaceRoot, guardScriptPath: "/g/guard.ts" });
-    expect(existsSync(settingsPath(stageRoot))).toBe(true);
-
-    expect(teardownGuard(stageRoot)).toBe(true);
-    expect(existsSync(settingsPath(stageRoot))).toBe(false);
-    expect(existsSync(join(skillsDir(stageRoot), GUARD_MARKER))).toBe(false);
-    expect(existsSync(join(skillsDir(stageRoot), GUARD_MANIFEST))).toBe(false);
-  });
-
-  test("teardown restores a pre-existing settings.local.json verbatim", () => {
-    const { stageRoot, workspaceRoot } = setup();
-    mkdirSync(join(stageRoot, ".claude"), { recursive: true });
-    const original = `${JSON.stringify({ permissions: { allow: ["Bash(ls)"] } }, null, 2)}\n`;
-    writeFileSync(settingsPath(stageRoot), original);
-
-    installGuard({ stageRoot, workspaceRoot, guardScriptPath: "/g/guard.ts" });
-    // hook present while armed
-    expect(readFileSync(settingsPath(stageRoot), "utf8")).toContain(
-      "PreToolUse",
-    );
-
-    teardownGuard(stageRoot);
-    expect(readFileSync(settingsPath(stageRoot), "utf8")).toBe(original);
-  });
-
-  test("teardown is a safe no-op when nothing is installed", () => {
-    const { stageRoot } = setup();
-    expect(teardownGuard(stageRoot)).toBe(false);
-  });
-
-  test("teardown sweeps a stray marker even without a manifest", () => {
-    const { stageRoot } = setup();
-    mkdirSync(skillsDir(stageRoot), { recursive: true });
-    writeFileSync(join(skillsDir(stageRoot), GUARD_MARKER), "{}");
-    expect(teardownGuard(stageRoot)).toBe(true);
-    expect(existsSync(join(skillsDir(stageRoot), GUARD_MARKER))).toBe(false);
-  });
-});

package/skills/evaluating-skills/runner/guard/install.ts

@@ -1,147 +0,0 @@
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  rmSync,
-  writeFileSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { join, resolve } from "node:path";
-
-export const GUARD_MARKER = ".slow-powers-eval-guard.json";
-export const GUARD_MANIFEST = ".slow-powers-eval-guard-manifest.json";
-const GUARD_TTL_MS = 6 * 60 * 60 * 1000; // 6h — bounds a crashed run's lingering hook
-
-const HOOK_MATCHER = "Write|Edit|MultiEdit|NotebookEdit|Bash";
-
-type GuardManifest = {
-  created_at: string;
-  settings_path: string;
-  settings_existed: boolean;
-  settings_backup: string | null;
-  marker_path: string;
-};
-
-type Settings = {
-  hooks?: {
-    PreToolUse?: Array<{ matcher?: string; hooks?: unknown[] }>;
-    [k: string]: unknown;
-  };
-  [k: string]: unknown;
-};
-
-/**
- * Arm the Claude Code write guard for an eval run. Writes a marker listing the
- * allowed roots and merges a `PreToolUse` hook into `.claude/settings.local.json`
- * that runs `guard.ts` on every Write/Edit/Bash. The original settings file is
- * backed up verbatim in a manifest so {@link teardownGuard} restores it exactly.
- *
- * Returns the marker path. The guard is a no-op until this marker exists and is
- * unexpired (see guard/policy.ts), so the hook is inert outside an active run.
- */
-export function installGuard(opts: {
-  stageRoot: string;
-  workspaceRoot: string;
-  guardScriptPath: string;
-  ttlMs?: number;
-}): string {
-  const skillsDir = join(opts.stageRoot, ".claude", "skills");
-  mkdirSync(skillsDir, { recursive: true });
-
-  const markerPath = join(skillsDir, GUARD_MARKER);
-  const allowedRoots = [
-    resolve(opts.workspaceRoot),
-    resolve(skillsDir),
-    resolve(tmpdir()),
-  ];
-  writeFileSync(
-    markerPath,
-    `${JSON.stringify(
-      {
-        active: true,
-        allowedRoots,
-        expiresAt: new Date(
-          Date.now() + (opts.ttlMs ?? GUARD_TTL_MS),
-        ).toISOString(),
-      },
-      null,
-      2,
-    )}\n`,
-  );
-
-  const settingsPath = join(opts.stageRoot, ".claude", "settings.local.json");
-  const settingsExisted = existsSync(settingsPath);
-  const backup = settingsExisted ? readFileSync(settingsPath, "utf8") : null;
-
-  let settings: Settings = {};
-  if (backup) {
-    try {
-      settings = JSON.parse(backup);
-    } catch {
-      settings = {};
-    }
-  }
-  settings.hooks ??= {};
-  settings.hooks.PreToolUse ??= [];
-  settings.hooks.PreToolUse.push({
-    matcher: HOOK_MATCHER,
-    hooks: [
-      {
-        type: "command",
-        command: `bun run "${opts.guardScriptPath}" "${markerPath}"`,
-      },
-    ],
-  });
-  writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`);
-
-  const manifest: GuardManifest = {
-    created_at: new Date().toISOString(),
-    settings_path: settingsPath,
-    settings_existed: settingsExisted,
-    settings_backup: backup,
-    marker_path: markerPath,
-  };
-  writeFileSync(
-    join(skillsDir, GUARD_MANIFEST),
-    `${JSON.stringify(manifest, null, 2)}\n`,
-  );
-  return markerPath;
-}
-
-/**
- * Disarm the guard: restore the original `settings.local.json` (or delete it if
- * we created it) and remove the marker + manifest. Safe to call when no guard is
- * installed. Returns true if a guard was found and torn down.
- */
-export function teardownGuard(stageRoot: string): boolean {
-  const skillsDir = join(stageRoot, ".claude", "skills");
-  const manifestPath = join(skillsDir, GUARD_MANIFEST);
-  const markerPath = join(skillsDir, GUARD_MARKER);
-
-  if (!existsSync(manifestPath)) {
-    // No manifest — still sweep a stray marker so the guard can't stay armed.
-    if (existsSync(markerPath)) {
-      rmSync(markerPath, { force: true });
-      return true;
-    }
-    return false;
-  }
-
-  let manifest: GuardManifest;
-  try {
-    manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
-  } catch {
-    rmSync(manifestPath, { force: true });
-    rmSync(markerPath, { force: true });
-    return true;
-  }
-
-  if (manifest.settings_existed && manifest.settings_backup !== null) {
-    writeFileSync(manifest.settings_path, manifest.settings_backup);
-  } else if (existsSync(manifest.settings_path)) {
-    rmSync(manifest.settings_path, { force: true });
-  }
-  rmSync(manifest.marker_path, { force: true });
-  rmSync(manifestPath, { force: true });
-  return true;
-}

package/skills/evaluating-skills/runner/guard/policy.test.ts

@@ -1,71 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { decide, type GuardMarker } from "./policy";
-
-const ROOTS = ["/work/skills-workspace", "/work/.claude/skills"];
-const future = () => new Date(Date.now() + 60_000).toISOString();
-const past = () => new Date(Date.now() - 60_000).toISOString();
-
-function marker(over: Partial<GuardMarker> = {}): GuardMarker {
-  return { active: true, allowedRoots: ROOTS, expiresAt: future(), ...over };
-}
-
-describe("guard decide", () => {
-  test("allows everything when marker is null (guard inactive)", () => {
-    expect(decide("Write", { file_path: "/etc/passwd" }, null).allow).toBe(
-      true,
-    );
-  });
-
-  test("allows everything when marker is inactive or expired", () => {
-    expect(
-      decide("Write", { file_path: "/etc/passwd" }, marker({ active: false }))
-        .allow,
-    ).toBe(true);
-    expect(
-      decide(
-        "Write",
-        { file_path: "/etc/passwd" },
-        marker({ expiresAt: past() }),
-      ).allow,
-    ).toBe(true);
-  });
-
-  test("allows a write under an allowed root", () => {
-    expect(
-      decide(
-        "Write",
-        { file_path: "/work/skills-workspace/x/outputs/a.md" },
-        marker(),
-      ).allow,
-    ).toBe(true);
-  });
-
-  test("denies a write outside all allowed roots", () => {
-    const d = decide("Edit", { file_path: "/work/runner/run.ts" }, marker());
-    expect(d.allow).toBe(false);
-    expect(d.reason).toMatch(/outside/i);
-  });
-
-  test("denies an install command", () => {
-    const d = decide("Bash", { command: "npm install left-pad" }, marker());
-    expect(d.allow).toBe(false);
-    expect(d.reason).toMatch(/install/i);
-  });
-
-  test("allows a Bash command scoped to an allowed root", () => {
-    expect(
-      decide(
-        "Bash",
-        { command: "echo hi > /work/skills-workspace/x/outputs/log" },
-        marker(),
-      ).allow,
-    ).toBe(true);
-  });
-
-  test("allows non-mutating Bash and read tools", () => {
-    expect(decide("Bash", { command: "ls -la /" }, marker()).allow).toBe(true);
-    expect(decide("Read", { file_path: "/etc/passwd" }, marker()).allow).toBe(
-      true,
-    );
-  });
-});

package/skills/evaluating-skills/runner/guard/policy.ts

@@ -1,74 +0,0 @@
-import {
-  classifyBash,
-  isUnderAny,
-  pathArg,
-  WRITE_TOOLS,
-} from "../sandbox-policy";
-
-/**
- * The marker file (`<stageRoot>/.claude/skills/.slow-powers-eval-guard.json`)
- * that arms the guard. The guard is a no-op unless this file exists, is active,
- * and has not expired — so a crashed run that never tore the hook down can't
- * silently block writes in the user's next interactive session.
- */
-export type GuardMarker = {
-  active?: boolean;
-  allowedRoots?: string[];
-  expiresAt?: string;
-};
-
-export type GuardDecision = { allow: boolean; reason?: string };
-
-const ALLOW: GuardDecision = { allow: true };
-
-function armed(marker: GuardMarker | null, now: number): boolean {
-  if (marker?.active !== true) return false;
-  if (marker.expiresAt && Date.parse(marker.expiresAt) <= now) return false;
-  return true;
-}
-
-/**
- * Decide whether a tool call should be allowed while the eval guard is armed.
- *
- * Write tools targeting a path outside every allowed root are denied; Bash
- * commands matching a mutation pattern (install/git/sed -i/redirection) that
- * aren't scoped to an allowed root are denied. Everything else — including all
- * read-only tools and the orchestrator's own writes under the workspace — is
- * allowed. When the guard is not armed, every call is allowed.
- */
-export function decide(
-  toolName: string,
-  toolInput: unknown,
-  marker: GuardMarker | null,
-  now: number = Date.now(),
-): GuardDecision {
-  if (!armed(marker, now)) return ALLOW;
-  const roots = marker?.allowedRoots ?? [];
-  const repoRoot = process.cwd();
-
-  if (WRITE_TOOLS.has(toolName)) {
-    const p = pathArg(toolInput);
-    if (p && !isUnderAny(p, roots, repoRoot)) {
-      return {
-        allow: false,
-        reason: `eval guard: ${toolName} to ${p} is outside the eval sandbox (allowed: ${roots.join(", ")})`,
-      };
-    }
-    return ALLOW;
-  }
-
-  if (toolName === "Bash") {
-    const command =
-      toolInput && typeof toolInput === "object"
-        ? String((toolInput as Record<string, unknown>).command ?? "")
-        : "";
-    const reason = classifyBash(command, roots);
-    if (reason)
-      return {
-        allow: false,
-        reason: `eval guard: blocked Bash (${reason}) — runs outside the eval sandbox`,
-      };
-  }
-
-  return ALLOW;
-}

package/skills/evaluating-skills/runner/plugin-shadow.test.ts

@@ -1,228 +0,0 @@
-import { afterAll, beforeAll, describe, expect, test } from "bun:test";
-import { mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { homedir, tmpdir } from "node:os";
-import { dirname, join } from "node:path";
-import {
-  detectPluginShadows,
-  formatShadowBanner,
-  resolveConfigDir,
-  shadowValidityWarnings,
-} from "./plugin-shadow";
-
-const ROOT = join(tmpdir(), `slow-powers-plugin-shadow-test-${process.pid}`);
-
-beforeAll(() => mkdirSync(ROOT, { recursive: true }));
-afterAll(() => rmSync(ROOT, { recursive: true, force: true }));
-
-let seq = 0;
-function freshDirs() {
-  seq += 1;
-  const base = join(ROOT, `case-${seq}`);
-  const configDir = join(base, "config");
-  const cwd = join(base, "cwd");
-  mkdirSync(configDir, { recursive: true });
-  mkdirSync(cwd, { recursive: true });
-  return { configDir, cwd };
-}
-
-function writeFile(path: string, body: string) {
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, body);
-}
-
-/** Lay down a plugin's skill folders and return its install path. */
-function installPlugin(
-  configDir: string,
-  key: string,
-  skillNames: string[],
-): string {
-  const installPath = join(
-    configDir,
-    "plugins",
-    "cache",
-    key.replace("@", "__"),
-  );
-  for (const name of skillNames) {
-    writeFile(
-      join(installPath, "skills", name, "SKILL.md"),
-      `---\nname: ${name}\ndescription: x\n---\n`,
-    );
-  }
-  return installPath;
-}
-
-function writeInstalledManifest(
-  configDir: string,
-  entries: Record<string, string>,
-) {
-  const plugins: Record<string, Array<{ installPath: string }>> = {};
-  for (const [key, installPath] of Object.entries(entries))
-    plugins[key] = [{ installPath }];
-  writeFile(
-    join(configDir, "plugins", "installed_plugins.json"),
-    `${JSON.stringify({ version: 2, plugins }, null, 2)}\n`,
-  );
-}
-
-function writeSettings(path: string, enabledPlugins: Record<string, boolean>) {
-  writeFile(path, `${JSON.stringify({ enabledPlugins }, null, 2)}\n`);
-}
-
-describe("resolveConfigDir", () => {
-  test("honors CLAUDE_CONFIG_DIR", () => {
-    expect(
-      resolveConfigDir({
-        CLAUDE_CONFIG_DIR: "/custom/cfg",
-      } as NodeJS.ProcessEnv),
-    ).toBe("/custom/cfg");
-  });
-
-  test("defaults to ~/.claude when unset", () => {
-    expect(resolveConfigDir({} as NodeJS.ProcessEnv)).toBe(
-      join(homedir(), ".claude"),
-    );
-  });
-});
-
-describe("detectPluginShadows", () => {
-  test("flags a staged skill also provided by an enabled plugin", () => {
-    const { configDir, cwd } = freshDirs();
-    const ip = installPlugin(configDir, "slow-powers@slowdini", [
-      "verification-before-completion",
-      "writing-skills",
-    ]);
-    writeInstalledManifest(configDir, { "slow-powers@slowdini": ip });
-    writeSettings(join(configDir, "settings.json"), {
-      "slow-powers@slowdini": true,
-    });
-
-    const report = detectPluginShadows({
-      configDir,
-      cwd,
-      stagedSkillNames: ["verification-before-completion"],
-    });
-    expect(report.shadowed).toHaveLength(1);
-    expect(report.shadowed[0]).toMatchObject({
-      kind: "plugin",
-      plugin: "slow-powers@slowdini",
-      skill_name: "verification-before-completion",
-    });
-  });
-
-  test("does not flag a plugin disabled in user settings", () => {
-    const { configDir, cwd } = freshDirs();
-    const ip = installPlugin(configDir, "slow-powers@slowdini", [
-      "verification-before-completion",
-    ]);
-    writeInstalledManifest(configDir, { "slow-powers@slowdini": ip });
-    writeSettings(join(configDir, "settings.json"), {
-      "slow-powers@slowdini": false,
-    });
-
-    const report = detectPluginShadows({
-      configDir,
-      cwd,
-      stagedSkillNames: ["verification-before-completion"],
-    });
-    expect(report.shadowed).toHaveLength(0);
-  });
-
-  test("project settings disabling a user-enabled plugin suppresses the shadow", () => {
-    const { configDir, cwd } = freshDirs();
-    const ip = installPlugin(configDir, "slow-powers@slowdini", [
-      "verification-before-completion",
-    ]);
-    writeInstalledManifest(configDir, { "slow-powers@slowdini": ip });
-    writeSettings(join(configDir, "settings.json"), {
-      "slow-powers@slowdini": true,
-    });
-    // Project scope (cwd/.claude/settings.json) outranks user scope.
-    writeSettings(join(cwd, ".claude", "settings.json"), {
-      "slow-powers@slowdini": false,
-    });
-
-    const report = detectPluginShadows({
-      configDir,
-      cwd,
-      stagedSkillNames: ["verification-before-completion"],
-    });
-    expect(report.shadowed).toHaveLength(0);
-  });
-
-  test("flags a staged skill also present in the global skills dir", () => {
-    const { configDir, cwd } = freshDirs();
-    writeFile(
-      join(configDir, "skills", "my-skill", "SKILL.md"),
-      "---\nname: my-skill\n---\n",
-    );
-
-    const report = detectPluginShadows({
-      configDir,
-      cwd,
-      stagedSkillNames: ["my-skill"],
-    });
-    expect(report.shadowed).toHaveLength(1);
-    expect(report.shadowed[0]).toMatchObject({
-      kind: "global-skill",
-      skill_name: "my-skill",
-    });
-  });
-
-  test("no shadow when staged names match nothing in the environment", () => {
-    const { configDir, cwd } = freshDirs();
-    const ip = installPlugin(configDir, "p@m", ["other"]);
-    writeInstalledManifest(configDir, { "p@m": ip });
-    writeSettings(join(configDir, "settings.json"), { "p@m": true });
-
-    const report = detectPluginShadows({
-      configDir,
-      cwd,
-      stagedSkillNames: ["mine"],
-    });
-    expect(report.shadowed).toHaveLength(0);
-  });
-
-  test("is graceful when the config dir has no plugins or skills", () => {
-    const { configDir, cwd } = freshDirs();
-    const report = detectPluginShadows({
-      configDir,
-      cwd,
-      stagedSkillNames: ["x"],
-    });
-    expect(report.shadowed).toHaveLength(0);
-    expect(report.config_dir).toBe(configDir);
-  });
-});
-
-describe("warning formatting", () => {
-  const report = {
-    config_dir: "/x",
-    shadowed: [
-      {
-        kind: "plugin" as const,
-        plugin: "slow-powers@slowdini",
-        skill_name: "verification-before-completion",
-        path: "/p",
-      },
-    ],
-  };
-
-  test("shadowValidityWarnings names the skill, the plugin, and the contamination", () => {
-    const warnings = shadowValidityWarnings(report);
-    expect(warnings).toHaveLength(1);
-    expect(warnings[0]).toContain("verification-before-completion");
-    expect(warnings[0]).toContain("slow-powers@slowdini");
-    expect(warnings[0]).toMatch(/contaminat/i);
-  });
-
-  test("formatShadowBanner is empty when nothing is shadowed", () => {
-    expect(formatShadowBanner({ config_dir: "/x", shadowed: [] })).toBe("");
-  });
-
-  test("formatShadowBanner lists shadowed skills and points at isolation docs", () => {
-    const banner = formatShadowBanner(report);
-    expect(banner).toContain("verification-before-completion");
-    expect(banner).toContain("slow-powers@slowdini");
-    expect(banner).toMatch(/isolat/i);
-  });
-});