kennel 0.1.9 → 0.2.0

package/node_modules/@raggle-ai/local/dist/core/base-repository.d.ts

@@ -0,0 +1,60 @@
+export type BaseRepository = {
+    schemaVersion: 1;
+    worktree: string;
+    repository: string;
+    repositoryKey: string;
+    branch?: string;
+};
+export type WorkspaceManifestV2 = {
+    $schema: "https://raggle.co/config.json";
+    schemaVersion: 2;
+    id: string;
+    type: "personal-workspace-repository" | "company" | "workspace" | "personal";
+    title: string;
+    workspaces?: WorkspaceEntry[];
+    content?: string[];
+    mounts?: MountEntry[];
+    repositories?: RepositoryEntry[];
+    searchPriority?: number;
+};
+export type WorkspaceEntry = {
+    id: string;
+    path: string;
+};
+export type MountEntry = {
+    path: string;
+    repository: string;
+};
+export type RepositoryEntry = {
+    url: string;
+};
+export type MountRecord = {
+    $schema: "https://raggle.co/mount.json";
+    schemaVersion: 1;
+    type: "git-repository";
+    repository: string;
+};
+export type ResolvedWorkspace = {
+    id: string;
+    type: WorkspaceManifestV2["type"];
+    title: string;
+    path: string;
+    worktree: string;
+    mounts?: ResolvedMount[];
+    repositories?: RepositoryEntry[];
+};
+export type ResolvedMount = {
+    path: string;
+    repository: string;
+    worktree?: string;
+    status: "resolved" | "missing" | "unmapped";
+};
+export type SearchSourceType = "native" | "mounted-repository" | "registered-repository";
+export type SearchDocumentMetadata = {
+    workspaceId: string;
+    sourceType: SearchSourceType;
+    repositoryId?: string;
+    relativePath?: string;
+    commitId?: string;
+    visibility: "private" | "shared";
+};

package/node_modules/@raggle-ai/local/dist/core/base-repository.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/node_modules/@raggle-ai/local/dist/core/catalog-project.d.ts

@@ -0,0 +1,4 @@
+import type { CatalogProject } from "../native-bridge";
+import type { LocalProject } from "./types";
+/** Converts the native catalogue contract into the shared local-project model. */
+export declare function catalogProjectToLocalProject(project: CatalogProject): LocalProject;

package/node_modules/@raggle-ai/local/dist/core/catalog-project.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.catalogProjectToLocalProject = catalogProjectToLocalProject;
+const project_emoji_1 = require("./project-emoji");
+/** Converts the native catalogue contract into the shared local-project model. */
+function catalogProjectToLocalProject(project) {
+    return (0, project_emoji_1.withProjectEmoji)({
+        id: project.id,
+        worktree: project.worktree,
+        name: project.name ?? undefined,
+        description: project.description ?? undefined,
+        worktreeName: project.worktreeName ?? undefined,
+        keywords: project.keywords ?? undefined,
+        tags: project.tags ?? undefined,
+        latestSessionTitle: project.latestSessionTitle ?? undefined,
+        icon: project.icon ?? undefined,
+        iconColor: project.iconColor ?? undefined,
+        startupCommand: project.startupCommand ?? undefined,
+        sandboxCount: project.sandboxCount,
+        updatedAt: project.updatedAt ?? undefined,
+        hasIcon: project.hasIcon,
+        isSessionOnly: project.isSessionOnly,
+        isFavorite: project.isFavorite,
+        relatedIds: project.relatedIds,
+        remoteUrl: project.remoteUrl,
+        browserUrl: project.browserUrl ?? undefined,
+        isCloned: project.isCloned,
+        repositoryRoot: project.repositoryRoot,
+        parentProjectName: project.parentProjectName ?? undefined,
+        relativePath: project.relativePath ?? undefined,
+        listed: project.listed,
+        isSubpathRoot: project.isSubpathRoot,
+        allSubpath: project.allSubpath,
+        collapseSubpaths: project.collapseSubpaths,
+        allTopLevelFolders: project.allTopLevelFolders,
+        folderDepth: project.folderDepth ?? undefined,
+        subpathAllSubpath: project.subpathAllSubpath,
+        removePathFromName: project.removePathFromName,
+        hasCustomName: project.hasCustomName,
+        remoteMismatch: project.remoteMismatch ?? undefined,
+        searchPriority: project.searchPriority ?? undefined,
+        relatedRepositories: project.relatedRepositories ?? undefined,
+        relatedOrganisations: project.relatedOrganisations ?? undefined,
+    });
+}

