@codemcp/ade 0.2.5 → 0.3.0

package/packages/cli/package.json

@@ -39,5 +39,5 @@
     "typescript": "catalog:",
     "vitest": "catalog:"
   },
-  "version": "0.2.5"
+  "version": "0.3.0"
 }

package/packages/cli/src/commands/conventions.integration.spec.ts

@@ -8,9 +8,15 @@ vi.mock("@clack/prompts", () => ({
   outro: vi.fn(),
   select: vi.fn(),
   multiselect: vi.fn(),
-  confirm: vi.fn(),
+  confirm: vi.fn().mockResolvedValue(true),
   isCancel: vi.fn().mockReturnValue(false),
   cancel: vi.fn(),
+  log: {
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    success: vi.fn()
+  },
   spinner: vi.fn().mockReturnValue({ start: vi.fn(), stop: vi.fn() })
 }));
 

package/packages/cli/src/commands/install.ts

@@ -51,7 +51,25 @@ export async function runInstall(
     );
   }
 
-  await installSkills(logicalConfig.skills, projectRoot);
+  if (logicalConfig.skills.length > 0) {
+    const confirmInstall = await clack.confirm({
+      message: `Install ${logicalConfig.skills.length} skill(s) now?`,
+      initialValue: true
+    });
+
+    if (typeof confirmInstall === "symbol") {
+      clack.cancel("Install cancelled.");
+      return;
+    }
+
+    if (confirmInstall) {
+      await installSkills(logicalConfig.skills, projectRoot);
+    } else {
+      clack.log.info(
+        "Skills not installed. Run manually when ready:\n  npx @codemcp/skills experimental_install"
+      );
+    }
+  }
 
   if (logicalConfig.knowledge_sources.length > 0) {
     clack.log.info(

package/packages/cli/src/commands/setup.ts

@@ -172,7 +172,25 @@ export async function runSetup(
     );
   }
 
-  await installSkills(logicalConfig.skills, projectRoot);
+  if (logicalConfig.skills.length > 0) {
+    const confirmInstall = await clack.confirm({
+      message: `Install ${logicalConfig.skills.length} skill(s) now?`,
+      initialValue: true
+    });
+
+    if (typeof confirmInstall === "symbol") {
+      clack.cancel("Setup cancelled.");
+      return;
+    }
+
+    if (confirmInstall) {
+      await installSkills(logicalConfig.skills, projectRoot);
+    } else {
+      clack.log.info(
+        "Skills not installed. Run manually when ready:\n  npx @codemcp/skills experimental_install"
+      );
+    }
+  }
 
   if (logicalConfig.knowledge_sources.length > 0) {
     clack.log.info(

package/packages/core/package.json

@@ -38,5 +38,5 @@
     "typescript": "catalog:",
     "vitest": "catalog:"
   },
-  "version": "0.2.5"
+  "version": "0.3.0"
 }

package/packages/core/src/catalog/catalog.spec.ts

@@ -486,16 +486,7 @@ describe("catalog", () => {
 
       expect(provision).toBeDefined();
       expect(provision!.config).toEqual({
-        profile: "sensible-defaults",
-        capabilities: {
-          read: "allow",
-          edit_write: "allow",
-          search_list: "allow",
-          bash_safe: "allow",
-          bash_unsafe: "ask",
-          web: "ask",
-          task_agent: "allow"
-        }
+        profile: "sensible-defaults"
       });
     });
   });

package/packages/core/src/catalog/facets/autonomy.ts

