kennel 0.1.9 → 0.2.0

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

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeLocalProjectMetadata = mergeLocalProjectMetadata;
+const node_path_1 = __importDefault(require("node:path"));
+const native_bridge_1 = require("../native-bridge");
+const project_emoji_1 = require("./project-emoji");
+function projectWithKeywords(item) {
+    const kw = (0, native_bridge_1.getNative)().projectKeywordsFromNative(JSON.stringify(item));
+    return { ...item, keywords: kw };
+}
+function resolvedProjectName(project, metadata) {
+    if (project.relativePath || project.hasCustomName)
+        return project.name;
+    return metadata?.name ?? project.name;
+}
+function nearestInheritedIconSource(project, projectsByWorktree, metadataByWorktree) {
+    if (!project.relativePath)
+        return undefined;
+    let currentDirectory = node_path_1.default.dirname(project.worktree);
+    while (currentDirectory && currentDirectory !== project.worktree) {
+        if (projectsByWorktree.has(currentDirectory)) {
+            const metadata = metadataByWorktree.get(currentDirectory);
+            if (metadata?.icon)
+                return metadata;
+        }
+        const nextDirectory = node_path_1.default.dirname(currentDirectory);
+        if (nextDirectory === currentDirectory)
+            break;
+        currentDirectory = nextDirectory;
+    }
+    return metadataByWorktree.get(project.repositoryRoot);
+}
+/** Merges consumer metadata into discovered projects and inherits repository icons for subpaths. */
+function mergeLocalProjectMetadata(projects, metadataItems) {
+    const projectsByWorktree = new Map(projects.map((project) => [project.worktree, project]));
+    const metadataByWorktree = new Map(metadataItems.map((metadata) => [metadata.worktree, metadata]));
+    return projects
+        .map((project) => {
+        const metadata = metadataByWorktree.get(project.worktree);
+        const inheritedIcon = nearestInheritedIconSource(project, projectsByWorktree, metadataByWorktree);
+        if (!metadata) {
+            if (!inheritedIcon?.icon)
+                return project;
+            return projectWithKeywords({
+                ...project,
+                icon: project.icon ?? inheritedIcon.icon,
+                iconColor: project.iconColor ?? inheritedIcon.iconColor,
+                hasIcon: project.hasIcon || Boolean(inheritedIcon.icon),
+            });
+        }
+        return projectWithKeywords({
+            ...project,
+            name: resolvedProjectName(project, metadata),
+            worktreeName: metadata.worktreeName ?? project.worktreeName,
+            tags: metadata.tags ?? project.tags,
+            latestSessionTitle: metadata.latestSessionTitle ?? project.latestSessionTitle,
+            icon: metadata.icon ?? inheritedIcon?.icon ?? project.icon,
+            iconColor: metadata.iconColor ?? inheritedIcon?.iconColor ?? project.iconColor,
+            startupCommand: metadata.startupCommand ?? project.startupCommand,
+            sandboxCount: metadata.sandboxCount ?? project.sandboxCount,
+            updatedAt: metadata.updatedAt ?? project.updatedAt,
+            hasIcon: Boolean(metadata.hasIcon) || Boolean(inheritedIcon?.icon) || project.hasIcon,
+            isSessionOnly: metadata.isSessionOnly ?? project.isSessionOnly,
+            isFavorite: metadata.isFavorite ?? project.isFavorite,
+            relatedIds: metadata.relatedIds ?? project.relatedIds,
+        });
+    })
+        .map(project_emoji_1.withProjectEmoji);
+}

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

