ccdesk 0.2.2 → 0.2.4

package/dist/core/scan/git.js

@@ -0,0 +1,106 @@
+import { execFile } from "node:child_process";
+import { dirname, normalize, relative } from "node:path";
+import { promisify } from "node:util";
+import {} from "../../shared/types.js";
+import {} from "./env.js";
+import { isWithin } from "./files.js";
+const run = promisify(execFile);
+export async function gitRoot(dir) {
+    try {
+        const { stdout } = await run("git", ["-C", dir, "rev-parse", "--show-toplevel"], {
+            timeout: 5000,
+        });
+        // Git prints forward slashes on Windows too; normalise so path comparisons hold.
+        return stdout.trim() ? normalize(stdout.trim()) : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Every checkout of the repository `dir` is in, the main one first; empty outside git. */
+export async function worktrees(dir) {
+    try {
+        const { stdout } = await run("git", ["-C", dir, "worktree", "list", "--porcelain"], {
+            timeout: 5000,
+        });
+        return stdout
+            .split("\n")
+            .filter((line) => line.startsWith("worktree "))
+            .map((line) => normalize(line.slice("worktree ".length)));
+    }
+    catch {
+        return [];
+    }
+}
+/** Main worktree root: worktrees of one repository share Claude Code's auto memory. */
+export async function mainWorktreeRoot(dir) {
+    try {
+        const { stdout } = await run("git", ["-C", dir, "rev-parse", "--path-format=absolute", "--git-common-dir"], { timeout: 5000 });
+        const common = stdout.trim();
+        if (!common)
+            return null;
+        return common.endsWith("/.git") || common.endsWith("\\.git")
+            ? normalize(dirname(common))
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The key ~/.claude.json keeps a folder's trust answers and local MCP servers under: the main
+ * checkout's root, else the repository root, else the folder itself outside git. The scan reads
+ * under it and `claude mcp add --scope local` writes under it, so both take it from here.
+ */
+export function trustKey(dir, mainRoot, root) {
+    return mainRoot ?? root ?? dir;
+}
+/**
+ * A folder as ~/.claude.json names it under `projects`: Claude Code writes Windows paths with
+ * forward slashes (observed in v2.1.296; the docs do not say), so lookups go through this.
+ */
+export function claudeJsonKey(env, path) {
+    return env.platform === "win32" ? path.replaceAll("\\", "/") : path;
+}
+/** Git visibility of each path, batched into two git calls per repository. */
+export async function visibilityOf(root, paths) {
+    const result = new Map();
+    if (paths.length === 0)
+        return result;
+    if (!root) {
+        for (const p of paths)
+            result.set(p, "no-git");
+        return result;
+    }
+    const inside = paths.filter((p) => p !== root && isWithin(root, p));
+    for (const p of paths)
+        if (!inside.includes(p))
+            result.set(p, "no-git");
+    if (inside.length === 0)
+        return result;
+    const rels = new Map(inside.map((p) => [p, relative(root, p).replaceAll("\\", "/")]));
+    const tracked = await gitLines(root, ["ls-files", "--full-name", "-z", "--", ...inside], "\0");
+    // check-ignore echoes the paths it matched, and on Windows an absolute path does not come back
+    // as written, so it gets relative ones. It accepts -z only with --stdin, so its output is split
+    // by line.
+    const ignored = await gitLines(root, ["check-ignore", "--no-index", "--", ...rels.values()], "\n");
+    for (const [p, rel] of rels) {
+        if (tracked.has(rel))
+            result.set(p, "tracked");
+        else if (ignored.has(rel))
+            result.set(p, "ignored");
+        else
+            result.set(p, "untracked");
+    }
+    return result;
+}
+// Failures (including check-ignore's exit 1 for "nothing ignored") read as an empty set.
+async function gitLines(root, args, separator) {
+    try {
+        const { stdout } = await run("git", ["-C", root, ...args], { timeout: 5000 });
+        return new Set(stdout.split(separator).filter(Boolean));
+    }
+    catch {
+        return new Set();
+    }
+}

package/dist/core/scan/index.d.ts

@@ -0,0 +1,5 @@
+import { type DirectoryView, type Overview, type SessionProfile } from "../../shared/types.ts";
+import { type ScanEnv } from "./env.ts";
+export declare function scanOverview(env: ScanEnv, launchDir: string): Promise<Overview>;
+/** Everything Claude Code reads when started in `dir`. */
+export declare function scanDirectory(env: ScanEnv, dir: string, profile?: SessionProfile): Promise<DirectoryView>;

package/dist/{server → core}/scan/index.js

@@ -4,20 +4,19 @@ import { storeDirName } from "../../shared/memory.js";
 import {} from "../../shared/types.js";
 import { buildContext } from "./context.js";
 import { isConfigHome } from "./env.js";
-import { gitRoot, isDir, isFile, isRecord, mainWorktreeRoot, readJsonObject, stringsIn, visibilityOf, } from "./files.js";
+import { isDir, isFile, readJsonObject, stringsIn } from "./files.js";
+import { isRecord } from "./data.js";
+import { claudeJsonKey, gitRoot, mainWorktreeRoot, trustKey, visibilityOf } from "./git.js";
 import { AGENTS_MD_MODES, resolveInstructions } from "./instructions.js";
 import { readInventory } from "./inventory.js";
 import { readMemoryStore } from "./memory.js";
 import { permissionsOf, trustWaits } from "./permissions.js";
 import { listProjects } from "./projects.js";
-import { effectiveSettings, readSettingsLayers } from "./settings.js";
+import { effectiveSettings, readManagedSettings, readSettingsLayers } from "./settings.js";
 import { builtinTools } from "./tools.js";
-async function readClaudeJson(env) {
-    const result = await readJsonObject(env, env.claudeJson);
-    return result.ok ? result.data : null;
-}
 export async function scanOverview(env, launchDir) {
-    const claudeJson = await readClaudeJson(env);
+    const result = await readJsonObject(env, env.claudeJson);
+    const claudeJson = result.ok ? result.data : null;
     const projects = await listProjects(env, claudeJson, launchDir);
     const hashesByName = new Map();
     const memoryCatalog = [];
@@ -53,26 +52,30 @@ export async function scanOverview(env, launchDir) {
 export async function scanDirectory(env, dir, profile = "interactive") {
     const path = resolve(dir);
     const exists = await isDir(path);
-    const claudeJson = await readClaudeJson(env);
+    const problems = [];
+    const claudeJson = await readClaudeJson(env, problems);
     const root = exists ? await gitRoot(path) : null;
-    const settings = await readSettingsLayers(env, path);
+    const managed = await readManagedSettings(env);
+    const settings = await readSettingsLayers(env, path, managed);
+    for (const l of settings)
+        if (l.error)
+            problems.push({
+                path: l.path,
+                error: l.error,
+                ...(l.blocksStart ? { blocksStart: true } : {}),
+            });
     const effective = effectiveSettings(settings);
     const mode = agentsMdMode(settings);
     const excludes = effective.find((s) => s.key === "claudeMdExcludes")?.value;
     const mainRoot = exists ? await mainWorktreeRoot(path) : null;
-    const trust = trustOf(env, claudeJson, path, mainRoot ?? root);
-    const managedLayer = settings.find((l) => l.scope === "managed");
-    const managedClaudeMd = managedLayer?.data?.claudeMd;
-    const problems = [];
+    const trust = trustOf(env, claudeJson, path, mainRoot, root);
     const instructions = await resolveInstructions({
         env,
         cwd: path,
         mode,
         excludes: stringsIn(excludes),
         externalImports: trust.externalImports,
-        managedClaudeMd: managedLayer && typeof managedClaudeMd === "string"
-            ? { path: `${managedLayer.path}#claudeMd`, text: managedClaudeMd }
-            : null,
+        managedClaudeMd: managedClaudeMd(settings),
         problems,
     });
     const inventory = await readInventory({
@@ -80,67 +83,23 @@ export async function scanDirectory(env, dir, profile = "interactive") {
         projectDir: path,
         gitRoot: root,
         layers: settings,
+        effective,
+        managed: managed.data,
         claudeJson,
         trust,
         profile,
+        problems,
     });
-    // Every project file that shapes Claude here, so the UI can say who sees each one.
-    const mcpJson = join(path, ".mcp.json");
-    const projectFiles = [
-        ...instructions.filter((i) => i.scope === "project" || i.scope === "local").map((i) => i.path),
-        ...settings
-            .filter((s) => s.exists && (s.scope === "project" || s.scope === "local"))
-            .map((s) => s.path),
-        ...((await isFile(mcpJson)) ? [mcpJson] : []),
-        ...[...inventory.agents, ...inventory.skills, ...inventory.commands, ...inventory.outputStyles]
-            .filter((e) => e.scope === "project" || e.scope === "local")
-            .map((e) => e.path),
-    ];
-    const visibility = await visibilityOf(root, projectFiles);
-    for (const item of [...instructions, ...settings]) {
-        const v = visibility.get(item.path);
-        if (v)
-            item.visibility = v;
-    }
-    let sharing = null;
-    if (root) {
-        sharing = { tracked: [], untracked: [], ignored: [] };
-        for (const file of new Set(projectFiles)) {
-            const v = visibility.get(file);
-            // Shown as repository paths, with forward slashes on every platform.
-            const rel = relative(root, file).replaceAll("\\", "/");
-            if (v === "tracked")
-                sharing.tracked.push(rel);
-            else if (v === "untracked")
-                sharing.untracked.push(rel);
-            else if (v === "ignored")
-                sharing.ignored.push(rel);
-        }
-    }
-    // A local file tracked in git, or in a .claude that is a link, counts as the repository's
-    // (docs: permissions#when-your-local-settings-file-needs-trust).
-    const localFromRepository = (await Promise.all(settings
-        .filter((l) => l.scope === "local" && l.exists)
-        .map(async (l) => l.visibility === "tracked" ||
-        ((await lstat(dirname(l.path)).catch(() => null))?.isSymbolicLink() ?? false)))).some(Boolean);
+    const sharing = await shareProjectFiles(path, root, instructions, settings, inventory);
     const trustOptions = {
         trust,
         inConfigHome: isConfigHome(env, path),
-        localFromRepository,
+        // Reads the visibility shareProjectFiles gave each layer.
+        localFromRepository: await localFromRepository(settings),
         profile,
     };
-    const memory = await readMemory(env, mainRoot, path, effective, trustOptions);
+    const memory = await readMemory(env, mainRoot, path, effective, trustOptions, problems);
     const permissions = permissionsOf(settings, trustOptions);
-    for (const l of settings)
-        if (l.error)
-            problems.push({
-                path: l.path,
-                error: l.error,
-                ...(l.blocksStart ? { blocksStart: true } : {}),
-            });
-    const mcp = await readJsonObject(env, mcpJson);
-    if (!mcp.ok && !mcp.missing)
-        problems.push({ path: mcpJson, error: mcp.error });
     return {
         path,
         profile,
@@ -163,32 +122,98 @@ export async function scanDirectory(env, dir, profile = "interactive") {
         permissions,
         tools: builtinTools(permissions, inventory.hooks),
         trust,
-        problems,
+        // One line per file: a file read twice, such as a rule that a CLAUDE.md also imports, is one problem.
+        problems: problems.filter((p, i) => problems.findIndex((q) => q.path === p.path) === i),
         sharing,
     };
 }
+/** ~/.claude.json, or null when it is missing or broken; a broken one is a problem. */
+async function readClaudeJson(env, problems) {
+    const file = await readJsonObject(env, env.claudeJson);
+    if (file.ok)
+        return file.data;
+    // Without it the folder looks untrusted and your servers missing, so the problem says why.
+    if (!file.missing)
+        problems.push({
+            path: env.claudeJson,
+            error: `${file.error}, so ccdesk cannot show your trust answers or your user and local MCP servers`,
+        });
+    return null;
+}
+/** The CLAUDE.md text managed settings give in their claudeMd key. */
+function managedClaudeMd(settings) {
+    const managed = settings.find((l) => l.scope === "managed");
+    const text = managed?.data?.claudeMd;
+    return managed && typeof text === "string" ? { path: `${managed.path}#claudeMd`, text } : null;
+}
+/**
+ * Says who sees each project file that shapes Claude here: marks the instructions and settings
+ * with their git visibility, and returns the repository's files by visibility, or null outside one.
+ */
+async function shareProjectFiles(path, root, instructions, settings, inventory) {
+    const inProject = (scope) => scope === "project" || scope === "local";
+    const mcpJson = join(path, ".mcp.json");
+    const projectFiles = [
+        ...instructions.filter((i) => inProject(i.scope)).map((i) => i.path),
+        ...settings.filter((s) => s.exists && inProject(s.scope)).map((s) => s.path),
+        ...((await isFile(mcpJson)) ? [mcpJson] : []),
+        ...[...inventory.agents, ...inventory.skills, ...inventory.commands, ...inventory.outputStyles]
+            .filter((e) => inProject(e.scope))
+            .map((e) => e.path),
+    ];
+    const visibility = await visibilityOf(root, projectFiles);
+    for (const item of [...instructions, ...settings]) {
+        const v = visibility.get(item.path);
+        if (v)
+            item.visibility = v;
+    }
+    if (!root)
+        return null;
+    const sharing = { tracked: [], untracked: [], ignored: [] };
+    for (const file of new Set(projectFiles)) {
+        const v = visibility.get(file);
+        // Shown as repository paths, with forward slashes on every platform.
+        const rel = relative(root, file).replaceAll("\\", "/");
+        if (v === "tracked")
+            sharing.tracked.push(rel);
+        else if (v === "untracked")
+            sharing.untracked.push(rel);
+        else if (v === "ignored")
+            sharing.ignored.push(rel);
+    }
+    return sharing;
+}
+/**
+ * Whether the local settings file counts as the repository's: tracked in git, or in a .claude
+ * that is a link (docs: permissions#when-your-local-settings-file-needs-trust).
+ */
+async function localFromRepository(settings) {
+    const fromRepository = await Promise.all(settings
+        .filter((l) => l.scope === "local" && l.exists)
+        .map(async (l) => l.visibility === "tracked" ||
+        ((await lstat(dirname(l.path)).catch(() => null))?.isSymbolicLink() ?? false)));
+    return fromRepository.some(Boolean);
+}
 /**
  * Your answers to Claude Code's trust dialogs, from ~/.claude.json (docs: permissions#project-allow-rules-and-workspace-trust).
  * In a repository the key is the main checkout's root; outside one it is the folder, and a trusted
  * parent folder covers it. In your home directory trust lasts one session and is never saved.
  */
-function trustOf(env, claudeJson, path, repositoryRoot) {
+function trustOf(env, claudeJson, path, mainRoot, repoRoot) {
     const projects = isRecord(claudeJson?.projects) ? claudeJson.projects : {};
-    const entry = (key) => (isRecord(projects[key]) ? projects[key] : {});
-    const root = repositoryRoot ?? path;
+    const entry = (dir) => {
+        const found = projects[claudeJsonKey(env, dir)];
+        return isRecord(found) ? found : {};
+    };
+    const root = trustKey(path, mainRoot, repoRoot);
     const own = entry(root);
     const trust = {
         root,
         trusted: own.hasTrustDialogAccepted === true,
         sessionOnly: path === env.home,
-        // These two keys are not documented; they are what Claude Code writes for the import dialog.
-        externalImports: own.hasClaudeMdExternalIncludesApproved === true
-            ? "approved"
-            : own.hasClaudeMdExternalIncludesWarningShown === true
-                ? "declined"
-                : "not-asked",
+        externalImports: importAnswer(own),
     };
-    if (!trust.trusted && !repositoryRoot)
+    if (!trust.trusted && !mainRoot && !repoRoot)
         for (let d = dirname(path); d !== dirname(d); d = dirname(d))
             if (entry(d).hasTrustDialogAccepted === true) {
                 trust.inheritedFrom = d;
@@ -196,12 +221,23 @@ function trustOf(env, claudeJson, path, repositoryRoot) {
             }
     return trust;
 }
+/**
+ * Your answer to the dialog about imports from outside the project. These two keys are not
+ * documented; they are what Claude Code writes for that dialog.
+ */
+function importAnswer(project) {
+    if (project.hasClaudeMdExternalIncludesApproved === true)
+        return "approved";
+    if (project.hasClaudeMdExternalIncludesWarningShown === true)
+        return "declined";
+    return "not-asked";
+}
 /**
  * The auto memory Claude Code uses here (docs: memory#storage-location, settings-reference#automemoryenabled).
  * Worktrees and subdirectories of one repository share one store. The store is returned even
  * when its folder does not exist yet, so a note about memory being off still shows.
  */
-async function readMemory(env, mainRoot, path, effective, trustOptions) {
+async function readMemory(env, mainRoot, path, effective, trustOptions, problems) {
     const key = mainRoot ?? path;
     const setting = effective.find((s) => s.key === "autoMemoryDirectory");
     // A value from a repository file counts once the folder is trusted, like hooks (docs:
@@ -216,7 +252,7 @@ async function readMemory(env, mainRoot, path, effective, trustOptions) {
     const customDir = typeof custom?.value === "string" ? expandHome(env, custom.value) : null;
     const storeName = env.projectDirName ?? storeDirName(key);
     const dir = customDir ?? join(env.claudeDir, "projects", storeName, "memory");
-    const store = (await readMemoryStore(env, dir, key)) ?? {
+    const store = (await readMemoryStore(env, dir, key, problems)) ?? {
         dir,
         loaded: true,
         projectPath: key,
@@ -272,8 +308,9 @@ function agentsMdMode(layers) {
         for (const id of ["cc-plugin-agents-md@builtin", "agents-md@builtin"]) {
             const entry = configs[id];
             const value = isRecord(entry) && isRecord(entry.options) ? entry.options.instructionFiles : undefined;
-            if (typeof value === "string" && AGENTS_MD_MODES.includes(value))
-                return value;
+            const mode = AGENTS_MD_MODES.find((m) => m === value);
+            if (mode)
+                return mode;
         }
     }
     return "claude-md-or-agents-md";

package/dist/core/scan/instructions.d.ts

@@ -0,0 +1,54 @@
+import { type AgentsMdMode, type Instruction, type Problem, type TextFile, type Trust } from "../../shared/types.ts";
+import { type ScanEnv } from "./env.ts";
+export declare const AGENTS_MD_MODES: AgentsMdMode[];
+/** The CLAUDE.md and AGENTS.md files each folder can hold, in the order Claude Code reads them. */
+export declare const CLAUDE_MD_NAMES: string[];
+export declare const AGENTS_MD_NAMES: string[];
+/**
+ * Whether AGENTS.md loads, given the instruction mode and whether a CLAUDE.md or CLAUDE.local.md
+ * is there (docs: memory#choose-which-instruction-files-load).
+ */
+export declare function agentsMdLoads(mode: AgentsMdMode, hasClaudeMd: boolean): boolean;
+/**
+ * Whether a claudeMdExcludes glob matches a file by its own path or, for a link, its target's
+ * (docs: memory#exclude-specific-claude-md-files).
+ */
+export declare function isExcluded(excludes: string[], path: string, realPath?: string): boolean;
+/**
+ * Where a rule in `dir` really is when that is outside both the project and `dir`: a link's
+ * target, or the file a linked folder leads to. Undefined for a rule that stays inside.
+ */
+export declare function ruleTarget(file: TextFile, dir: string, realCwd: string): Promise<string | undefined>;
+/**
+ * Why a project rule linked from outside the project does not load, or null when it does: it waits
+ * for your approval of outside imports, and once approved loads only without a paths field
+ * (docs: memory#share-rules-across-projects-with-symlinks).
+ */
+export declare function linkedRuleBlock(target: string | undefined, realCwd: string, approved: boolean, hasPaths: boolean): "needs-approval" | "has-paths" | null;
+/** Directories from the filesystem root down to `cwd`, the order Claude Code concatenates them in. */
+export declare function ancestorsRootFirst(cwd: string): string[];
+interface ResolveOptions {
+    env: ScanEnv;
+    cwd: string;
+    mode: AgentsMdMode;
+    /** Merged `claudeMdExcludes` globs from every settings layer. */
+    excludes: string[];
+    /** Your answer to Claude Code's dialog about imports from outside the project. */
+    externalImports: Trust["externalImports"];
+    /** The managed settings' `claudeMd` text, which loads like a managed CLAUDE.md. */
+    managedClaudeMd: {
+        path: string;
+        text: string;
+    } | null;
+    /** Receives instruction files and imports that exist but cannot be read. */
+    problems: Problem[];
+}
+/**
+ * The instruction files Claude Code reads in `cwd`, in load order, each with whether it loads at
+ * session start, when Claude works with matching files, or not at all, and why.
+ * Follows code.claude.com/docs/en/memory.
+ */
+export declare function resolveInstructions(options: ResolveOptions): Promise<Instruction[]>;
+/** An invalid pattern matches nothing. */
+export declare function safeMatch(path: string, glob: string): boolean;
+export {};