package/node_modules/@raggle-ai/local/dist/core/connected-projects.d.ts

@@ -0,0 +1,52 @@
+import type { UserProjectSearchItem } from "./search";
+import type { RepositoryLinkType } from "./project-schema";
+import { type RelationDepth } from "./relation-depth";
+export declare function canonicalPath(filePath: string): string;
+export type ConnectedProjects = {
+    /** Project worktree used as the graph root for links discovered from the folder. */
+    selectedWorktree: string;
+    /** Related or linked repositories reachable from the folder (typically outside it). */
+    linked: UserProjectSearchItem[];
+    /** Other repositories whose raggle.json links to the selected repository. */
+    linking: UserProjectSearchItem[];
+    /** Direct configured edges between repositories in linked and linking. */
+    relations: RepositoryRelation[];
+    /** Projects discovered beneath the folder. */
+    local: UserProjectSearchItem[];
+    linkedDepths: Map<string, number>;
+    linkingDepths: Map<string, number>;
+    /** Collapsed subprojects of a linked repository, keyed by its representative worktree. */
+    linkedSubpaths: Map<string, string[]>;
+    /** Collapsed subprojects of a linking repository, keyed by its representative worktree. */
+    linkingSubpaths: Map<string, string[]>;
+};
+export type RepositoryRelation = {
+    source: string;
+    target: string;
+    type: RepositoryLinkType;
+    /** Distinguish broad organisation inference from an explicit project link. */
+    origin?: "organisation";
+};
+export type ListedRepository = {
+    worktree: string;
+    repository?: string;
+    type: RepositoryLinkType;
+    direction: "outgoing" | "incoming";
+    depth: number;
+};
+export type ConnectedProjectsList = {
+    schemaVersion: 2;
+    folder: string;
+    repositories: ListedRepository[];
+    localSubpaths: string[];
+};
+export declare function connectedProjectsList(folder: string, connected: ConnectedProjects): ConnectedProjectsList;
+export declare function listConnectedProjects(folder: string, options?: {
+    all?: boolean;
+    depth?: RelationDepth;
+    focused?: boolean;
+}): Promise<ConnectedProjects>;
+export declare function listConnectedWorktrees(folder: string, options?: {
+    all?: boolean;
+    depth?: RelationDepth;
+}): Promise<string[]>;

package/node_modules/@raggle-ai/local/dist/core/connected-projects.js