@@ -0,0 +1,14 @@
+import { type FolderMetadata } from "../folder-metadata";
+import { type SearchableProject } from "./search";
+export type ProjectPresentationOptions = {
+    /** Prefix display names with the fallback emoji. Defaults to false for separate-icon consumers. */
+    addEmojis?: boolean;
+};
+export type ProjectPresentation = {
+    name: string;
+    path: string;
+    emoji?: string;
+    metadata: FolderMetadata;
+};
+/** Configure once per consumer. Resolve current local metadata without changing stored project data. */
+export declare function createProjectPresenter({ addEmojis }?: ProjectPresentationOptions): (project: SearchableProject) => ProjectPresentation;

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

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProjectPresenter = createProjectPresenter;
+const node_path_1 = __importDefault(require("node:path"));
+const folder_metadata_1 = require("../folder-metadata");
+const project_emoji_1 = require("./project-emoji");
+const search_1 = require("./search");
+/** Configure once per consumer. Resolve current local metadata without changing stored project data. */
+function createProjectPresenter({ addEmojis = false } = {}) {
+    return (project) => {
+        const target = (0, search_1.projectSearchResultPath)(project);
+        const folder = target === project.worktree ? project.worktree : node_path_1.default.dirname(target);
+        const metadata = (0, folder_metadata_1.resolveFolderMetadata)(folder, {
+            repositoryRoot: project.repositoryRoot,
+            fallbackIcon: project.icon,
+        });
+        const emoji = (0, project_emoji_1.resolveProjectEmoji)({
+            ...project,
+            repositoryRoot: metadata.repositoryRoot,
+            icon: metadata.icon?.path,
+        });
+        const name = (0, search_1.projectSearchResultName)(project);
+        return {
+            name: addEmojis && emoji && !name.startsWith(emoji) ? `${emoji} ${name}` : name,
+            path: target,
+            emoji,
+            metadata,
+        };
+    };
+}

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

@@ -0,0 +1,3 @@
+export declare function remoteToBrowserUrl(input: string): string | undefined;
+export declare function projectRemoteUrl(worktree: string): Promise<string>;
+export declare function projectRemoteBrowserUrl(worktree: string): Promise<string>;

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

@@ -0,0 +1,45 @@
+"use strict";
+// Thin git CLI wrapper for getting project remote URLs. The pure URL
+// transformations (remoteToBrowserUrl) are in Rust config-core.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.remoteToBrowserUrl = remoteToBrowserUrl;
+exports.projectRemoteUrl = projectRemoteUrl;
+exports.projectRemoteBrowserUrl = projectRemoteBrowserUrl;
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const native_bridge_1 = require("../native-bridge");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+function remoteToBrowserUrl(input) {
+    return (0, native_bridge_1.getNative)().remoteToBrowserUrl(input) ?? undefined;
+}
+async function gitOutput(worktree, args) {
+    const { stdout } = await execFileAsync("git", args, { cwd: worktree });
+    return stdout.trim();
+}
+async function projectRemoteUrl(worktree) {
+    for (const remote of ["origin", "upstream"]) {
+        try {
+            const url = await gitOutput(worktree, ["remote", "get-url", remote]);
+            if (url)
+                return url;
+        }
+        catch {
+            /* try next */
+        }
+    }
+    const remotes = await gitOutput(worktree, ["remote"]);
+    const first = remotes
+        .split(/\r?\n/)
+        .map((r) => r.trim())
+        .find(Boolean);
+    if (!first)
+        throw new Error(`No git remote found for ${worktree}`);
+    return gitOutput(worktree, ["remote", "get-url", first]);
+}
+async function projectRemoteBrowserUrl(worktree) {
+    const remote = await projectRemoteUrl(worktree);
+    const url = remoteToBrowserUrl(remote);
+    if (!url)
+        throw new Error(`Unsupported git remote URL: ${remote}`);
+    return url;
+}

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