@@ -1,62 +1,4 @@
-import type {
-  AutonomyCapability,
-  Facet,
-  PermissionDecision,
-  PermissionPolicy
-} from "../../types.js";
-
-const ALL_CAPABILITIES: AutonomyCapability[] = [
-  "read",
-  "edit_write",
-  "search_list",
-  "bash_safe",
-  "bash_unsafe",
-  "web",
-  "task_agent"
-];
-
-function capabilityMap(
-  defaultDecision: PermissionDecision,
-  overrides: Partial<Record<AutonomyCapability, PermissionDecision>> = {}
-): Record<AutonomyCapability, PermissionDecision> {
-  return Object.fromEntries(
-    ALL_CAPABILITIES.map((capability) => [
-      capability,
-      overrides[capability] ?? defaultDecision
-    ])
-  ) as Record<AutonomyCapability, PermissionDecision>;
-}
-
-function autonomyPolicy(
-  profile: PermissionPolicy["profile"]
-): PermissionPolicy {
-  switch (profile) {
-    case "rigid":
-      return {
-        profile,
-        capabilities: capabilityMap("ask")
-      };
-    case "sensible-defaults":
-      return {
-        profile,
-        capabilities: capabilityMap("ask", {
-          read: "allow",
-          edit_write: "allow",
-          search_list: "allow",
-          bash_safe: "allow",
-          task_agent: "allow",
-          web: "ask"
-        })
-      };
-    case "max-autonomy":
-      return {
-        profile,
-        capabilities: capabilityMap("allow", {
-          web: "ask"
-        })
-      };
-  }
-}
+import type { Facet } from "../../types.js";
 
 export const autonomyFacet: Facet = {
   id: "autonomy",
@@ -74,7 +16,7 @@ export const autonomyFacet: Facet = {
       recipe: [
         {
           writer: "permission-policy",
-          config: autonomyPolicy("rigid")
+          config: { profile: "rigid" }
         }
       ]
     },
@@ -86,7 +28,7 @@ export const autonomyFacet: Facet = {
       recipe: [
         {
           writer: "permission-policy",
-          config: autonomyPolicy("sensible-defaults")
+          config: { profile: "sensible-defaults" }
         }
       ]
     },
@@ -98,7 +40,7 @@ export const autonomyFacet: Facet = {
       recipe: [
         {
           writer: "permission-policy",
-          config: autonomyPolicy("max-autonomy")
+          config: { profile: "max-autonomy" }
         }
       ]
     }

package/packages/core/src/index.ts

@@ -15,10 +15,7 @@ export {
   type ExternalSkill,
   type GitHook,
   type PermissionPolicy,
-  type AutonomyProfile,
-  type AutonomyCapability,
-  type PermissionDecision,
-  type PermissionRule
+  type AutonomyProfile
 } from "./types.js";
 export { type ResolutionContext, type ResolvedFacet } from "./types.js";
 export { type UserConfig, type LockFile } from "./types.js";

package/packages/core/src/resolver.spec.ts

@@ -580,7 +580,7 @@ describe("resolve", () => {
   });
 
   describe("autonomy permission policy", () => {
-    it("adds a capability-based permission policy to LogicalConfig and keeps web access on ask", async () => {
+    it("adds a profile-based permission policy to LogicalConfig", async () => {
       const userConfig: UserConfig = {
         choices: { autonomy: "rigid" }
       };
@@ -589,20 +589,11 @@ describe("resolve", () => {
 
       expect(result).toHaveProperty("permission_policy");
       expect((result as Record<string, unknown>).permission_policy).toEqual({
-        profile: "rigid",
-        capabilities: {
-          read: "ask",
-          edit_write: "ask",
-          search_list: "ask",
-          bash_safe: "ask",
-          bash_unsafe: "ask",
-          web: "ask",
-          task_agent: "ask"
-        }
+        profile: "rigid"
       });
     });
 
-    it("uses curated built-in defaults for the sensible-defaults autonomy profile", async () => {
+    it("uses the sensible-defaults autonomy profile", async () => {
       const userConfig: UserConfig = {
         choices: { autonomy: "sensible-defaults" }
       };
@@ -610,16 +601,7 @@ describe("resolve", () => {
       const result = await resolve(userConfig, catalog, registry);
 
       expect(result.permission_policy).toEqual({
-        profile: "sensible-defaults",
-        capabilities: {
-          read: "allow",
-          edit_write: "allow",
-          search_list: "allow",
-          bash_safe: "allow",
-          bash_unsafe: "ask",
-          web: "ask",
-          task_agent: "allow"
-        }
+        profile: "sensible-defaults"
       });
     });
   });

package/packages/core/src/resolver.ts

@@ -179,11 +179,7 @@ function mergePermissionPolicy(
 
   return {
     ...existing,
-    ...incoming,
-    capabilities: {
-      ...existing.capabilities,
-      ...incoming.capabilities
-    }
+    ...incoming
   };
 }
 

package/packages/core/src/types.ts

@@ -68,28 +68,8 @@ export interface GitHook {
 
 export type AutonomyProfile = "rigid" | "sensible-defaults" | "max-autonomy";
 
-export type PermissionDecision = "ask" | "allow" | "deny";
-
-export type AutonomyCapability =
-  | "read"
-  | "edit_write"
-  | "search_list"
-  | "bash_safe"
-  | "bash_unsafe"
-  | "web"
-  | "task_agent";
-
-/**
- * @deprecated Harness-specific tool-level rules are no longer produced by core.
- * Kept temporarily as a compatibility type for downstream packages.
- */
-export type PermissionRule =
-  | PermissionDecision
-  | Record<string, PermissionDecision>;
-
 export interface PermissionPolicy extends Record<string, unknown> {
   profile: AutonomyProfile;
-  capabilities: Record<AutonomyCapability, PermissionDecision>;
 }
 
 export interface LogicalConfig extends Record<string, unknown> {

package/packages/harnesses/package.json

@@ -28,6 +28,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
+    "@clack/prompts": "^1.1.0",
     "@codemcp/ade-core": "workspace:*",
     "@codemcp/skills": "^2.3.0"
   },
@@ -39,5 +40,5 @@
     "typescript": "catalog:",
     "vitest": "catalog:"
   },
-  "version": "0.2.5"
+  "version": "0.3.0"
 }

package/packages/harnesses/src/permission-policy.ts

@@ -1,121 +1,4 @@
-import type {
-  AutonomyCapability,
-  LogicalConfig,
-  PermissionDecision,
-  PermissionRule
-} from "@codemcp/ade-core";
-
-const SENSIBLE_DEFAULTS_RULES: Record<string, PermissionRule> = {
-  read: {
-    "*": "allow",
-    "*.env": "deny",
-    "*.env.*": "deny",
-    "*.env.example": "allow"
-  },
-  edit: "allow",
-  glob: "allow",
-  grep: "allow",
-  list: "allow",
-  lsp: "allow",
-  task: "allow",
-  todoread: "deny",
-  todowrite: "deny",
-  skill: "deny",
-  webfetch: "ask",
-  websearch: "ask",
-  codesearch: "ask",
-  bash: {
-    "*": "deny",
-    "grep *": "allow",
-    "rg *": "allow",
-    "find *": "allow",
-    "fd *": "allow",
-    ls: "allow",
-    "ls *": "allow",
-    "cat *": "allow",
-    "head *": "allow",
-    "tail *": "allow",
-    "wc *": "allow",
-    "sort *": "allow",
-    "uniq *": "allow",
-    "diff *": "allow",
-    "echo *": "allow",
-    "printf *": "allow",
-    pwd: "allow",
-    "which *": "allow",
-    "type *": "allow",
-    whoami: "allow",
-    date: "allow",
-    "date *": "allow",
-    env: "allow",
-    "tree *": "allow",
-    "file *": "allow",
-    "stat *": "allow",
-    "readlink *": "allow",
-    "realpath *": "allow",
-    "dirname *": "allow",
-    "basename *": "allow",
-    "sed *": "allow",
-    "awk *": "allow",
-    "cut *": "allow",
-    "tr *": "allow",
-    "tee *": "allow",
-    "xargs *": "allow",
-    "jq *": "allow",
-    "yq *": "allow",
-    "mkdir *": "allow",
-    "touch *": "allow",
-    "cp *": "ask",
-    "mv *": "ask",
-    "ln *": "ask",
-    "npm *": "ask",
-    "node *": "ask",
-    "pip *": "ask",
-    "python *": "ask",
-    "python3 *": "ask",
-    "rm *": "deny",
-    "rmdir *": "deny",
-    "curl *": "deny",
-    "wget *": "deny",
-    "chmod *": "deny",
-    "chown *": "deny",
-    "sudo *": "deny",
-    "su *": "deny",
-    "sh *": "deny",
-    "bash *": "deny",
-    "zsh *": "deny",
-    "eval *": "deny",
-    "exec *": "deny",
-    "source *": "deny",
-    ". *": "deny",
-    "nohup *": "deny",
-    "dd *": "deny",
-    "mkfs *": "deny",
-    "mount *": "deny",
-    "umount *": "deny",
-    "kill *": "deny",
-    "killall *": "deny",
-    "pkill *": "deny",
-    "nc *": "deny",
-    "ncat *": "deny",
-    "ssh *": "deny",
-    "scp *": "deny",
-    "rsync *": "deny",
-    "docker *": "deny",
-    "kubectl *": "deny",
-    "systemctl *": "deny",
-    "service *": "deny",
-    "crontab *": "deny",
-    reboot: "deny",
-    "shutdown *": "deny",
-    "passwd *": "deny",
-    "useradd *": "deny",
-    "userdel *": "deny",
-    "iptables *": "deny"
-  },
-  external_directory: "deny",
-  doom_loop: "deny"
-};
+import type { LogicalConfig } from "@codemcp/ade-core";
 
 export function getAutonomyProfile(config: LogicalConfig) {
   return config.permission_policy?.profile;
@@ -124,50 +7,3 @@ export function getAutonomyProfile(config: LogicalConfig) {
 export function hasPermissionPolicy(config: LogicalConfig): boolean {
   return config.permission_policy !== undefined;
 }
-
-export function getCapabilityDecision(
-  config: LogicalConfig,
-  capability: AutonomyCapability
-): PermissionDecision | undefined {
-  return config.permission_policy?.capabilities?.[capability];
-}
-
-export function allowsCapability(
-  config: LogicalConfig,
-  capability: AutonomyCapability
-): boolean {
-  return getCapabilityDecision(config, capability) === "allow";
-}
-
-export function keepsWebOnAsk(config: LogicalConfig): boolean {
-  return getCapabilityDecision(config, "web") === "ask";
-}
-
-export function getHarnessPermissionRules(
-  config: LogicalConfig
-): Record<string, PermissionRule> | undefined {
-  switch (config.permission_policy?.profile) {
-    case "rigid":
-      return {
-        "*": "ask",
-        webfetch: "ask",
-        websearch: "ask",
-        codesearch: "ask",
-        external_directory: "deny",
-        doom_loop: "deny"
-      };
-    case "sensible-defaults":
-      return SENSIBLE_DEFAULTS_RULES;
-    case "max-autonomy":
-      return {
-        "*": "allow",
-        webfetch: "ask",
-        websearch: "ask",
-        codesearch: "ask",
-        external_directory: "deny",
-        doom_loop: "deny"
-      };
-    default:
-      return undefined;
-  }
-}

package/packages/harnesses/src/util.spec.ts

@@ -0,0 +1,97 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { mkdtemp, rm, mkdir, readFile, stat } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import * as clack from "@clack/prompts";
+import type { GitHook } from "@codemcp/ade-core";
+import { writeGitHooks } from "./util.js";
+
+describe("writeGitHooks", () => {
+  let dir: string;
+
+  beforeEach(async () => {
+    dir = await mkdtemp(join(tmpdir(), "ade-util-git-hooks-"));
+    vi.spyOn(clack.log, "warn").mockImplementation(() => undefined);
+  });
+
+  afterEach(async () => {
+    await rm(dir, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  it("is a no-op when hooks is undefined", async () => {
+    await expect(writeGitHooks(undefined, dir)).resolves.toBeUndefined();
+    expect(clack.log.warn).not.toHaveBeenCalled();
+  });
+
+  it("is a no-op when hooks array is empty", async () => {
+    await expect(writeGitHooks([], dir)).resolves.toBeUndefined();
+    expect(clack.log.warn).not.toHaveBeenCalled();
+  });
+
+  it("warns and skips gracefully when .git directory does not exist", async () => {
+    const hooks: GitHook[] = [
+      { phase: "pre-commit", script: "#!/bin/sh\nnpx lint-staged" }
+    ];
+
+    await expect(writeGitHooks(hooks, dir)).resolves.toBeUndefined();
+
+    expect(clack.log.warn).toHaveBeenCalledOnce();
+    expect(clack.log.warn).toHaveBeenCalledWith(
+      expect.stringContaining("not a git repository")
+    );
+
+    // No .git/hooks directory should have been created
+    await expect(stat(join(dir, ".git"))).rejects.toThrow();
+  });
+
+  it("writes hook files when .git exists", async () => {
+    await mkdir(join(dir, ".git"), { recursive: true });
+
+    const script = "#!/bin/sh\nnpx lint-staged\n";
+    const hooks: GitHook[] = [{ phase: "pre-commit", script }];
+
+    await writeGitHooks(hooks, dir);
+
+    expect(clack.log.warn).not.toHaveBeenCalled();
+
+    const written = await readFile(
+      join(dir, ".git", "hooks", "pre-commit"),
+      "utf-8"
+    );
+    expect(written).toBe(script);
+  });
+
+  it("creates .git/hooks directory if it does not exist yet", async () => {
+    // .git exists but no hooks subdir
+    await mkdir(join(dir, ".git"), { recursive: true });
+
+    const hooks: GitHook[] = [{ phase: "pre-commit", script: "#!/bin/sh\n" }];
+    await writeGitHooks(hooks, dir);
+
+    const hookStat = await stat(join(dir, ".git", "hooks"));
+    expect(hookStat.isDirectory()).toBe(true);
+  });
+
+  it("writes multiple hooks", async () => {
+    await mkdir(join(dir, ".git"), { recursive: true });
+
+    const hooks: GitHook[] = [
+      { phase: "pre-commit", script: "#!/bin/sh\necho pre-commit\n" },
+      { phase: "pre-push", script: "#!/bin/sh\necho pre-push\n" }
+    ];
+
+    await writeGitHooks(hooks, dir);
+
+    const preCommit = await readFile(
+      join(dir, ".git", "hooks", "pre-commit"),
+      "utf-8"
+    );
+    const prePush = await readFile(
+      join(dir, ".git", "hooks", "pre-push"),
+      "utf-8"
+    );
+    expect(preCommit).toBe(hooks[0].script);
+    expect(prePush).toBe(hooks[1].script);
+  });
+});

package/packages/harnesses/src/util.ts

@@ -1,5 +1,6 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
+import * as clack from "@clack/prompts";
 import type { GitHook, LogicalConfig, McpServerEntry } from "@codemcp/ade-core";
 
 // ---------------------------------------------------------------------------
@@ -169,15 +170,31 @@ export async function writeAgentMd(
 /**
  * Write git hook scripts to `.git/hooks/<phase>`.
  * Files are created with executable permissions (0o755).
- * No-op when the hooks array is empty.
+ * No-op when the hooks array is empty or undefined.
+ * Emits a warning and skips gracefully when the project root is not a git repository.
  */
 export async function writeGitHooks(
   hooks: GitHook[] | undefined,
   projectRoot: string
 ): Promise<void> {
-  if (!hooks) return;
+  if (!hooks || hooks.length === 0) return;
+
+  const gitDir = join(projectRoot, ".git");
+  try {
+    await access(gitDir);
+  } catch {
+    clack.log.warn(
+      "Git hooks were configured but could not be installed: the project is not a git repository.\n" +
+        "Run `git init` and re-run setup to install the hooks."
+    );
+    return;
+  }
+
+  const hooksDir = join(gitDir, "hooks");
+  await mkdir(hooksDir, { recursive: true });
+
   for (const hook of hooks) {
-    const hookPath = join(projectRoot, ".git", "hooks", hook.phase);
+    const hookPath = join(hooksDir, hook.phase);
     await writeFile(hookPath, hook.script, { mode: 0o755 });
   }
 }
@@ -219,3 +236,14 @@ export async function writeInlineSkills(
 
   return modified;
 }
+
+// ---------------------------------------------------------------------------
+// YAML helpers
+// ---------------------------------------------------------------------------
+
+/** Quote a YAML key only when it contains characters that require quoting. */
+export function formatYamlKey(value: string): string {
+  return /^[A-Za-z_][A-Za-z0-9_-]*$/.test(value)
+    ? value
+    : JSON.stringify(value);
+}