@@ -0,0 +1,440 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canonicalPath = canonicalPath;
+exports.connectedProjectsList = connectedProjectsList;
+exports.listConnectedProjects = listConnectedProjects;
+exports.listConnectedWorktrees = listConnectedWorktrees;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const node_util_1 = require("node:util");
+const base_repository_1 = require("../adapters/base-repository");
+const linked_workspace_1 = require("../adapters/linked-workspace");
+const user_settings_1 = require("../adapters/user-settings");
+const native_bridge_1 = require("../native-bridge");
+const user_projects_1 = require("./user-projects");
+const relation_depth_1 = require("./relation-depth");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+function findGitRootByMarker(source) {
+    let directory = canonicalPath(source);
+    while (true) {
+        if ((0, node_fs_1.statSync)(node_path_1.default.join(directory, ".git"), { throwIfNoEntry: false }))
+            return directory;
+        const parent = node_path_1.default.dirname(directory);
+        if (parent === directory)
+            return undefined;
+        directory = parent;
+    }
+}
+async function linkedRepositoryRoot(source) {
+    try {
+        const { stdout } = await execFileAsync("git", ["-C", source, "rev-parse", "--show-toplevel"]);
+        return canonicalPath(stdout.trim());
+    }
+    catch {
+        return findGitRootByMarker(source) ?? canonicalPath(source);
+    }
+}
+function nearestProjectConfigDirectory(startDirectory, repositoryRoot) {
+    let directory = canonicalPath(startDirectory);
+    while (true) {
+        if ((0, node_fs_1.statSync)(node_path_1.default.join(directory, "raggle.json"), { throwIfNoEntry: false })?.isFile())
+            return directory;
+        if (directory === repositoryRoot)
+            return repositoryRoot;
+        const parent = node_path_1.default.dirname(directory);
+        if (parent === directory || !directory.startsWith(repositoryRoot + node_path_1.default.sep))
+            return repositoryRoot;
+        directory = parent;
+    }
+}
+function canonicalPath(filePath) {
+    try {
+        return (0, node_fs_1.realpathSync)(filePath);
+    }
+    catch {
+        return node_path_1.default.resolve(filePath);
+    }
+}
+function uniqueProjects(projects) {
+    const byWorktree = new Map();
+    for (const project of projects) {
+        if (!project.worktree.trim())
+            continue;
+        byWorktree.set(canonicalPath(project.worktree), project);
+    }
+    return [...byWorktree.values()];
+}
+/**
+ * Collapse every project of the same repository to its shallowest worktree so a
+ * repository link resolves to a single connected folder. The remaining projects
+ * of that repository (monorepo packages, native crates, skill folders) become
+ * relative subpaths of the representative instead of duplicate repositories.
+ */
+function collapseRepositorySubprojects(projects, preservedWorktrees = new Set()) {
+    const byKey = new Map();
+    const representative = new Map();
+    const projectByWorktree = new Map(projects.map((project) => [canonicalPath(project.worktree), project]));
+    const collapsed = [];
+    for (const project of projects) {
+        const key = repositoryKeys(project).find((candidate) => !isOrgLevelRepositoryKey(candidate));
+        if (!key || preservedWorktrees.has(canonicalPath(project.worktree))) {
+            collapsed.push(project);
+            continue;
+        }
+        const group = byKey.get(key) ?? [];
+        group.push(project);
+        byKey.set(key, group);
+        const worktree = canonicalPath(project.worktree);
+        const current = representative.get(key);
+        if (!current || worktree.length < current.length)
+            representative.set(key, worktree);
+    }
+    const subpaths = new Map();
+    const representativeForWorktree = new Map();
+    for (const [key, group] of byKey) {
+        const representativeWorktree = representative.get(key);
+        collapsed.push(projectByWorktree.get(representativeWorktree));
+        const names = group
+            .filter((project) => canonicalPath(project.worktree) !== representativeWorktree)
+            .map((project) => {
+            const worktree = canonicalPath(project.worktree);
+            representativeForWorktree.set(worktree, representativeWorktree);
+            return node_path_1.default.relative(representativeWorktree, worktree);
+        })
+            .filter((name) => Boolean(name) && name !== ".")
+            .sort();
+        if (names.length)
+            subpaths.set(representativeWorktree, names);
+    }
+    return { collapsed, subpaths, representativeForWorktree };
+}
+function isOrgLevelRepositoryKey(key) {
+    const parts = key.split("/");
+    return parts.length === 2 && (parts[0] === "github.com" || parts[0].endsWith(".github.com"));
+}
+function repositoryKeys(project) {
+    return [project.remoteMismatch?.actualRemoteUrl, project.remoteUrl, ...(project.relatedIds ?? [])].flatMap((url) => {
+        const key = url ? (0, native_bridge_1.repositoryLocationKey)(url) : undefined;
+        return key ? [key] : [];
+    });
+}
+function relationMatchesProject(relation, project) {
+    const relationKey = (0, native_bridge_1.repositoryLocationKey)(relation.repository);
+    if (!relationKey)
+        return false;
+    const keys = repositoryKeys(project);
+    if (isOrgLevelRepositoryKey(relationKey)) {
+        const prefix = `${relationKey}/`;
+        return keys.some((key) => key === relationKey || key.startsWith(prefix));
+    }
+    return keys.includes(relationKey);
+}
+function repositoryRelations(projects, includeOrganisations = true) {
+    const relations = [];
+    for (const project of projects) {
+        const source = canonicalPath(project.worktree);
+        for (const relation of project.relatedRepositories ?? []) {
+            const key = (0, native_bridge_1.repositoryLocationKey)(relation.repository);
+            if (!includeOrganisations && key && isOrgLevelRepositoryKey(key))
+                continue;
+            for (const relatedProject of projects) {
+                const target = canonicalPath(relatedProject.worktree);
+                if (source === target || !relationMatchesProject(relation, relatedProject))
+                    continue;
+                relations.push({ source, target, type: relation.type });
+            }
+        }
+        // Linked organisations manage every repository the organisation owns.
+        // Each org edge lets an org repository auto-detect its central notes
+        // folder, and lets the central folder see every repo it manages.
+        for (const organisation of includeOrganisations ? (project.relatedOrganisations ?? []) : []) {
+            const organisationKey = (0, native_bridge_1.repositoryLocationKey)(organisation);
+            if (!organisationKey || !isOrgLevelRepositoryKey(organisationKey))
+                continue;
+            const prefix = `${organisationKey}/`;
+            for (const relatedProject of projects) {
+                const target = canonicalPath(relatedProject.worktree);
+                if (source === target)
+                    continue;
+                if (!repositoryKeys(relatedProject).some((key) => key.startsWith(prefix)))
+                    continue;
+                relations.push({ source, target, type: "notes", origin: "organisation" });
+            }
+        }
+    }
+    return relations;
+}
+function configuredSelectedProject(selectedWorktree, configDirectory) {
+    let config;
+    try {
+        config = (0, native_bridge_1.readRaggleProjectConfig)(configDirectory);
+    }
+    catch {
+        return undefined;
+    }
+    const selected = canonicalPath(selectedWorktree);
+    const relatedRepositories = config.linkedRepositories
+        .filter((relation) => canonicalPath(relation.project) === selected)
+        .map((relation) => ({ repository: relation.repository, type: relation.type }));
+    if (!relatedRepositories.length)
+        return undefined;
+    return {
+        worktree: selected,
+        repositoryRoot: selected,
+        remoteUrl: "",
+        relatedIds: [],
+        listed: true,
+        relatedRepositories,
+    };
+}
+function isNestedProject(candidate, parent) {
+    const relative = node_path_1.default.relative(parent, candidate);
+    return Boolean(relative) && relative !== ".." && !relative.startsWith(`..${node_path_1.default.sep}`) && !node_path_1.default.isAbsolute(relative);
+}
+function focusedNotesRelations(relations) {
+    // Organisation links still identify the central notes workspace so an
+    // explicit implementation link from a nested project can be converted, but
+    // they no longer provide notes on their own: a repository without an
+    // explicit notes link receives nothing from the central folder.
+    const organisationByTarget = new Map();
+    for (const relation of relations) {
+        if (relation.origin !== "organisation")
+            continue;
+        const owners = organisationByTarget.get(relation.target) ?? [];
+        owners.push(relation);
+        organisationByTarget.set(relation.target, owners);
+    }
+    return relations.flatMap((relation) => {
+        if (relation.type === "notes") {
+            return relation.origin === "organisation" ? [] : [relation];
+        }
+        // An explicit implementation link from a project inside the central notes
+        // workspace identifies the specific non-code folder for that implementation.
+        if (relation.type === "implementation" &&
+            relation.origin !== "organisation" &&
+            organisationByTarget.get(relation.target)?.some((owner) => isNestedProject(relation.source, owner.source))) {
+            return [{ ...relation, type: "notes" }];
+        }
+        return [];
+    });
+}
+function projectsWithinDepth(initialWorktree, projects, depth, reverse = false, includeOrganisations = true, notesOnly = false) {
+    const projectByWorktree = new Map(projects.map((project) => [canonicalPath(project.worktree), project]));
+    const links = new Map();
+    const allRelations = repositoryRelations(projects, includeOrganisations);
+    const directRelations = notesOnly ? focusedNotesRelations(allRelations) : allRelations;
+    for (const relation of directRelations) {
+        const from = reverse ? relation.target : relation.source;
+        const to = reverse ? relation.source : relation.target;
+        const targets = links.get(from) ?? new Set();
+        targets.add(to);
+        links.set(from, targets);
+    }
+    const initial = canonicalPath(initialWorktree);
+    const visited = new Set([initial]);
+    const depths = new Map([[initial, 0]]);
+    let frontier = [initial];
+    const maxDepth = depth === "full" ? Infinity : depth;
+    for (let level = 0; level < maxDepth && frontier.length; level += 1) {
+        const next = [];
+        for (const worktree of frontier) {
+            for (const target of links.get(worktree) ?? []) {
+                if (visited.has(target))
+                    continue;
+                visited.add(target);
+                depths.set(target, level + 1);
+                next.push(target);
+            }
+        }
+        frontier = next;
+    }
+    visited.delete(initial);
+    const relations = directRelations.filter(({ source, target }) => (visited.has(source) || source === initial) && (visited.has(target) || target === initial));
+    return {
+        projects: [...visited]
+            .map((worktree) => projectByWorktree.get(worktree))
+            .filter((project) => project !== undefined),
+        relations,
+        depths,
+    };
+}
+function localSubpathNames(folder, localProjects, linked) {
+    const linkedKeys = new Set(linked.map((project) => canonicalPath(project.worktree)));
+    return localProjects
+        .filter((project) => !linkedKeys.has(canonicalPath(project.worktree)))
+        .map((project) => project.relativePath || node_path_1.default.relative(canonicalPath(folder), canonicalPath(project.worktree)))
+        .filter((name) => name && name !== ".");
+}
+function connectedProjectsList(folder, connected) {
+    const rows = new Map();
+    const selected = canonicalPath(connected.selectedWorktree);
+    for (const project of connected.linked) {
+        const worktree = canonicalPath(project.worktree);
+        const relation = connected.relations.find((candidate) => candidate.target === worktree);
+        if (!relation || worktree === selected)
+            continue;
+        rows.set(`outgoing\0${worktree}\0${relation.type}`, {
+            worktree,
+            repository: project.remoteUrl,
+            type: relation.type,
+            direction: "outgoing",
+            depth: connected.linkedDepths.get(worktree) ?? 1,
+        });
+    }
+    for (const project of connected.linking) {
+        const worktree = canonicalPath(project.worktree);
+        const relation = connected.relations.find((candidate) => candidate.source === worktree);
+        if (!relation || worktree === selected)
+            continue;
+        rows.set(`incoming\0${worktree}\0${relation.type}`, {
+            worktree,
+            repository: project.remoteUrl,
+            type: relation.type,
+            direction: "incoming",
+            depth: connected.linkingDepths.get(worktree) ?? 1,
+        });
+    }
+    return {
+        schemaVersion: 2,
+        folder: canonicalPath(folder),
+        repositories: [...rows.values()],
+        localSubpaths: localSubpathNames(folder, connected.local, connected.linked),
+    };
+}
+async function listConnectedProjects(folder, options = {}) {
+    if (!(0, node_fs_1.statSync)(folder, { throwIfNoEntry: false })?.isDirectory()) {
+        throw new Error(`Folder does not exist: ${folder}`);
+    }
+    const resolvedWorkspaces = (0, base_repository_1.getResolvedWorkspaces)();
+    const projectLinks = (0, linked_workspace_1.listLinkedWorkspaces)(folder).filter((workspace) => workspace.status === "synced");
+    const linkedSourcePaths = [
+        ...projectLinks.map((workspace) => workspace.source),
+        ...resolvedWorkspaces.map((ws) => ws.worktree),
+    ];
+    const currentRoot = await linkedRepositoryRoot(folder);
+    const configDirectory = nearestProjectConfigDirectory(folder, currentRoot);
+    const linkedSources = [...new Set(await Promise.all(linkedSourcePaths.map(linkedRepositoryRoot)))];
+    const settings = (0, user_settings_1.readRaggleUserSettings)();
+    const schemaScanRoots = [
+        ...new Set([settings.baseRepository, ...settings.projectDirectories].filter((root) => Boolean(root))),
+    ];
+    const [catalogProjects, configuredProjects, configDirectoryProjects, childProjects, linkedProjects] = await Promise.all([
+        (0, user_projects_1.loadUserProjects)(),
+        (0, native_bridge_1.buildProjectCatalog)({
+            cloneSources: settings.cloneDirectories.map((cloneDirectory) => ({ cloneDirectory })),
+            projectRoots: settings.projectDirectories,
+            repositoryLocations: settings.repositoryLocations,
+            localRepositoryLinks: settings.localRepositoryLinks,
+            schemaScanRoots,
+        }),
+        (0, native_bridge_1.discoverProjectsUnderFolder)({ folder: configDirectory }),
+        (0, native_bridge_1.discoverProjectsUnderFolder)({ folder }),
+        linkedSources.length ? (0, native_bridge_1.buildProjectCatalog)({ projectRoots: linkedSources, schemaScanRoots: linkedSources }) : [],
+    ]);
+    const folderWorktree = canonicalPath(folder);
+    const configWorktree = canonicalPath(configDirectory);
+    const baseGraphProjects = uniqueProjects([
+        ...catalogProjects,
+        ...configuredProjects.map(native_bridge_1.catalogToUserProject),
+        ...configDirectoryProjects.map(native_bridge_1.catalogToUserProject),
+        ...linkedProjects.map(native_bridge_1.catalogToUserProject),
+    ]);
+    const folderConfigProject = configuredSelectedProject(folderWorktree, configDirectory);
+    const existingFolderProject = baseGraphProjects.find((project) => project.worktree.trim() && canonicalPath(project.worktree) === folderWorktree);
+    const selectedWorktree = folderConfigProject || existingFolderProject?.relatedRepositories?.length ? folderWorktree : configWorktree;
+    const selectedConfigProject = selectedWorktree === folderWorktree
+        ? folderConfigProject
+        : configuredSelectedProject(selectedWorktree, configDirectory);
+    const existingSelectedProject = baseGraphProjects.find((project) => project.worktree.trim() && canonicalPath(project.worktree) === selectedWorktree);
+    const graphProjects = selectedConfigProject && !existingSelectedProject?.relatedRepositories?.length
+        ? uniqueProjects([...baseGraphProjects, selectedConfigProject])
+        : baseGraphProjects;
+    const childUserProjects = childProjects.map(native_bridge_1.catalogToUserProject);
+    const selectedProject = graphProjects.find((project) => project.worktree.trim() && canonicalPath(project.worktree) === selectedWorktree);
+    const listedProjects = (projects, keepWorktrees = new Set()) => {
+        const candidates = uniqueProjects(projects).filter((project) => canonicalPath(project.worktree) !== selectedWorktree &&
+            (options.all || project.listed === true || keepWorktrees.has(canonicalPath(project.worktree))));
+        if (options.all)
+            return candidates;
+        const candidateWorktrees = new Set(candidates.map((project) => canonicalPath(project.worktree)));
+        return candidates.filter((project) => {
+            // An actual relation target must not disappear merely because a broader
+            // ancestor also has a relation (for example an organisation notes folder).
+            if (keepWorktrees.has(canonicalPath(project.worktree)))
+                return true;
+            let current = node_path_1.default.dirname(canonicalPath(project.worktree));
+            while (current !== selectedWorktree && current !== node_path_1.default.dirname(current)) {
+                if (candidateWorktrees.has(current))
+                    return false;
+                current = node_path_1.default.dirname(current);
+            }
+            return true;
+        });
+    };
+    if (!selectedProject) {
+        const collapsed = collapseRepositorySubprojects(linkedProjects.map(native_bridge_1.catalogToUserProject));
+        const collapsedWorktrees = new Set(collapsed.collapsed.map((project) => canonicalPath(project.worktree)));
+        return {
+            selectedWorktree,
+            linked: listedProjects(collapsed.collapsed, collapsedWorktrees),
+            linking: [],
+            relations: [],
+            local: listedProjects(childUserProjects),
+            linkedDepths: new Map(),
+            linkingDepths: new Map(),
+            linkedSubpaths: collapsed.subpaths,
+            linkingSubpaths: new Map(),
+        };
+    }
+    const depth = options.depth ?? relation_depth_1.defaultRelationDepth;
+    // Focused context keeps declared outgoing links and incoming notes only.
+    // Org-wide expansion is useful outward exploration, not default context;
+    // org links alone provide no notes (explicit links decide what a
+    // repository receives).
+    const selectedProjects = projectsWithinDepth(selectedProject.worktree, graphProjects, depth, false, !options.focused);
+    const linkingProjects = projectsWithinDepth(selectedProject.worktree, graphProjects, depth, true, true, options.focused);
+    // Collapse each repository to one representative project so a repository link
+    // yields a single connected folder. Discovered subprojects (monorepo
+    // packages, native crates, skill folders) become relative subpaths of the
+    // representative instead of duplicate connected repositories.
+    // Notes links identify exact content folders, not repository representatives.
+    // Keep each source intact in focused context, including sibling notes folders.
+    const notesSources = new Set(options.focused
+        ? [...selectedProjects.relations, ...linkingProjects.relations]
+            .filter((relation) => relation.type === "notes")
+            .map((relation) => relation.source)
+        : []);
+    const selectedCollapsed = collapseRepositorySubprojects(selectedProjects.projects, notesSources);
+    const linkingCollapsed = collapseRepositorySubprojects(linkingProjects.projects, notesSources);
+    const representativeForWorktree = new Map([
+        ...selectedCollapsed.representativeForWorktree,
+        ...linkingCollapsed.representativeForWorktree,
+    ]);
+    const redirect = (worktree) => representativeForWorktree.get(worktree) ?? worktree;
+    const relations = [...selectedProjects.relations, ...linkingProjects.relations]
+        .map((relation) => ({ ...relation, source: redirect(relation.source), target: redirect(relation.target) }))
+        .filter((relation) => relation.source !== relation.target)
+        .filter((relation, index, all) => all.findIndex((candidate) => candidate.source === relation.source &&
+        candidate.target === relation.target &&
+        candidate.type === relation.type) === index);
+    const relationWorktrees = new Set(relations.flatMap((relation) => [relation.source, relation.target]));
+    return {
+        selectedWorktree,
+        linked: listedProjects(selectedCollapsed.collapsed, relationWorktrees),
+        linking: listedProjects(linkingCollapsed.collapsed, relationWorktrees),
+        relations,
+        local: listedProjects(childUserProjects),
+        linkedDepths: selectedProjects.depths,
+        linkingDepths: linkingProjects.depths,
+        linkedSubpaths: selectedCollapsed.subpaths,
+        linkingSubpaths: linkingCollapsed.subpaths,
+    };
+}
+async function listConnectedWorktrees(folder, options = {}) {
+    const { linked, linking, local } = await listConnectedProjects(folder, options);
+    return uniqueProjects([...linked, ...linking, ...local]).map((project) => project.worktree);
+}

package/node_modules/@raggle-ai/local/dist/core/generated/cli-commands.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Generated from packages/local/schemas/cli-commands.json.
+ * Do not edit manually.
+ */
+export type RaggleCliCommand = {
+    /** Canonical form, e.g. ["base", "set"]. */
+    tokens: string[];
+    /** One-line description shown in help text and in the TUI slash list. */
+    description: string;
+    /**
+     * Interactive commands start a full-screen UI or long-lived foreground
+     * process; hosts that already run one pick them out and skip them.
+     */
+    interactive?: boolean;
+    /**
+     * The command takes typed input after its name. Hosts show an argument
+     * form instead of running it with an empty argument.
+     */
+    argument?: boolean;
+};
+export declare const RAGGLE_CLI_COMMANDS: readonly RaggleCliCommand[];
+/** Alias token(s) -> canonical form; single source for short command names. */
+export declare const raggleCliCommandAliases: Readonly<Record<string, string[]>>;
+/**
+ * Split the text typed after a slash command into argv tokens. Words split on
+ * whitespace; double or single quoted spans stay one token.
+ */
+export declare function splitRaggleCommandArgument(argument: string): string[];