@@ -0,0 +1,126 @@
+import type { BaseRepository } from "./base-repository";
+import type { ImportedRepositorySubpath } from "./project-subpaths";
+export type ProjectSearchItemType = "project" | "skill";
+export type RemoteProject = {
+    remoteUrl: string;
+    listed?: boolean;
+    repository?: string;
+    name?: string;
+    description?: string;
+    tags?: string[];
+    subpaths?: ImportedRepositorySubpath[];
+    allSubpath?: boolean;
+    collapseSubpaths?: boolean;
+    allTopLevelFolders?: boolean;
+    folderDepth?: number;
+    folders?: string[];
+    clonePathTemplate?: string;
+    removePathFromName?: boolean;
+    plugins?: string[];
+    searchPriority?: number;
+    linkedRepositories?: LinkedRepositoryConfig[];
+    linkedOrganisations?: LinkedOrganisationConfig[];
+};
+export type LinkedRepositoryConfig = {
+    project: string;
+    repository: string;
+    type: RepositoryLinkType;
+};
+export type RepositoryLinkType = "notes" | "implementation" | "dependency" | "related";
+export type RelatedRepository = {
+    repository: string;
+    type: RepositoryLinkType;
+};
+export type LinkedOrganisationConfig = {
+    project: string;
+    organisation: string;
+};
+export type LocalProject = {
+    id: string;
+    worktree: string;
+    name?: string;
+    description?: string;
+    worktreeName?: string;
+    keywords?: string[];
+    tags?: string[];
+    plugins?: string[];
+    latestSessionTitle?: string;
+    icon?: string;
+    /** Automatically selected Unicode emoji when no image icon is available. */
+    emoji?: string;
+    iconColor?: string;
+    startupCommand?: string;
+    sandboxCount: number;
+    updatedAt?: number;
+    hasIcon: boolean;
+    isSessionOnly: boolean;
+    isFavorite: boolean;
+    relatedIds: string[];
+    remoteUrl: string;
+    browserUrl?: string;
+    isCloned: boolean;
+    repositoryRoot: string;
+    parentProjectName?: string;
+    relativePath?: string;
+    listed?: boolean;
+    isSubpathRoot?: boolean;
+    allSubpath?: boolean;
+    collapseSubpaths?: boolean;
+    allTopLevelFolders?: boolean;
+    folderDepth?: number;
+    subpathAllSubpath?: boolean;
+    removePathFromName?: boolean;
+    hasCustomName?: boolean;
+    remoteMismatch?: {
+        worktree: string;
+        actualRemoteUrl: string;
+    };
+    searchPriority?: number;
+    relatedRepositories?: RelatedRepository[];
+    relatedOrganisations?: string[];
+    baseRepository?: BaseRepository["worktree"];
+    projectType?: ProjectSearchItemType;
+};
+export type ProjectSearchDocument = {
+    id: string;
+    title: string;
+    innerFolder?: string;
+    repositoryLabel?: string;
+    relativePath?: string;
+    worktree: string;
+    description?: string;
+    keywords?: string[];
+    latestSessionTitle?: string;
+    searchPriority?: number;
+    sourceIndex: number;
+    remoteUrl?: string;
+    relatedRepositories?: RelatedRepository[];
+    relatedIds?: string[];
+};
+export type RaggleProjectConfig = {
+    /** Explicit Markdown collections; paths are relative to this config. */
+    schemas?: {
+        path: string;
+        schema: string;
+    }[];
+    listed?: boolean;
+    tags?: string[];
+    folders?: string[];
+    subpaths?: ImportedRepositorySubpath[];
+    allSubpaths?: boolean;
+    collapseSubpaths?: boolean;
+    allTopLevelFolders?: boolean;
+    folderDepth?: number;
+    removePathFromName?: boolean;
+    ignoredSubpaths?: string[];
+    excludeFolders?: string[];
+    includeAgents?: boolean;
+    includeSkills?: boolean;
+    linkedRepositories?: LinkedRepositoryConfig[];
+    linkedOrganisations?: LinkedOrganisationConfig[];
+    searchPriority?: number;
+};
+export type NormalizedRemoteProject = Required<Pick<RemoteProject, "remoteUrl" | "repository" | "tags" | "subpaths" | "allSubpath" | "collapseSubpaths" | "allTopLevelFolders" | "folderDepth" | "folders" | "plugins" | "removePathFromName" | "searchPriority" | "linkedRepositories" | "linkedOrganisations">> & Omit<RemoteProject, "remoteUrl" | "repository" | "tags" | "subpaths" | "allSubpath" | "collapseSubpaths" | "allTopLevelFolders" | "folderDepth" | "folders" | "plugins" | "removePathFromName" | "searchPriority" | "linkedRepositories" | "linkedOrganisations"> & {
+    hasCustomName: boolean;
+};
+export declare function normalizeSearchPriority(input: unknown): number | undefined;

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeSearchPriority = normalizeSearchPriority;
+// Thin TS wrapper for normalizeSearchPriority (used by import.ts adapter)
+function normalizeSearchPriority(input) {
+    const value = input === true ? 1 : typeof input === "number" ? input : undefined;
+    if (value === undefined || !Number.isSafeInteger(value) || value < 1)
+        return undefined;
+    return value;
+}

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

