ccdesk 0.0.0-stage → 0.2.0

package/dist/server/scan/index.js

@@ -0,0 +1,280 @@
+import { lstat } from "node:fs/promises";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+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 { 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 { 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 projects = await listProjects(env, claudeJson, launchDir);
+    const hashesByName = new Map();
+    const memoryCatalog = [];
+    for (const project of projects) {
+        for (const memory of project.store?.memories ?? []) {
+            memoryCatalog.push({
+                projectPath: project.path,
+                path: memory.path,
+                name: memory.name,
+                description: memory.description,
+                type: memory.type,
+            });
+            const list = hashesByName.get(memory.name) ?? [];
+            list.push({ projectPath: project.path, hash: memory.hash });
+            hashesByName.set(memory.name, list);
+        }
+    }
+    return {
+        generatedAt: new Date().toISOString(),
+        home: env.home,
+        claudeDir: env.claudeDir,
+        launchDir: resolve(launchDir),
+        platform: env.platform,
+        projects: projects.map(({ store: _store, ...summary }) => summary),
+        sharedMemories: [...hashesByName.entries()]
+            .filter(([, stores]) => stores.length > 1)
+            .map(([name, stores]) => ({ name, stores }))
+            .sort((a, b) => a.name.localeCompare(b.name)),
+        memoryCatalog,
+    };
+}
+/** Everything Claude Code reads when started in `dir`. */
+export async function scanDirectory(env, dir, profile = "interactive") {
+    const path = resolve(dir);
+    const exists = await isDir(path);
+    const claudeJson = await readClaudeJson(env);
+    const root = exists ? await gitRoot(path) : null;
+    const settings = await readSettingsLayers(env, path);
+    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 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,
+        problems,
+    });
+    const inventory = await readInventory({
+        env,
+        projectDir: path,
+        gitRoot: root,
+        layers: settings,
+        claudeJson,
+        trust,
+        profile,
+    });
+    // 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 trustOptions = {
+        trust,
+        inConfigHome: isConfigHome(env, path),
+        localFromRepository,
+        profile,
+    };
+    const memory = await readMemory(env, mainRoot, path, effective, trustOptions);
+    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,
+        exists,
+        gitRoot: root,
+        agentsMdMode: mode,
+        instructions,
+        settings,
+        effective,
+        memory,
+        inventory,
+        context: await buildContext({
+            env,
+            projectRoot: root ?? path,
+            instructions,
+            memory,
+            inventory,
+            effective,
+        }),
+        permissions,
+        tools: builtinTools(permissions, inventory.hooks),
+        trust,
+        problems,
+        sharing,
+    };
+}
+/**
+ * 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) {
+    const projects = isRecord(claudeJson?.projects) ? claudeJson.projects : {};
+    const entry = (key) => (isRecord(projects[key]) ? projects[key] : {});
+    const root = repositoryRoot ?? path;
+    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",
+    };
+    if (!trust.trusted && !repositoryRoot)
+        for (let d = dirname(path); d !== dirname(d); d = dirname(d))
+            if (entry(d).hasTrustDialogAccepted === true) {
+                trust.inheritedFrom = d;
+                break;
+            }
+    return trust;
+}
+/**
+ * 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) {
+    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:
+    // settings-reference#automemorydirectory); until then the next file down that sets it decides.
+    // claude -p and the SDK treat the folder as trusted for hooks, so for this too.
+    const waitsForTrust = trustOptions.profile === "print" ? () => false : trustWaits(trustOptions);
+    const candidates = setting
+        ? [{ scope: setting.from[0], value: setting.value }, ...setting.overridden]
+        : [];
+    const waiting = candidates.find((c) => c.scope && waitsForTrust(c.scope));
+    const custom = candidates.find((c) => c.scope && !waitsForTrust(c.scope));
+    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)) ?? {
+        dir,
+        loaded: true,
+        projectPath: key,
+        index: null,
+        memories: [],
+    };
+    if (customDir)
+        store.custom = true;
+    const disable = env.disableAutoMemory;
+    const enabled = effective.find((s) => s.key === "autoMemoryEnabled");
+    const fromRepository = custom?.scope === "project" || (custom?.scope === "local" && trustOptions.localFromRepository);
+    if (disable === "1" || disable === "true") {
+        store.loaded = false;
+        store.note = "CLAUDE_CODE_DISABLE_AUTO_MEMORY turns auto memory off in this shell";
+    }
+    else if (disable === undefined && enabled?.value === false) {
+        store.loaded = false;
+        store.note = `autoMemoryEnabled is false in ${enabled.from.join(", ")} settings`;
+    }
+    else if (customDir && custom && fromRepository && blocksOutsideReads(effective)) {
+        // docs: settings-reference#permissions-blockreadsoutsideworkingdirectories
+        store.loaded = false;
+        store.note =
+            "autoMemoryDirectory comes from repository settings and blockReadsOutsideWorkingDirectories is on, so Claude Code loads no auto memory from it";
+    }
+    else if (customDir && custom) {
+        store.note = `autoMemoryDirectory in ${custom.scope} settings points here; ccdesk only changes stores under ~/.claude/projects`;
+    }
+    else if (waiting) {
+        store.note = `autoMemoryDirectory in ${waiting.scope} settings takes over once you trust this folder; until then Claude Code uses this store`;
+    }
+    else if (env.projectDirName) {
+        store.note = `CLAUDE_CODE_PROJECT_DIR_NAME names this store "${env.projectDirName}" in every project`;
+    }
+    return store;
+}
+function blocksOutsideReads(effective) {
+    const permissions = effective.find((s) => s.key === "permissions")?.value;
+    return isRecord(permissions) && permissions.blockReadsOutsideWorkingDirectories === true;
+}
+/** autoMemoryDirectory takes an absolute or ~/ path; anything else is not a valid value. */
+function expandHome(env, path) {
+    if (path.startsWith("~/"))
+        return join(env.home, path.slice(2));
+    return isAbsolute(path) ? path : null;
+}
+/** Read from user, --settings or managed settings only; project and local files are ignored for it. */
+function agentsMdMode(layers) {
+    for (const scope of ["managed", "user"]) {
+        const configs = layers.find((l) => l.scope === scope)?.data?.pluginConfigs;
+        if (!isRecord(configs))
+            continue;
+        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;
+        }
+    }
+    return "claude-md-or-agents-md";
+}

