ide-agents 0.1.1 → 0.3.0

package/dist/scan.js

@@ -15,7 +15,7 @@ function parseAllowedScope(data) {
     if (scope === "global" || scope === "project" || scope === "any") {
         return scope;
     }
-    return null;
+    return "any";
 }
 function parseAgentDescription(content, fallbackName) {
     const parsed = matter(content);
@@ -37,45 +37,74 @@ function parseAgentDescription(content, fallbackName) {
     }
     return fallbackName;
 }
-async function scanSkills(repoPath) {
-    const skillsDir = path.join(repoPath, "skills");
-    if (!(await pathExists(skillsDir))) {
+async function parseSkillDirectory(skillDir, dirName) {
+    const skillMdPath = path.join(skillDir, "SKILL.md");
+    const hasSkillMd = await pathExists(skillMdPath);
+    let name = dirName;
+    let description = "";
+    let allowedScope = "any";
+    if (hasSkillMd) {
+        const raw = await readFile(skillMdPath, "utf8");
+        const parsed = matter(raw);
+        if (typeof parsed.data.name === "string" && parsed.data.name.trim()) {
+            name = parsed.data.name.trim();
+        }
+        if (typeof parsed.data.description === "string") {
+            description = parsed.data.description.trim();
+        }
+        allowedScope = parseAllowedScope(parsed.data);
+    }
+    return { id: dirName, name, description, hasSkillMd, allowedScope };
+}
+function toSkillArtifact(sourcePath, parsed) {
+    return {
+        id: parsed.id,
+        kind: "skill",
+        sourcePath,
+        name: parsed.name,
+        description: parsed.description,
+        hasSkillMd: parsed.hasSkillMd,
+        allowedScope: parsed.allowedScope,
+    };
+}
+async function scanSkillsInDirectory(parentDir, sourcePathPrefix) {
+    if (!(await pathExists(parentDir))) {
         return [];
     }
-    const entries = await readdir(skillsDir, { withFileTypes: true });
+    const entries = await readdir(parentDir, { withFileTypes: true });
     const artifacts = [];
     for (const entry of entries) {
         if (!entry.isDirectory())
             continue;
-        const skillDir = path.join(skillsDir, entry.name);
+        if (entry.name.startsWith("."))
+            continue;
+        const skillDir = path.join(parentDir, entry.name);
         const skillMdPath = path.join(skillDir, "SKILL.md");
-        const hasSkillMd = await pathExists(skillMdPath);
-        let name = entry.name;
-        let description = "";
-        let allowedScope = null;
-        if (hasSkillMd) {
-            const raw = await readFile(skillMdPath, "utf8");
-            const parsed = matter(raw);
-            if (typeof parsed.data.name === "string" && parsed.data.name.trim()) {
-                name = parsed.data.name.trim();
-            }
-            if (typeof parsed.data.description === "string") {
-                description = parsed.data.description.trim();
-            }
-            allowedScope = parseAllowedScope(parsed.data);
+        if (!(await pathExists(skillMdPath))) {
+            continue;
         }
-        artifacts.push({
-            id: entry.name,
-            kind: "skill",
-            sourcePath: path.join("skills", entry.name),
-            name,
-            description,
-            hasSkillMd,
-            allowedScope,
-        });
+        const parsed = await parseSkillDirectory(skillDir, entry.name);
+        const relativeSource = sourcePathPrefix
+            ? path.join(sourcePathPrefix, entry.name)
+            : entry.name;
+        artifacts.push(toSkillArtifact(relativeSource, parsed));
     }
     return artifacts.sort((a, b) => a.id.localeCompare(b.id));
 }
+async function scanSkillsNested(repoPath) {
+    return scanSkillsInDirectory(path.join(repoPath, "skills"), "skills");
+}
+/** Repos like bluriesophos/cursorskills: `<repo>/<skill-name>/SKILL.md` at root. */
+async function scanSkillsFlat(repoPath) {
+    return scanSkillsInDirectory(repoPath, "");
+}
+async function scanSkills(repoPath) {
+    const nested = await scanSkillsNested(repoPath);
+    if (nested.length > 0) {
+        return nested;
+    }
+    return scanSkillsFlat(repoPath);
+}
 async function scanAgents(repoPath) {
     const agentsDir = path.join(repoPath, "agents");
     if (!(await pathExists(agentsDir))) {

package/dist/server.js

@@ -3,11 +3,13 @@ import fastifyStatic from "@fastify/static";
 import { v4 as uuidv4 } from "uuid";
 import { addRecentProject, readConfig, writeConfig, } from "./config.js";
 import { cloneRepo, fetchRepo, getGitStatusWithoutFetch, pullRepo, } from "./git.js";
+import { bootstrapEmptyRepo } from "./template.js";
 import { applyInstallations } from "./apply.js";
 import { scanRepoArtifacts } from "./scan.js";
 import { getArtifactTargets } from "./targets.js";
-import { getIdeAgentsHome, getRepoPath, getWebDistDir, slugFromUrl, } from "./paths.js";
-import { PACKAGE_VERSION as VERSION } from "./types.js";
+import { expandUserPath, getIdeAgentsHome, getRepoPath, getWebDistDir, slugFromUrl, } from "./paths.js";
+import { defaultAdapterFromIdes, getDefaultIdes } from "./ides.js";
+import { PACKAGE_VERSION as VERSION } from "./version.js";
 export async function createServer(options) {
     const app = Fastify({ logger: false });
     app.setErrorHandler((error, _request, reply) => {
@@ -19,21 +21,70 @@ export async function createServer(options) {
         const config = await readConfig();
         return {
             home: getIdeAgentsHome(),
-            adapter: config.adapter,
             port: options.port,
             version: VERSION,
             defaultProjectPath: options.launchCwd ?? null,
+            ides: config.ides,
         };
     });
+    app.get("/api/settings", async () => {
+        const config = await readConfig();
+        return {
+            ides: config.ides,
+            defaults: getDefaultIdes(),
+            home: getIdeAgentsHome(),
+            version: VERSION,
+        };
+    });
+    app.put("/api/settings", async (request, reply) => {
+        const { ides } = request.body ?? {};
+        if (!ides) {
+            return reply.status(400).send({ error: "ides is required" });
+        }
+        for (const key of ["cursor", "claude", "codex"]) {
+            const entry = ides[key];
+            if (!entry || typeof entry.configPath !== "string" || !entry.configPath.trim()) {
+                return reply.status(400).send({ error: `Invalid config for ${key}` });
+            }
+        }
+        const normalized = {
+            cursor: {
+                enabled: Boolean(ides.cursor.enabled),
+                configPath: expandUserPath(ides.cursor.configPath),
+            },
+            claude: {
+                enabled: Boolean(ides.claude.enabled),
+                configPath: expandUserPath(ides.claude.configPath),
+            },
+            codex: {
+                enabled: Boolean(ides.codex.enabled),
+                configPath: expandUserPath(ides.codex.configPath),
+            },
+        };
+        if (!normalized.cursor.enabled &&
+            !normalized.claude.enabled &&
+            !normalized.codex.enabled) {
+            return reply.status(400).send({ error: "At least one IDE must be enabled" });
+        }
+        const config = await readConfig();
+        config.ides = normalized;
+        config.adapter = defaultAdapterFromIdes(config.ides);
+        await writeConfig(config);
+        return { ides: config.ides };
+    });
     app.get("/api/repos", async () => {
         const config = await readConfig();
         const repos = [];
         for (const repo of config.repos) {
             const git = await getGitStatusWithoutFetch(repo.slug, repo.ref);
+            const repoPath = getRepoPath(repo.slug);
+            const artifacts = await scanRepoArtifacts(repoPath);
             repos.push({
                 ...repo,
-                localPath: getRepoPath(repo.slug),
+                localPath: repoPath,
                 git,
+                skillCount: artifacts.filter((a) => a.kind === "skill").length,
+                agentCount: artifacts.filter((a) => a.kind === "agent").length,
             });
         }
         return { repos };
@@ -49,14 +100,16 @@ export async function createServer(options) {
         if (config.repos.some((r) => r.id === repoId)) {
             return reply.status(409).send({ error: `Repository id already exists: ${repoId}` });
         }
+        let repoPath;
         try {
-            await cloneRepo(url.trim(), slug, ref);
+            repoPath = await cloneRepo(url.trim(), slug, ref);
         }
         catch (err) {
             return reply.status(400).send({
                 error: err instanceof Error ? err.message : String(err),
             });
         }
+        const bootstrap = await bootstrapEmptyRepo(repoPath, ref);
         const repo = { id: repoId, url: url.trim(), ref, slug };
         config.repos.push(repo);
         await writeConfig(config);
@@ -66,7 +119,10 @@ export async function createServer(options) {
                 ...repo,
                 localPath: getRepoPath(slug),
                 git,
+                skillCount: bootstrap.skillCount,
+                agentCount: bootstrap.agentCount,
             },
+            bootstrap,
         };
     });
     app.delete("/api/repos/:id", async (request, reply) => {
@@ -80,6 +136,38 @@ export async function createServer(options) {
         await writeConfig(config);
         return { ok: true };
     });
+    app.post("/api/repos/:id/bootstrap", async (request, reply) => {
+        const config = await readConfig();
+        const repo = config.repos.find((r) => r.id === request.params.id);
+        if (!repo) {
+            return reply.status(404).send({ error: "Repository not found" });
+        }
+        const repoPath = getRepoPath(repo.slug);
+        try {
+            const bootstrap = await bootstrapEmptyRepo(repoPath, repo.ref);
+            if (!bootstrap.applied) {
+                return reply.status(409).send({
+                    error: "Repository is not empty — bootstrap skipped",
+                });
+            }
+            const git = await getGitStatusWithoutFetch(repo.slug, repo.ref);
+            return {
+                repo: {
+                    ...repo,
+                    localPath: repoPath,
+                    git,
+                    skillCount: bootstrap.skillCount,
+                    agentCount: bootstrap.agentCount,
+                },
+                bootstrap,
+            };
+        }
+        catch (err) {
+            return reply.status(400).send({
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    });
     app.post("/api/repos/:id/fetch", async (request, reply) => {
         const config = await readConfig();
         const repo = config.repos.find((r) => r.id === request.params.id);
@@ -97,6 +185,23 @@ export async function createServer(options) {
         const git = await getGitStatusWithoutFetch(repo.slug, repo.ref);
         return { git };
     });
+    app.post("/api/repos/:id/check-updates", async (request, reply) => {
+        const config = await readConfig();
+        const repo = config.repos.find((r) => r.id === request.params.id);
+        if (!repo) {
+            return reply.status(404).send({ error: "Repository not found" });
+        }
+        try {
+            await fetchRepo(repo.slug);
+        }
+        catch (err) {
+            return reply.status(400).send({
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+        const git = await getGitStatusWithoutFetch(repo.slug, repo.ref);
+        return { git };
+    });
     app.post("/api/repos/:id/pull", async (request, reply) => {
         const config = await readConfig();
         const repo = config.repos.find((r) => r.id === request.params.id);
@@ -124,7 +229,7 @@ export async function createServer(options) {
         const scanned = await scanRepoArtifacts(getRepoPath(repo.slug));
         const artifacts = await Promise.all(scanned.map(async (artifact) => ({
             ...artifact,
-            targets: await getArtifactTargets(artifact, projectPath, config.adapter),
+            targets: await getArtifactTargets(artifact, projectPath, config),
         })));
         return { artifacts };
     });

package/dist/targets.d.ts

@@ -1,4 +1,5 @@
+import type { IdeAgentsConfig } from "./types.js";
 import type { Artifact, ArtifactTargets, Installation, TargetStatus } from "./types.js";
 export declare function getTargetStatus(targetPath: string): Promise<TargetStatus>;
-export declare function getArtifactTargets(artifact: Pick<Artifact, "kind" | "id">, projectPath: string | null, adapterId: string): Promise<ArtifactTargets>;
+export declare function getArtifactTargets(artifact: Pick<Artifact, "kind" | "id">, projectPath: string | null, config: IdeAgentsConfig): Promise<ArtifactTargets>;
 export declare function installationStub(artifact: Pick<Artifact, "kind" | "id" | "sourcePath">, projectPath: string | null): Pick<Installation, "kind" | "targetName" | "sourcePath" | "projectPath">;

package/dist/targets.js

@@ -1,5 +1,5 @@
 import { lstat } from "node:fs/promises";
-import { getAdapter } from "./adapters/cursor.js";
+import { getEnabledAdapters } from "./adapters/index.js";
 export async function getTargetStatus(targetPath) {
     try {
         const stats = await lstat(targetPath);
@@ -18,17 +18,35 @@ export async function getTargetStatus(targetPath) {
         };
     }
 }
-export async function getArtifactTargets(artifact, projectPath, adapterId) {
-    const adapter = getAdapter(adapterId);
+function mergeTargetStatus(current, next) {
+    return {
+        exists: current.exists || next.exists,
+        isSymlink: current.isSymlink || next.isSymlink,
+        blocked: current.blocked || next.blocked,
+    };
+}
+export async function getArtifactTargets(artifact, projectPath, config) {
+    const adapters = getEnabledAdapters(config);
     const installation = {
         kind: artifact.kind,
         targetName: artifact.id,
         projectPath,
     };
-    const global = await getTargetStatus(adapter.getGlobalTargetPath(installation));
+    let global = {
+        exists: false,
+        isSymlink: false,
+        blocked: false,
+    };
     let project = null;
-    if (projectPath) {
-        project = await getTargetStatus(adapter.getProjectTargetPath(installation));
+    for (const adapter of adapters) {
+        const globalStatus = await getTargetStatus(adapter.getGlobalTargetPath(installation));
+        global = mergeTargetStatus(global, globalStatus);
+        if (projectPath) {
+            const projectStatus = await getTargetStatus(adapter.getProjectTargetPath(installation));
+            project = project
+                ? mergeTargetStatus(project, projectStatus)
+                : projectStatus;
+        }
     }
     return { global, project };
 }

package/dist/template.d.ts

@@ -0,0 +1,12 @@
+export interface BootstrapResult {
+    applied: boolean;
+    pushed: boolean;
+    pushError?: string;
+    skillCount: number;
+    agentCount: number;
+}
+export declare function getTemplateDir(): string;
+/** True when the clone has no installable artifacts and no custom content. */
+export declare function isEmptySkillRepo(repoPath: string): Promise<boolean>;
+export declare function applyTemplateToRepo(repoPath: string): Promise<void>;
+export declare function bootstrapEmptyRepo(repoPath: string, ref: string): Promise<BootstrapResult>;

package/dist/template.js

@@ -0,0 +1,86 @@
+import { cp, readdir, stat } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { commitAndPushRepo } from "./git.js";
+import { scanRepoArtifacts } from "./scan.js";
+const GITHUB_INIT_FILES = new Set([
+    "README.md",
+    "LICENSE",
+    "LICENSE.md",
+    "LICENSE.txt",
+    ".gitignore",
+]);
+export function getTemplateDir() {
+    const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+    return path.resolve(moduleDir, "../template");
+}
+async function pathExists(filePath) {
+    try {
+        await stat(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** True when the clone has no installable artifacts and no custom content. */
+export async function isEmptySkillRepo(repoPath) {
+    const artifacts = await scanRepoArtifacts(repoPath);
+    if (artifacts.length > 0) {
+        return false;
+    }
+    const entries = await readdir(repoPath, { withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.name === ".git") {
+            continue;
+        }
+        if (entry.isDirectory()) {
+            return false;
+        }
+        if (!GITHUB_INIT_FILES.has(entry.name)) {
+            return false;
+        }
+    }
+    return true;
+}
+export async function applyTemplateToRepo(repoPath) {
+    const templateDir = getTemplateDir();
+    if (!(await pathExists(templateDir))) {
+        throw new Error(`Template directory not found: ${templateDir}`);
+    }
+    const entries = await readdir(templateDir, { withFileTypes: true });
+    for (const entry of entries) {
+        const src = path.join(templateDir, entry.name);
+        const dest = path.join(repoPath, entry.name);
+        await cp(src, dest, { recursive: true, force: true });
+    }
+}
+export async function bootstrapEmptyRepo(repoPath, ref) {
+    if (!(await isEmptySkillRepo(repoPath))) {
+        const artifacts = await scanRepoArtifacts(repoPath);
+        return {
+            applied: false,
+            pushed: false,
+            skillCount: artifacts.filter((a) => a.kind === "skill").length,
+            agentCount: artifacts.filter((a) => a.kind === "agent").length,
+        };
+    }
+    await applyTemplateToRepo(repoPath);
+    let pushed = false;
+    let pushError;
+    try {
+        await commitAndPushRepo(repoPath, ref);
+        pushed = true;
+    }
+    catch (err) {
+        pushError = err instanceof Error ? err.message : String(err);
+    }
+    const artifacts = await scanRepoArtifacts(repoPath);
+    return {
+        applied: true,
+        pushed,
+        pushError,
+        skillCount: artifacts.filter((a) => a.kind === "skill").length,
+        agentCount: artifacts.filter((a) => a.kind === "agent").length,
+    };
+}

package/dist/types.d.ts

@@ -1,6 +1,17 @@
 export type ArtifactKind = "skill" | "agent";
 export type ArtifactAllowedScope = "global" | "project" | "any";
-export type AdapterId = "cursor";
+export type IdeId = "cursor" | "claude" | "codex";
+/** @deprecated use IdeId */
+export type AdapterId = IdeId;
+export interface IdeToolConfig {
+    enabled: boolean;
+    configPath: string;
+}
+export interface IdesConfig {
+    cursor: IdeToolConfig;
+    claude: IdeToolConfig;
+    codex: IdeToolConfig;
+}
 export interface ServerConfig {
     port: number;
 }
@@ -23,7 +34,9 @@ export interface Installation {
 }
 export interface IdeAgentsConfig {
     version: 1;
+    /** @deprecated kept for migration; use ides */
     adapter: AdapterId;
+    ides: IdesConfig;
     server: ServerConfig;
     repos: RepoConfig[];
     installations: Installation[];
@@ -61,6 +74,8 @@ export interface GitStatus {
 export interface RepoWithStatus extends RepoConfig {
     localPath: string;
     git: GitStatus;
+    skillCount: number;
+    agentCount: number;
 }
 export interface ApplyResultItem {
     path: string;
@@ -70,6 +85,5 @@ export interface ApplyResultItem {
 export interface ApplyResult {
     results: ApplyResultItem[];
 }
-export declare const PACKAGE_VERSION = "0.1.0";
 /** @deprecated legacy config field */
 export type Scope = "global" | "project" | "off";

package/dist/types.js

@@ -1 +1 @@
-export const PACKAGE_VERSION = "0.1.0";
+export {};

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const PACKAGE_VERSION: string;

package/dist/version.js

@@ -0,0 +1,6 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const require = createRequire(import.meta.url);
+const { version } = require(path.join(fileURLToPath(new URL(".", import.meta.url)), "../package.json"));
+export const PACKAGE_VERSION = version;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ide-agents",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "Local admin for IDE agents and skills from git repos",
   "type": "module",
   "bin": {
@@ -8,6 +8,7 @@
   },
   "files": [
     "dist",
+    "template",
     "web/dist",
     "LICENSE",
     "README.md"
@@ -23,7 +24,9 @@
     "start": "node dist/cli.js",
     "docs:install": "npm install --prefix docs",
     "docs:start": "npm --prefix docs start",
-    "docs:build": "npm --prefix docs run build"
+    "docs:build": "npm --prefix docs run build",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix"
   },
   "engines": {
     "node": ">=20"
@@ -51,27 +54,32 @@
   },
   "dependencies": {
     "@fastify/static": "^8.1.1",
-    "fastify": "^5.2.1",
+    "fastify": "^5.8.5",
     "gray-matter": "^4.0.3",
     "uuid": "^11.1.0"
   },
   "devDependencies": {
+    "@eslint/js": "^10.0.1",
     "@mantine/core": "^9.2.2",
     "@mantine/hooks": "^9.2.2",
     "@tabler/icons-react": "^3.44.0",
     "@types/node": "^22.13.10",
-    "@types/react": "^19.0.10",
-    "@types/react-dom": "^19.0.4",
-    "@vitejs/plugin-react": "^4.3.4",
+    "@types/react": "^19.2.15",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^6.0.2",
     "concurrently": "^9.1.2",
+    "eslint": "^10.4.1",
+    "eslint-plugin-react-hooks": "^7.1.1",
+    "globals": "^16.5.0",
     "postcss": "^8.5.15",
     "postcss-preset-mantine": "^1.18.0",
     "postcss-simple-vars": "^7.0.1",
-    "react": "^19.0.0",
-    "react-dom": "^19.0.0",
+    "react": "^19.2.6",
+    "react-dom": "^19.2.6",
     "react-router-dom": "^7.3.0",
     "tsx": "^4.19.3",
     "typescript": "^5.8.2",
-    "vite": "^6.2.1"
+    "typescript-eslint": "^8.60.0",
+    "vite": "^8.0.14"
   }
 }

package/template/.agents/AGENTS.md

@@ -0,0 +1,51 @@
+# Codex — repository guide
+
+This repository holds **Agent Skills** and **agents** consumed by ide-agents.
+
+## Expected layout
+
+```
+skills/<skill-id>/
+├── SKILL.md
+├── scripts/       # optional — *.mjs generators (stdlib, ESM)
+└── assets/        # optional — JSON config for scripts
+agents/<agent-id>.md
+```
+
+## SKILL.md
+
+Required frontmatter:
+
+```yaml
+---
+name: skill-id
+description: Short summary for the UI.
+scope: any
+---
+```
+
+Project installs symlink into `<project>/.agents/skills/<name>`.
+
+## Agents
+
+Markdown files in `agents/<agent-id>.md`. Required frontmatter:
+
+```yaml
+---
+name: agent-id          # must match filename stem
+description: When the IDE should delegate to this subagent.
+scope: any              # optional — ide-agents install toggles
+---
+```
+
+Project installs use `.agents/agents/<name>.md`.
+
+Agents define **role and workflow** only. Repeatable generators (stack detection, audits, structured reports) go in `skills/<skill-id>/scripts/` — agents invoke `node <SKILL_DIR>/scripts/….mjs` instead of improvising the same logic in chat. Pattern: [repo-audit-skills](https://github.com/sergeychernov/repo-audit-skills).
+
+## Editing rules
+
+- Do not flatten skills to repo root unless you intentionally use the flat layout (ide-agents detects nested `skills/` first).
+- Preserve skill folder names — they become installation ids.
+- Push to git after changes so remote catalogs stay in sync.
+
+See `README.md` for usage with ide-agents.

package/template/.claude/CLAUDE.md

@@ -0,0 +1,37 @@
+# Claude Code — repository guide
+
+This repo is a **skills and agents catalog** for ide-agents.
+
+## Layout
+
+- `skills/<name>/SKILL.md` — skills with YAML frontmatter (`name`, `description`, `scope`)
+- `skills/<name>/scripts/` — optional Node `.mjs` generators (stable scans, JSON reports)
+- `skills/<name>/assets/` — optional JSON/markers scripts read
+- `agents/<name>.md` — subagent orchestrators; frontmatter `name`, `description`, optional `scope`
+
+## Agents and scripts
+
+Do **not** implement multi-step repo scanners or report generators inline in agent markdown. Put them in `skills/<skill-id>/scripts/` and have agents run:
+
+```bash
+node <SKILL_DIR>/scripts/<script>.mjs
+```
+
+Then read stdout (`--json`) or documented output files. See repo-audit-skills for reference (`detect-stack.mjs`, `run-audit.mjs`).
+
+## When editing
+
+- Keep one skill per folder; the folder name is the skill id.
+- Use `scope: any` unless the skill must be global-only or project-only.
+- Write instructions in the skill body, not only in frontmatter.
+- Commit meaningful changes; ide-agents symlinks from the cloned copy under `~/.ide-agents/repos/`.
+
+## Scope values
+
+| Value | Meaning |
+|-------|---------|
+| `global` | Install only to user config (`~/.claude/`) |
+| `project` | Install only to project `.claude/` |
+| `any` | User chooses global or project in the UI |
+
+See `README.md` for the full catalog overview.