@@ -0,0 +1,19 @@
+export type ProjectSourceType = "json-file" | "turso";
+export type ProjectSourceSettings = {
+    projectSource?: ProjectSourceType;
+    projectListFile?: string;
+    cloneDirectory?: string;
+    projectActionsDirectory?: string[];
+    globalIgnoredSubpaths?: string[];
+    gitCloneAccount?: string;
+    gitPullRequestAuthors?: string[];
+    tursoDatabaseUrl?: string;
+    tursoAuthToken?: string;
+    deviceName?: string;
+};
+export declare function expandHomePath(input?: string): string | undefined;
+export declare function normalizeProjectActionsDirectories(input?: string | string[]): string[];
+export declare function normalizeGitPullRequestAuthors(input?: string | string[]): string[];
+export declare function normalizeGitHubUsername(input?: string): string | undefined;
+export declare function normalizeProjectSourceSettings(settings: ProjectSourceSettings): ProjectSourceSettings;
+export declare function needsTursoProjectSourceSetup(settings: Pick<ProjectSourceSettings, "projectSource" | "tursoDatabaseUrl">): boolean;

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

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expandHomePath = expandHomePath;
+exports.normalizeProjectActionsDirectories = normalizeProjectActionsDirectories;
+exports.normalizeGitPullRequestAuthors = normalizeGitPullRequestAuthors;
+exports.normalizeGitHubUsername = normalizeGitHubUsername;
+exports.normalizeProjectSourceSettings = normalizeProjectSourceSettings;
+exports.needsTursoProjectSourceSetup = needsTursoProjectSourceSetup;
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const native_bridge_1 = require("../native-bridge");
+function expandHomePath(input) {
+    if (!input)
+        return undefined;
+    if (input === "~")
+        return node_os_1.default.homedir();
+    if (input.startsWith(`~${node_path_1.default.sep}`))
+        return node_path_1.default.join(node_os_1.default.homedir(), input.slice(2));
+    return input;
+}
+function normalizeProjectActionsDirectories(input) {
+    const values = Array.isArray(input) ? input : input ? [input] : [];
+    return values.map(expandHomePath).filter((value) => Boolean(value));
+}
+function normalizeGitPullRequestAuthors(input) {
+    const values = Array.isArray(input) ? input : input ? [input] : [];
+    return [
+        ...new Set(values
+            .flatMap((value) => value.split(/[\s,]+/))
+            .map((value) => value.trim().replace(/^@/, ""))
+            .filter(Boolean)),
+    ];
+}
+function normalizeGitHubUsername(input) {
+    const username = input?.trim().replace(/^@/, "");
+    return username || undefined;
+}
+function normalizeProjectSourceSettings(settings) {
+    return {
+        projectSource: settings.projectSource === "turso" ? "turso" : "json-file",
+        projectListFile: expandHomePath(settings.projectListFile),
+        cloneDirectory: expandHomePath(settings.cloneDirectory),
+        projectActionsDirectory: normalizeProjectActionsDirectories(settings.projectActionsDirectory),
+        globalIgnoredSubpaths: (0, native_bridge_1.normalizeGlobalIgnoredSubpaths)(settings.globalIgnoredSubpaths),
+        gitCloneAccount: normalizeGitHubUsername(settings.gitCloneAccount),
+        gitPullRequestAuthors: normalizeGitPullRequestAuthors(settings.gitPullRequestAuthors),
+        tursoDatabaseUrl: settings.tursoDatabaseUrl?.trim() || undefined,
+        tursoAuthToken: settings.tursoAuthToken?.trim() || undefined,
+        deviceName: settings.deviceName?.trim() || node_os_1.default.hostname(),
+    };
+}
+function needsTursoProjectSourceSetup(settings) {
+    return settings.projectSource === "turso" && !settings.tursoDatabaseUrl?.trim();
+}

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