package/dist/server/scan/instructions.js

@@ -0,0 +1,289 @@
+import { constants } from "node:fs";
+import { access, stat } from "node:fs/promises";
+import { dirname, isAbsolute, join, matchesGlob, parse, resolve } from "node:path";
+import {} from "../../shared/types.js";
+import {} from "./env.js";
+import { isFile, isNetworkPath, isWithin, MAX_TEXT_BYTES, parseFrontmatter, readTextFile, resolvedPath, toStringList, walkMarkdown, } from "./files.js";
+const MAX_IMPORT_HOPS = 4;
+export const AGENTS_MD_MODES = [
+    "claude-md-or-agents-md",
+    "claude-md-and-agents-md",
+    "claude-md",
+    "managed-only",
+];
+/** Directories from the filesystem root down to `cwd`, the order Claude Code concatenates them in. */
+export function ancestorsRootFirst(cwd) {
+    const dirs = [];
+    let current = resolve(cwd);
+    const { root } = parse(current);
+    while (true) {
+        dirs.unshift(current);
+        if (current === root)
+            break;
+        current = dirname(current);
+    }
+    return dirs;
+}
+/**
+ * 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 async function resolveInstructions(options) {
+    const { env, cwd, mode, excludes, externalImports, managedClaudeMd, problems } = options;
+    /** A file that exists but cannot be read is reported, not taken for a missing one. */
+    const readInstruction = async (path) => {
+        const file = await readTextFile(env, path);
+        if (file || !(await stat(path).catch(() => null))?.isFile())
+            return file;
+        const denied = await access(path, constants.R_OK).then(() => null, (error) => error.code ?? String(error));
+        if (denied)
+            problems.push({ path, error: `cannot be read (${denied})` });
+        return null;
+    };
+    const ctx = {
+        realCwd: await resolvedPath(resolve(cwd)),
+        env,
+        approved: externalImports === "approved",
+    };
+    const managedOnly = mode === "managed-only";
+    const skippedByMode = `Skipped: instruction mode is ${mode}`;
+    const out = [];
+    const managed = await readInstruction(join(env.managedDir, "CLAUDE.md"));
+    if (managed)
+        out.push(await instruction(managed, "claude-md", "managed", env.managedDir, ctx, "Organisation policy, always loaded"));
+    if (managedClaudeMd) {
+        const { path, text } = managedClaudeMd;
+        const file = {
+            path,
+            mtime: "",
+            bytes: Buffer.byteLength(text),
+            lines: text.split("\n").length,
+            text,
+        };
+        const entry = await instruction(file, "claude-md", "managed", env.managedDir, ctx, "Organisation policy from the claudeMd key in managed settings");
+        entry.imports = [];
+        out.push(entry);
+    }
+    const user = await readInstruction(join(env.claudeDir, "CLAUDE.md"));
+    if (user)
+        out.push(await instruction(user, "claude-md", "user", env.claudeDir, ctx, "Your instructions for every project"));
+    for (const path of await walkMarkdown(join(env.claudeDir, "rules"))) {
+        const file = await readInstruction(path);
+        if (file)
+            out.push(await rule(file, "user", env.claudeDir, ctx));
+    }
+    // Per directory, root first: CLAUDE.md, .claude/CLAUDE.md, rules, then CLAUDE.local.md last
+    // ("your personal notes are the last thing Claude reads at that level"), then AGENTS.md.
+    const claudeFiles = [];
+    const agentsFiles = [];
+    for (const dir of ancestorsRootFirst(cwd)) {
+        // ~/.claude/CLAUDE.md and ~/.claude/rules are the user files above, not the home's project files.
+        const isConfigHome = join(dir, ".claude") === env.claudeDir;
+        for (const name of ["CLAUDE.md", ".claude/CLAUDE.md"]) {
+            if (isConfigHome && name === ".claude/CLAUDE.md")
+                continue;
+            const file = await readInstruction(join(dir, name));
+            if (file)
+                claudeFiles.push(await instruction(file, "claude-md", "project", dir, ctx, ""));
+        }
+        if (!isConfigHome && dir !== env.claudeDir)
+            for (const path of await walkMarkdown(join(dir, ".claude", "rules"))) {
+                const file = await readInstruction(path);
+                if (file)
+                    claudeFiles.push(await rule(file, "project", dir, ctx));
+            }
+        const local = await readInstruction(join(dir, "CLAUDE.local.md"));
+        if (local)
+            claudeFiles.push(await instruction(local, "claude-local-md", "local", dir, ctx, ""));
+        for (const name of ["AGENTS.md", ".claude/AGENTS.md"]) {
+            const file = await readInstruction(join(dir, name));
+            if (file)
+                agentsFiles.push(await instruction(file, "agents-md", "project", dir, ctx, ""));
+        }
+    }
+    const hasClaudeMd = claudeFiles.some((f) => f.kind !== "rule");
+    for (const file of claudeFiles) {
+        if (file.kind === "rule")
+            continue;
+        file.reason =
+            file.kind === "claude-local-md"
+                ? "Your private notes for this directory"
+                : file.dir === resolve(cwd)
+                    ? "Instructions for this directory"
+                    : "Inherited from a parent directory";
+    }
+    const includedElsewhere = new Set(claudeFiles.flatMap((f) => [f.realPath ?? f.path, ...f.imports.map((i) => i.resolved)]));
+    for (const file of agentsFiles) {
+        if (mode === "managed-only" || mode === "claude-md")
+            skip(file, skippedByMode);
+        else if (includedElsewhere.has(file.realPath ?? file.path))
+            skip(file, "Already included through a CLAUDE.md import or symlink");
+        else if (mode === "claude-md-and-agents-md")
+            file.reason = "Loaded alongside CLAUDE.md (instruction mode claude-md-and-agents-md)";
+        else if (hasClaudeMd)
+            skip(file, "Ignored: a CLAUDE.md or CLAUDE.local.md exists here or above, so Claude Code reads that instead");
+        else
+            file.reason = "Loaded because there is no CLAUDE.md here or above";
+    }
+    for (const dir of ancestorsRootFirst(cwd))
+        out.push(...claudeFiles.filter((f) => f.dir === dir), ...agentsFiles.filter((f) => f.dir === dir));
+    const waiting = externalImports === "declined"
+        ? "You declined imports from outside this project"
+        : "Waits for you to approve imports from outside this project";
+    for (const file of out) {
+        if (file.scope === "managed")
+            continue;
+        // Path-scoped rules still load on demand in managed-only mode (docs: memory#choose-which-instruction-files-load).
+        if (managedOnly && file.status === "loaded")
+            skip(file, skippedByMode);
+        // Managed files cannot be excluded; a linked file is excluded by its own path or its target's
+        // (docs: memory#exclude-specific-claude-md-files).
+        const excluded = excludes.some((glob) => [file.path, file.realPath].some((p) => p !== undefined && safeMatch(p, glob)));
+        if (excluded)
+            skip(file, "Skipped by claudeMdExcludes");
+        if (file.status !== "skipped" && file.bytes > MAX_TEXT_BYTES)
+            skip(file, "Skipped: Claude Code does not load an instruction file over 4 MiB");
+        // A project's links outside it need your approval, like its imports; your own files do not.
+        if (file.scope !== "project" && file.scope !== "local")
+            continue;
+        if (file.kind === "rule" && file.realPath && !isWithin(ctx.realCwd, file.realPath)) {
+            if (!ctx.approved)
+                skip(file, `${waiting}; this rule links outside it`);
+            // docs: memory#share-rules-across-projects-with-symlinks
+            else if (file.paths)
+                skip(file, "Links outside this project, and such a rule loads only without a paths field");
+        }
+    }
+    addChecks(out);
+    return out;
+}
+function skip(file, reason) {
+    if (file.status === "skipped")
+        return;
+    file.status = "skipped";
+    file.reason = reason;
+}
+/** An invalid pattern matches nothing. */
+function safeMatch(path, glob) {
+    try {
+        return matchesGlob(path, glob);
+    }
+    catch {
+        return false;
+    }
+}
+/** Claude Code's docs suggest keeping each CLAUDE.md under this many lines. */
+const LONG_FILE_LINES = 200;
+function paragraphs(text) {
+    return parseFrontmatter(text)
+        .body.split(/\n\s*\n/)
+        .map((p) => p.trim().replace(/\s+/g, " "))
+        .filter((p) => p.length >= 60);
+}
+/** Upkeep notes: files longer than the docs recommend, paragraphs repeated across files, missing imports. */
+function addChecks(files) {
+    const seen = new Map();
+    for (const file of files.filter((f) => f.status !== "skipped")) {
+        if (file.lines > LONG_FILE_LINES)
+            file.checks.push(`${file.lines} lines; Claude Code's docs suggest under ${LONG_FILE_LINES} for better adherence`);
+        const repeated = new Set();
+        for (const paragraph of paragraphs(file.text)) {
+            const first = seen.get(paragraph);
+            if (first && first !== file)
+                repeated.add(first.path);
+            else
+                seen.set(paragraph, file);
+        }
+        for (const path of repeated)
+            file.checks.push(`Repeats a paragraph from ${path}`);
+        // `@name` without a slash or dot is as likely a mention as a path, so only path-like ones count.
+        for (const ref of file.imports)
+            if (!ref.exists && /[./]/.test(ref.raw))
+                file.checks.push(`Imports @${ref.raw}, which does not exist`);
+    }
+}
+async function rule(file, scope, dir, ctx) {
+    const paths = toStringList(parseFrontmatter(file.text).data.paths);
+    const entry = await instruction(file, "rule", scope, dir, ctx, paths.length > 0
+        ? "Loads only when Claude works with matching files"
+        : "Rule loaded every session");
+    if (paths.length > 0) {
+        entry.paths = paths;
+        entry.status = "on-match";
+    }
+    // A rule reached through a linked folder is not a link itself, but its target can be outside.
+    const real = await resolvedPath(file.path);
+    if (!entry.realPath && !isWithin(ctx.realCwd, real) && !isWithin(await resolvedPath(dir), real))
+        entry.realPath = real;
+    return entry;
+}
+async function instruction(file, kind, scope, dir, ctx, reason) {
+    // Your own files' imports load without asking; a project's imports outside it wait for approval.
+    const own = scope === "managed" || scope === "user";
+    const imports = await collectImports(file, ctx, own || ctx.approved);
+    if (!own && !ctx.approved)
+        for (const ref of imports)
+            if (ref.external)
+                ref.pending = true;
+    return { ...file, kind, scope, dir, status: "loaded", reason, imports, checks: [] };
+}
+/**
+ * `@path` imports, depth first up to four hops, each with the file that imports it. An import
+ * outside the project is read only when Claude Code would read it: from your own files, or once
+ * you approved the project's external imports.
+ */
+async function collectImports(file, ctx, readExternal) {
+    const seen = new Set([file.realPath ?? file.path]);
+    const out = [];
+    const visit = async (source, via, hop) => {
+        if (hop >= MAX_IMPORT_HOPS)
+            return;
+        for (const raw of importPaths(source.text)) {
+            const target = expandImport(raw, dirname(source.path), ctx.env.home);
+            if (isNetworkPath(target))
+                continue;
+            const real = await resolvedPath(target);
+            if (seen.has(real))
+                continue;
+            seen.add(real);
+            const external = !isWithin(ctx.realCwd, real);
+            const imported = !external || readExternal ? await readTextFile(ctx.env, target) : null;
+            const ref = {
+                raw,
+                resolved: real,
+                via,
+                exists: imported !== null || (await isFile(target)),
+                external,
+            };
+            if (imported && imported.bytes > MAX_TEXT_BYTES)
+                ref.tooLarge = true;
+            out.push(ref);
+            if (imported)
+                await visit(imported, real, hop + 1);
+        }
+    };
+    await visit(file, file.path, 0);
+    return out;
+}
+function expandImport(raw, baseDir, home) {
+    const unescaped = raw.replaceAll("\\ ", " ");
+    if (unescaped.startsWith("~/"))
+        return join(home, unescaped.slice(2));
+    return isAbsolute(unescaped) ? unescaped : resolve(baseDir, unescaped);
+}
+/**
+ * `@path` references outside code spans and fences; a backslash keeps a space in the path. A code
+ * span opens with a run of backticks and closes at the next run of the same length.
+ */
+function importPaths(text) {
+    const withoutFences = text.replace(/^(```|~~~)[\s\S]*?^\1/gm, "");
+    const withoutSpans = withoutFences.replace(/(?<!`)(`+)(?!`)[\s\S]*?(?<!`)\1(?!`)/g, "");
+    const found = [];
+    for (const match of withoutSpans.matchAll(/(?:^|\s)@((?:[^\s\\]|\\ )+)/g)) {
+        const path = match[1]?.replace(/[.,;:!?)\]]+$/, "");
+        if (path)
+            found.push(path);
+    }
+    return found;
+}