@@ -0,0 +1,21 @@
+import type { CloneRepositoryResult } from "../adapters/git-clone";
+import type { ImportedRepositoryRow } from "../adapters/import";
+import type { TursoProjectSourceSettings } from "../adapters/turso-project-source";
+import { type AddProjectValues } from "./project-add";
+export type AddStoredProjectValues = AddProjectValues;
+export type AddStoredProjectResult = {
+    status: "added" | "exists";
+    row: ImportedRepositoryRow;
+};
+export type CloneStoredProjectOptions = {
+    cloneDirectory: string;
+    startClone: (command: string) => Promise<void>;
+};
+/**
+ * Shared write path for adding a repository to the project store. Every
+ * interface (CLI, Raycast, TUI) uses this so one store cannot drift from
+ * another. A repository already present keeps a single stored record.
+ */
+export declare function addProjectToStore(settings: TursoProjectSourceSettings, values: AddStoredProjectValues): Promise<AddStoredProjectResult>;
+/** Clone an already-stored repository to its configured destination. */
+export declare function cloneStoredProject(row: Pick<ImportedRepositoryRow, "url" | "clonePathTemplate">, options: CloneStoredProjectOptions): Promise<CloneRepositoryResult>;

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addProjectToStore = addProjectToStore;
+exports.cloneStoredProject = cloneStoredProject;
+const git_clone_1 = require("../adapters/git-clone");
+const git_repository_1 = require("../adapters/git-repository");
+const turso_project_source_1 = require("../adapters/turso-project-source");
+const project_add_1 = require("./project-add");
+/**
+ * Shared write path for adding a repository to the project store. Every
+ * interface (CLI, Raycast, TUI) uses this so one store cannot drift from
+ * another. A repository already present keeps a single stored record.
+ */
+async function addProjectToStore(settings, values) {
+    const row = (0, project_add_1.projectRowFromValues)(values);
+    const normalizedUrl = row.url;
+    const rows = await (0, turso_project_source_1.readTursoProjectRows)(settings);
+    const identity = (0, git_repository_1.repositoryLocationKey)(normalizedUrl);
+    const existingRow = rows.find((item) => identity ? (0, git_repository_1.repositoryLocationKey)(item.url) === identity : (0, git_repository_1.normalizeRepositoryUrl)(item.url) === normalizedUrl);
+    if (existingRow)
+        return { status: "exists", row: existingRow };
+    await (0, turso_project_source_1.upsertTursoProjectRow)(settings, row);
+    return { status: "added", row };
+}
+/** Clone an already-stored repository to its configured destination. */
+async function cloneStoredProject(row, options) {
+    const normalizedUrl = (0, git_repository_1.normalizeRepositoryUrl)(String(row.url));
+    return (0, git_clone_1.cloneRepository)(normalizedUrl, (0, project_add_1.repositoryRootPath)({
+        repository: (0, project_add_1.deriveProjectName)(normalizedUrl),
+        remoteUrl: normalizedUrl,
+        clonePathTemplate: typeof row.clonePathTemplate === "string" ? row.clonePathTemplate : undefined,
+    }, options.cloneDirectory), {
+        cloneDirectory: options.cloneDirectory,
+        startClone: options.startClone,
+    });
+}

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

@@ -0,0 +1,16 @@
+import type { RelatedRepository } from "./project-schema";
+export type ImportedRepositorySubpath = {
+    path: string;
+    listed?: boolean;
+    allSubpath?: boolean;
+    removePathFromName?: boolean;
+    searchPriority?: number;
+    relatedRepositories?: RelatedRepository[];
+    relatedOrganisations?: string[];
+};
+export type ProjectSubpathSettingsValues = {
+    allSubpath: boolean;
+    removePathFromName: boolean;
+};
+export declare function shouldIncludeSubpathDirectory(name: string): boolean;
+export declare function readSubpathChildDirectories(parentDirectory: string): string[];

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

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldIncludeSubpathDirectory = shouldIncludeSubpathDirectory;
+exports.readSubpathChildDirectories = readSubpathChildDirectories;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const skippedSubpathDirectories = new Set([
+    ".git",
+    "node_modules",
+    "dist",
+    "build",
+    "coverage",
+    ".next",
+    ".turbo",
+    ".vercel",
+    "target",
+]);
+function shouldIncludeSubpathDirectory(name) {
+    return !name.startsWith(".") && !name.startsWith("_") && !skippedSubpathDirectories.has(name);
+}
+function readSubpathChildDirectories(parentDirectory) {
+    const items = new Set();
+    try {
+        for (const entry of (0, node_fs_1.readdirSync)(parentDirectory, { withFileTypes: true })) {
+            if (!entry.isDirectory() || !shouldIncludeSubpathDirectory(entry.name))
+                continue;
+            items.add(node_path_1.default.join(parentDirectory, entry.name));
+        }
+    }
+    catch {
+        // Ignore missing or unreadable optional subpath directories.
+    }
+    return [...items];
+}

package/node_modules/@raggle-ai/local/dist/core/raggle-deep-link.d.ts

@@ -0,0 +1 @@
+export declare function raggleProjectURL(projectPath: string): string;

package/node_modules/@raggle-ai/local/dist/core/raggle-deep-link.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.raggleProjectURL = raggleProjectURL;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+function raggleProjectURL(projectPath) {
+    const resolvedPath = (0, node_fs_1.realpathSync)(node_path_1.default.resolve(projectPath));
+    return `https://raggle-project-links.vercel.app/open/project?path=${encodeURIComponent(resolvedPath)}`;
+}

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

@@ -0,0 +1,32 @@
+import type { RepositoryLinkType } from "./project-schema";
+import { type ConnectedProjects } from "./connected-projects";
+export declare function describeRelation(folder: string, target: string, text?: string): Promise<{
+    schemaVersion: 1;
+    action: "describe";
+    source: string;
+    target: string;
+    text: string | null;
+    changed?: undefined;
+} | {
+    schemaVersion: 1;
+    action: "describe";
+    source: string;
+    target: string;
+    text: string;
+    changed: boolean;
+}>;
+export declare function syncRelations(folder: string, dryRun?: boolean): Promise<import("./personal-relations-sync").RelationSyncResult>;
+export declare function connectRelation(folder: string, target: string, type: RepositoryLinkType, text: string): Promise<{
+    schemaVersion: 1;
+    action: "connect";
+    source: string;
+    target: string;
+    type: RepositoryLinkType;
+    text: string;
+    changed: boolean;
+}>;
+export type PersonalRelationsOverlay = ConnectedProjects & {
+    personalReasons: Map<string, string>;
+};
+/** Merges personal overlay edges and reasons for the folder's source identity into the connected core graph. */
+export declare function mergePersonalRelations(folder: string, connected: ConnectedProjects): Promise<PersonalRelationsOverlay>;

package/node_modules/@raggle-ai/local/dist/core/relation-commands.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeRelation = describeRelation;
+exports.syncRelations = syncRelations;
+exports.connectRelation = connectRelation;
+exports.mergePersonalRelations = mergePersonalRelations;
+const git_repository_1 = require("../adapters/git-repository");
+const personal_relations_sync_1 = require("./personal-relations-sync");
+const personal_relations_1 = require("./personal-relations");
+const connected_projects_1 = require("./connected-projects");
+function requireText(text) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        throw new Error("--text must not be empty");
+    return trimmed;
+}
+async function relationExists(folder, source, target) {
+    const store = (0, personal_relations_1.readPersonalRelations)();
+    if ((0, personal_relations_1.personalEdge)(store, source.identity, target.identity))
+        return true;
+    if (!target.worktree)
+        return false;
+    const connected = await (0, connected_projects_1.listConnectedProjects)(folder);
+    const folderWorktree = (0, connected_projects_1.canonicalPath)(folder);
+    const targetWorktree = (0, connected_projects_1.canonicalPath)(target.worktree);
+    return connected.relations.some((relation) => (0, connected_projects_1.canonicalPath)(relation.source) === folderWorktree && (0, connected_projects_1.canonicalPath)(relation.target) === targetWorktree);
+}
+async function describeRelation(folder, target, text) {
+    const source = (0, personal_relations_1.resolveSourceIdentity)(folder);
+    const resolvedTarget = await (0, personal_relations_1.resolveTargetRepository)(target);
+    if (!(await relationExists(folder, source, resolvedTarget))) {
+        throw new Error(`No relation exists from ${folder} to ${target}`);
+    }
+    if (text === undefined) {
+        const reason = (0, personal_relations_1.personalReason)((0, personal_relations_1.readPersonalRelations)(), source.identity, resolvedTarget.identity);
+        return {
+            schemaVersion: 1,
+            action: "describe",
+            source: source.identity,
+            target: resolvedTarget.identity,
+            text: reason ?? null,
+        };
+    }
+    const normalized = requireText(text);
+    const store = (0, personal_relations_1.readPersonalRelations)();
+    const { store: next, changed } = (0, personal_relations_1.setPersonalReason)(store, source.identity, resolvedTarget.identity, normalized);
+    (0, personal_relations_1.writePersonalRelations)(next);
+    return {
+        schemaVersion: 1,
+        action: "describe",
+        source: source.identity,
+        target: resolvedTarget.identity,
+        text: normalized,
+        changed,
+    };
+}
+async function syncRelations(folder, dryRun = false) {
+    return (0, personal_relations_sync_1.syncPersonalRelations)({ folder, dryRun });
+}
+async function connectRelation(folder, target, type, text) {
+    const source = (0, personal_relations_1.resolveSourceIdentity)(folder);
+    const resolvedTarget = await (0, personal_relations_1.resolveTargetRepository)(target);
+    const normalized = requireText(text);
+    const store = (0, personal_relations_1.readPersonalRelations)();
+    const { store: next, changed } = (0, personal_relations_1.setPersonalEdge)(store, source.identity, resolvedTarget.identity, type, normalized);
+    (0, personal_relations_1.writePersonalRelations)(next);
+    return {
+        schemaVersion: 1,
+        action: "connect",
+        source: source.identity,
+        target: resolvedTarget.identity,
+        type,
+        text: normalized,
+        changed,
+    };
+}
+/** Merges personal overlay edges and reasons for the folder's source identity into the connected core graph. */
+async function mergePersonalRelations(folder, connected) {
+    const store = (0, personal_relations_1.readPersonalRelations)();
+    const hasPersonal = Object.keys(store.reasons).length > 0 || Object.keys(store.edges).length > 0;
+    if (!hasPersonal)
+        return { ...connected, personalReasons: new Map() };
+    const source = (0, personal_relations_1.resolveSourceIdentity)(folder);
+    const edges = store.edges[source.identity] ?? {};
+    const reasons = store.reasons[source.identity] ?? {};
+    const personalReasons = new Map();
+    const extraRelations = [];
+    const extraLinked = [];
+    for (const targetId of [...new Set([...Object.keys(edges), ...Object.keys(reasons)])]) {
+        const worktree = await (0, personal_relations_1.resolveStoredTargetWorktree)(targetId);
+        if (!worktree)
+            continue;
+        const edge = edges[targetId];
+        const reason = reasons[targetId]?.text;
+        const text = reason ?? edge?.text;
+        if (edge) {
+            extraRelations.push({ source: (0, connected_projects_1.canonicalPath)(source.worktree), target: worktree, type: edge.type });
+            if (!connected.linked.some((project) => (0, connected_projects_1.canonicalPath)(project.worktree) === worktree)) {
+                extraLinked.push({ worktree, remoteUrl: (0, git_repository_1.canonicalRepositoryIdentity)(targetId)?.repository });
+            }
+        }
+        if (text)
+            personalReasons.set(worktree, text);
+    }
+    return {
+        ...connected,
+        linked: [...connected.linked, ...extraLinked],
+        relations: [...connected.relations, ...extraRelations],
+        personalReasons,
+    };
+}