kennel 0.1.8 → 0.2.0

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

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectActionConfigFromSource = projectActionConfigFromSource;
+const native_bridge_1 = require("../native-bridge");
+const native_bridge_2 = require("../native-bridge");
+function stripComments(sourceText) {
+    return sourceText.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1");
+}
+function findMatchingBrace(sourceText, openIndex) {
+    let depth = 0;
+    let quote;
+    let isEscaped = false;
+    for (let index = openIndex; index < sourceText.length; index += 1) {
+        const char = sourceText[index];
+        if (quote) {
+            if (isEscaped) {
+                isEscaped = false;
+            }
+            else if (char === "\\") {
+                isEscaped = true;
+            }
+            else if (char === quote) {
+                quote = undefined;
+            }
+            continue;
+        }
+        if (char === '"' || char === "'" || char === "`") {
+            quote = char;
+            continue;
+        }
+        if (char === "{")
+            depth += 1;
+        if (char === "}") {
+            depth -= 1;
+            if (depth === 0)
+                return index;
+        }
+    }
+    return -1;
+}
+function objectLiteralAfter(sourceText, marker) {
+    const match = marker.exec(sourceText);
+    if (!match)
+        return undefined;
+    const openIndex = sourceText.indexOf("{", match.index + match[0].length);
+    if (openIndex === -1)
+        return undefined;
+    const closeIndex = findMatchingBrace(sourceText, openIndex);
+    if (closeIndex === -1)
+        return undefined;
+    return sourceText.slice(openIndex, closeIndex + 1);
+}
+function parseQuotedStrings(input) {
+    const values = [];
+    const stringPattern = /(["'`])((?:\\.|(?!\1)[\s\S])*?)\1/g;
+    let match;
+    while ((match = stringPattern.exec(input))) {
+        values.push(match[2].replace(/\\(["'`\\])/g, "$1"));
+    }
+    return values;
+}
+function splitArrayElements(input) {
+    const values = [];
+    let start = 0;
+    let depth = 0;
+    let quote;
+    let isEscaped = false;
+    for (let index = 0; index < input.length; index += 1) {
+        const char = input[index];
+        if (quote) {
+            if (isEscaped) {
+                isEscaped = false;
+            }
+            else if (char === "\\") {
+                isEscaped = true;
+            }
+            else if (char === quote) {
+                quote = undefined;
+            }
+            continue;
+        }
+        if (char === '"' || char === "'" || char === "`") {
+            quote = char;
+            continue;
+        }
+        if (char === "{" || char === "[")
+            depth += 1;
+        if (char === "}" || char === "]")
+            depth -= 1;
+        if (char !== "," || depth !== 0)
+            continue;
+        const value = input.slice(start, index).trim();
+        if (value)
+            values.push(value);
+        start = index + 1;
+    }
+    const value = input.slice(start).trim();
+    if (value)
+        values.push(value);
+    return values;
+}
+function parseSubpathItems(input) {
+    return splitArrayElements(input)
+        .map((item) => {
+        const quotedStringMatch = /^\s*(["'`])((?:\\.|(?!\1)[\s\S])*?)\1\s*$/.exec(item);
+        if (quotedStringMatch)
+            return quotedStringMatch[2].replace(/\\(["'`\\])/g, "$1");
+        const pathMatch = /["']?path["']?\s*:\s*(["'`])((?:\\.|(?!\1)[\s\S])*?)\1/.exec(item);
+        if (!pathMatch)
+            return undefined;
+        const allSubpathMatch = /["']?allSubpath["']?\s*:\s*(true|false)\b/.exec(item);
+        const removePathFromNameMatch = /["']?removePathFromName["']?\s*:\s*(true|false)\b/.exec(item);
+        return {
+            path: pathMatch[2].replace(/\\(["'`\\])/g, "$1"),
+            ...(allSubpathMatch ? { allSubpath: allSubpathMatch[1] === "true" } : {}),
+            ...(removePathFromNameMatch ? { removePathFromName: removePathFromNameMatch[1] === "true" } : {}),
+        };
+    })
+        .filter(Boolean);
+}
+function projectActionConfigFromObjectText(objectText) {
+    const config = {};
+    const ignoredSubpathsArrayMatch = /["']?ignoredSubpaths["']?\s*:\s*\[([\s\S]*?)\]/.exec(objectText);
+    if (ignoredSubpathsArrayMatch)
+        config.ignoredSubpaths = parseQuotedStrings(ignoredSubpathsArrayMatch[1]);
+    const ignoredSubpathsStringMatch = /["']?ignoredSubpaths["']?\s*:\s*(["'`])([\s\S]*?)\1/.exec(objectText);
+    if (!ignoredSubpathsArrayMatch && ignoredSubpathsStringMatch) {
+        config.ignoredSubpaths = ignoredSubpathsStringMatch[2].replace(/\\(["'`\\])/g, "$1");
+    }
+    const tagsArrayMatch = /["']?tags["']?\s*:\s*\[([\s\S]*?)\]/.exec(objectText);
+    if (tagsArrayMatch)
+        config.tags = (0, native_bridge_1.normalizeTags)(parseQuotedStrings(tagsArrayMatch[1]));
+    const foldersArrayMatch = /["']?folders["']?\s*:\s*\[([\s\S]*?)\]/.exec(objectText);
+    if (foldersArrayMatch)
+        config.folders = (0, native_bridge_1.normalizeFolders)(parseQuotedStrings(foldersArrayMatch[1]));
+    const subpathsArrayMatch = /["']?subpaths["']?\s*:\s*\[([\s\S]*?)\]/.exec(objectText);
+    if (subpathsArrayMatch) {
+        const subpathValues = parseSubpathItems(subpathsArrayMatch[1]);
+        config.subpaths = subpathValues.length ? (0, native_bridge_2.normalizeSubpaths)(subpathValues) : undefined;
+    }
+    const allSubpathMatch = /["']?allSubpath["']?\s*:\s*(true|false)\b/.exec(objectText);
+    if (allSubpathMatch)
+        config.allSubpath = allSubpathMatch[1] === "true";
+    const collapseSubpathsMatch = /["']?collapseSubpaths["']?\s*:\s*(true|false)\b/.exec(objectText);
+    if (collapseSubpathsMatch)
+        config.collapseSubpaths = collapseSubpathsMatch[1] === "true";
+    const folderDepthMatch = /["']?folderDepth["']?\s*:\s*(\d+)\b/.exec(objectText);
+    if (folderDepthMatch)
+        config.folderDepth = Number.parseInt(folderDepthMatch[1], 10);
+    const removePathFromNameMatch = /["']?removePathFromName["']?\s*:\s*(true|false)\b/.exec(objectText);
+    if (removePathFromNameMatch)
+        config.removePathFromName = removePathFromNameMatch[1] === "true";
+    return Object.keys(config).length ? config : undefined;
+}
+function projectActionConfigFromSource(sourceText) {
+    const source = stripComments(sourceText);
+    const configObject = objectLiteralAfter(source, /\bdefineProjectConfig\s*\(/) ??
+        objectLiteralAfter(source, /\b(?:export\s+)?(?:const|let|var)\s+(?:projectConfig|config)\b[^=]*=/) ??
+        objectLiteralAfter(source, /\b(?:projectConfig|config)\s*:/);
+    return configObject ? projectActionConfigFromObjectText(configObject) : undefined;
+}

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

@@ -0,0 +1,11 @@
+export type ProjectActionConfig = {
+    tags?: string[];
+    folders?: string[];
+    subpaths?: unknown;
+    allSubpath?: boolean;
+    collapseSubpaths?: boolean;
+    allTopLevelFolders?: boolean;
+    folderDepth?: number;
+    removePathFromName?: boolean;
+    ignoredSubpaths?: string[] | string;
+};

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

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

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

@@ -0,0 +1,20 @@
+import { type ImportedRepository, type ImportedRepositoryRow } from "../adapters/import";
+export type AddProjectValues = {
+    url: string;
+    name: string;
+    description: string;
+    tags: string;
+    folders: string[];
+    subpaths: string;
+};
+export declare function getRepositoryNameFromUrl(url: string): string;
+export declare function getRepositoryDirectoryNameFromUrl(url: string): string;
+export declare function deriveLocalProjectPath(url: string, defaultCloneDirectory?: string, folderName?: string): string;
+export declare function deriveProjectName(url: string): string;
+export declare function resolveCloneDestination(clonePath: string, defaultCloneDirectory: string): string;
+export declare function clonePathTemplateFromFormValue(clonePath: string, defaultCloneDirectory: string, defaultRepositoryName: string): string | undefined;
+export declare function projectRowFromValues(values: AddProjectValues): ImportedRepositoryRow;
+export declare function repositoryRootPath(repository: Pick<ImportedRepository, "repository" | "clonePathTemplate"> & {
+    remoteUrl?: string;
+}, defaultCloneDirectory: string): string;
+export declare function repositoryCloneParentDirectory(repository: Pick<ImportedRepository, "repository" | "clonePathTemplate">, defaultCloneDirectory: string): string;

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

@@ -0,0 +1,119 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRepositoryNameFromUrl = getRepositoryNameFromUrl;
+exports.getRepositoryDirectoryNameFromUrl = getRepositoryDirectoryNameFromUrl;
+exports.deriveLocalProjectPath = deriveLocalProjectPath;
+exports.deriveProjectName = deriveProjectName;
+exports.resolveCloneDestination = resolveCloneDestination;
+exports.clonePathTemplateFromFormValue = clonePathTemplateFromFormValue;
+exports.projectRowFromValues = projectRowFromValues;
+exports.repositoryRootPath = repositoryRootPath;
+exports.repositoryCloneParentDirectory = repositoryCloneParentDirectory;
+const node_path_1 = __importDefault(require("node:path"));
+const git_repository_1 = require("../adapters/git-repository");
+const import_1 = require("../adapters/import");
+const native_bridge_1 = require("../native-bridge");
+function splitListInput(input) {
+    return input
+        .split(/[\n,]/)
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
+function repositoryUrlInput(input) {
+    const trimmed = input.trim();
+    const markdownLink = /^\[[^\]]+\]\(([^)]+)\)$/.exec(trimmed);
+    return markdownLink?.[1]?.trim() || trimmed;
+}
+function normalizedRepositoryUrlInput(input) {
+    return (0, git_repository_1.normalizeRepositoryUrl)(repositoryUrlInput(input));
+}
+function getRepositoryNameFromUrl(url) {
+    const trimmedUrl = repositoryUrlInput(url);
+    if (!trimmedUrl)
+        return "";
+    try {
+        return (0, git_repository_1.repositoryName)((0, git_repository_1.normalizeRepositoryUrl)(trimmedUrl));
+    }
+    catch {
+        return "";
+    }
+}
+function getRepositoryDirectoryNameFromUrl(url) {
+    const trimmedUrl = repositoryUrlInput(url);
+    if (!trimmedUrl)
+        return "";
+    try {
+        return (0, git_repository_1.repositoryDirectoryName)(trimmedUrl);
+    }
+    catch {
+        return "";
+    }
+}
+function deriveLocalProjectPath(url, defaultCloneDirectory, folderName) {
+    const repository = folderName?.trim() || getRepositoryDirectoryNameFromUrl(url);
+    if (!defaultCloneDirectory)
+        return repository;
+    if (!repository)
+        return defaultCloneDirectory;
+    return node_path_1.default.join(defaultCloneDirectory, repository);
+}
+function deriveProjectName(url) {
+    return (0, git_repository_1.repositoryName)(normalizedRepositoryUrlInput(url));
+}
+function resolveCloneDestination(clonePath, defaultCloneDirectory) {
+    if (!node_path_1.default.isAbsolute(defaultCloneDirectory)) {
+        throw new Error(`Clone directory must be an absolute path: ${defaultCloneDirectory}`);
+    }
+    return node_path_1.default.isAbsolute(clonePath) ? clonePath : node_path_1.default.join(defaultCloneDirectory, clonePath);
+}
+function clonePathTemplateFromFormValue(clonePath, defaultCloneDirectory, defaultRepositoryName) {
+    const trimmedClonePath = clonePath.trim();
+    if (!trimmedClonePath)
+        return undefined;
+    const clonePathTemplate = (() => {
+        if (!node_path_1.default.isAbsolute(trimmedClonePath) || !defaultCloneDirectory)
+            return trimmedClonePath;
+        const relativePath = node_path_1.default.relative(defaultCloneDirectory, trimmedClonePath);
+        if (!relativePath || relativePath.startsWith("..") || node_path_1.default.isAbsolute(relativePath))
+            return trimmedClonePath;
+        return relativePath;
+    })();
+    const normalized = (0, import_1.normalizeClonePathTemplate)(clonePathTemplate);
+    if (!normalized || normalized === defaultRepositoryName)
+        return undefined;
+    return normalized;
+}
+function projectRowFromValues(values) {
+    const normalizedUrl = normalizedRepositoryUrlInput(values.url);
+    const derivedName = deriveProjectName(normalizedUrl);
+    const trimmedName = values.name.trim();
+    const description = values.description.trim();
+    const tags = (0, import_1.normalizeTags)(splitListInput(values.tags));
+    const folders = (0, import_1.normalizeFolders)(values.folders ?? []);
+    const subpaths = (0, native_bridge_1.normalizeSubpathPaths)(splitListInput(values.subpaths));
+    const row = { url: normalizedUrl };
+    if (trimmedName && trimmedName !== derivedName)
+        row.name = trimmedName;
+    if (description)
+        row.description = description;
+    if (tags.length)
+        row.tags = tags;
+    if (folders.length)
+        row.folders = folders;
+    if (subpaths.length)
+        row.subpaths = subpaths;
+    return row;
+}
+function repositoryRootPath(repository, defaultCloneDirectory) {
+    const clonePathTemplate = (0, import_1.normalizeClonePathTemplate)(repository.clonePathTemplate);
+    if (clonePathTemplate) {
+        return resolveCloneDestination(clonePathTemplate, defaultCloneDirectory);
+    }
+    return resolveCloneDestination(repository.remoteUrl ? (0, git_repository_1.repositoryDirectoryName)(repository.remoteUrl) : repository.repository, defaultCloneDirectory);
+}
+function repositoryCloneParentDirectory(repository, defaultCloneDirectory) {
+    return node_path_1.default.dirname(repositoryRootPath(repository, defaultCloneDirectory));
+}

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

@@ -0,0 +1,43 @@
+import type { LocalProject } from "./types";
+import type { RelatedRepository } from "./project-schema";
+export type CachedProjectRecord = {
+    id: string;
+    worktree: string;
+    name?: string;
+    description?: string;
+    worktreeName?: string;
+    keywords?: string[];
+    tags?: string[];
+    latestSessionTitle?: string;
+    iconColor?: string;
+    startupCommand?: string;
+    sandboxCount: number;
+    updatedAt?: number;
+    hasIcon: boolean;
+    isSessionOnly?: boolean;
+    relatedIds?: string[];
+    remoteUrl?: string;
+    browserUrl?: string;
+    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?: LocalProject["remoteMismatch"];
+    searchPriority?: number;
+    relatedRepositories?: RelatedRepository[];
+    relatedOrganisations?: string[];
+    baseRepository?: LocalProject["baseRepository"];
+};
+export declare function cachedProjectRecord(project: LocalProject): CachedProjectRecord;
+export declare function localProjectFromCacheRecord(record: CachedProjectRecord, options: {
+    icon?: string;
+    isFavorite: boolean;
+}): LocalProject;

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

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cachedProjectRecord = cachedProjectRecord;
+exports.localProjectFromCacheRecord = localProjectFromCacheRecord;
+const project_emoji_1 = require("./project-emoji");
+function cachedProjectRecord(project) {
+    return {
+        id: project.id,
+        worktree: project.worktree,
+        name: project.name,
+        description: project.description,
+        worktreeName: project.worktreeName,
+        keywords: project.keywords,
+        tags: project.tags,
+        latestSessionTitle: project.latestSessionTitle,
+        iconColor: project.iconColor,
+        startupCommand: project.startupCommand,
+        sandboxCount: project.sandboxCount,
+        updatedAt: project.updatedAt,
+        hasIcon: project.hasIcon,
+        isSessionOnly: project.isSessionOnly,
+        relatedIds: project.relatedIds,
+        remoteUrl: project.remoteUrl,
+        browserUrl: project.browserUrl,
+        repositoryRoot: project.repositoryRoot,
+        parentProjectName: project.parentProjectName,
+        relativePath: project.relativePath,
+        listed: project.listed,
+        isSubpathRoot: project.isSubpathRoot,
+        allSubpath: project.allSubpath,
+        collapseSubpaths: project.collapseSubpaths,
+        allTopLevelFolders: project.allTopLevelFolders,
+        folderDepth: project.folderDepth,
+        subpathAllSubpath: project.subpathAllSubpath,
+        removePathFromName: project.removePathFromName,
+        hasCustomName: project.hasCustomName,
+        remoteMismatch: project.remoteMismatch,
+        searchPriority: project.searchPriority,
+        relatedRepositories: project.relatedRepositories,
+        relatedOrganisations: project.relatedOrganisations,
+        baseRepository: project.baseRepository,
+    };
+}
+function localProjectFromCacheRecord(record, options) {
+    const relatedIds = record.relatedIds?.length ? record.relatedIds : [record.id];
+    return (0, project_emoji_1.withProjectEmoji)({
+        id: record.id,
+        worktree: record.worktree,
+        remoteUrl: record.remoteUrl ?? record.worktree,
+        browserUrl: record.browserUrl,
+        repositoryRoot: record.repositoryRoot ?? record.worktree,
+        isCloned: true,
+        name: record.name,
+        description: record.description,
+        worktreeName: record.worktreeName,
+        keywords: record.keywords,
+        tags: record.tags,
+        latestSessionTitle: record.latestSessionTitle,
+        icon: options.icon,
+        iconColor: record.iconColor,
+        startupCommand: record.startupCommand,
+        sandboxCount: record.sandboxCount,
+        updatedAt: record.updatedAt,
+        hasIcon: record.hasIcon,
+        isSessionOnly: Boolean(record.isSessionOnly),
+        isFavorite: options.isFavorite,
+        relatedIds,
+        parentProjectName: record.parentProjectName,
+        relativePath: record.relativePath,
+        listed: record.listed,
+        isSubpathRoot: record.isSubpathRoot,
+        allSubpath: record.allSubpath,
+        collapseSubpaths: record.collapseSubpaths,
+        allTopLevelFolders: record.allTopLevelFolders,
+        folderDepth: record.folderDepth,
+        subpathAllSubpath: record.subpathAllSubpath,
+        removePathFromName: record.removePathFromName,
+        hasCustomName: record.hasCustomName,
+        remoteMismatch: record.remoteMismatch,
+        searchPriority: record.searchPriority,
+        relatedRepositories: record.relatedRepositories,
+        relatedOrganisations: record.relatedOrganisations,
+        baseRepository: record.baseRepository,
+    });
+}

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

@@ -0,0 +1,2 @@
+/** Product choices for terms whose common project meaning is ambiguous in emoji keyword data. */
+export declare const projectEmojiPreferences: Readonly<Record<string, string>>;

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectEmojiPreferences = void 0;
+/** Product choices for terms whose common project meaning is ambiguous in emoji keyword data. */
+exports.projectEmojiPreferences = {
+    music: "🎵",
+    greek: "🇬🇷",
+    british: "🇬🇧",
+    turkey: "🇹🇷",
+};

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

@@ -0,0 +1,15 @@
+/** Only stable project metadata is used; queries and session titles do not affect selection. */
+export type ProjectEmojiInput = {
+    worktree: string;
+    name?: string;
+    icon?: string;
+    tags?: readonly string[];
+    keywords?: readonly string[];
+    repositoryRoot?: string;
+    parentProjectName?: string;
+};
+/** An offline display fallback, never an image path or a persisted configuration override. */
+export declare function resolveProjectEmoji(project: ProjectEmojiInput): string | undefined;
+export declare function withProjectEmoji<T extends ProjectEmojiInput>(project: T): T & {
+    emoji?: string;
+};

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

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveProjectEmoji = resolveProjectEmoji;
+exports.withProjectEmoji = withProjectEmoji;
+const node_path_1 = __importDefault(require("node:path"));
+const project_emoji_preferences_1 = require("./project-emoji-preferences");
+let keywordIndex;
+function words(text) {
+    return (text
+        .replace(/([a-z\d])([A-Z])/g, "$1 $2")
+        .normalize("NFKD")
+        .replace(/\p{M}/gu, "")
+        .toLowerCase()
+        .match(/[\p{L}\p{N}]+/gu) ?? []);
+}
+function emojiKeywords() {
+    if (keywordIndex)
+        return keywordIndex;
+    // The generated catalog is shipped with this package. No source dataset or network is needed.
+    const catalog = require("../generated/project-emoji.json");
+    const terms = new Map();
+    let maxWords = 1;
+    function add(text, emoji, priority, region) {
+        const tokens = words(text);
+        if (!tokens.length)
+            return;
+        const term = tokens.join(" ");
+        const candidates = terms.get(term) ?? new Map();
+        const existing = candidates.get(emoji);
+        if (!existing || priority > existing.priority) {
+            candidates.set(emoji, { emoji, priority, wholeOnly: region && /^[a-z]{2}$/.test(term) });
+        }
+        terms.set(term, candidates);
+        maxWords = Math.max(maxWords, tokens.length);
+    }
+    for (const item of catalog.emojis) {
+        const region = Boolean(item.regionName);
+        add(item.label, item.emoji, 4, region);
+        if (item.regionName)
+            add(item.regionName, item.emoji, 5, true);
+        for (const alias of item.aliases)
+            add(alias, item.emoji, 3, region);
+        for (const tag of item.tags)
+            add(tag, item.emoji, 2, region);
+        for (const keyword of item.keywords)
+            add(keyword, item.emoji, 1, region);
+    }
+    for (const [term, emoji] of Object.entries(project_emoji_preferences_1.projectEmojiPreferences))
+        add(term, emoji, 6, false);
+    keywordIndex = { terms, maxWords };
+    return keywordIndex;
+}
+function matchEmoji(text, allowCountryCodes = true) {
+    const tokens = words(text);
+    const { terms, maxWords } = emojiKeywords();
+    // Longer phrases win. For equal-length matches prefer names to aliases, then tags and keywords.
+    for (let length = Math.min(tokens.length, maxWords); length > 0; length--) {
+        let priority = 0;
+        const best = new Set();
+        for (let start = 0; start + length <= tokens.length; start++) {
+            const candidates = terms.get(tokens.slice(start, start + length).join(" "));
+            if (!candidates)
+                continue;
+            for (const candidate of candidates.values()) {
+                if (candidate.wholeOnly && (!allowCountryCodes || length !== tokens.length))
+                    continue;
+                if (candidate.priority > priority) {
+                    priority = candidate.priority;
+                    best.clear();
+                }
+                if (candidate.priority === priority)
+                    best.add(candidate.emoji);
+            }
+        }
+        // Do not turn an ambiguous keyword into an arbitrary emoji based on dataset order.
+        if (best.size)
+            return best.size === 1 ? best.values().next().value : undefined;
+    }
+    return undefined;
+}
+/** An offline display fallback, never an image path or a persisted configuration override. */
+function resolveProjectEmoji(project) {
+    if (project.icon)
+        return undefined;
+    for (const text of [project.name, node_path_1.default.basename(project.worktree), ...(project.tags ?? [])]) {
+        if (!text)
+            continue;
+        const emoji = matchEmoji(text);
+        if (emoji)
+            return emoji;
+    }
+    for (const text of project.keywords ?? []) {
+        const emoji = matchEmoji(text, false);
+        if (emoji)
+            return emoji;
+    }
+    // Do not infer a project topic from an unrelated home or checkout directory.
+    if (project.repositoryRoot) {
+        const root = node_path_1.default.resolve(project.repositoryRoot);
+        let directory = node_path_1.default.dirname(node_path_1.default.resolve(project.worktree));
+        while (directory === root || directory.startsWith(root + node_path_1.default.sep)) {
+            const emoji = matchEmoji(node_path_1.default.basename(directory));
+            if (emoji)
+                return emoji;
+            if (directory === root)
+                break;
+            directory = node_path_1.default.dirname(directory);
+        }
+    }
+    return (project.parentProjectName && matchEmoji(project.parentProjectName)) || "📁";
+}
+function withProjectEmoji(project) {
+    return { ...project, emoji: resolveProjectEmoji(project) };
+}

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

@@ -0,0 +1,3 @@
+import type { LocalMarkdownFileSummary } from "./markdown-file";
+export declare function isProjectInstruction(file: LocalMarkdownFileSummary): boolean;
+export declare function compareProjectInstructions(left: LocalMarkdownFileSummary, right: LocalMarkdownFileSummary): number;

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isProjectInstruction = isProjectInstruction;
+exports.compareProjectInstructions = compareProjectInstructions;
+const instructionNames = new Set(["AGENTS.md", "CLAUDE.md", "GEMINI.md"]);
+const instructionPaths = new Set([".github/copilot-instructions.md"]);
+function isProjectInstruction(file) {
+    return instructionNames.has(file.name) || instructionPaths.has(file.relativePath);
+}
+function compareProjectInstructions(left, right) {
+    const leftDepth = left.relativePath.split("/").length;
+    const rightDepth = right.relativePath.split("/").length;
+    if (leftDepth !== rightDepth)
+        return leftDepth - rightDepth;
+    return left.relativePath.localeCompare(right.relativePath);
+}

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

@@ -0,0 +1,11 @@
+import type { LocalProject } from "./types";
+export declare const maxProgressiveIconHydrationProjects = 300;
+export declare function hydrateProjectMetadata(items: LocalProject[], dependencies: {
+    discoverIcon: (worktree: string) => string | undefined;
+    hydrateIcons: (items: LocalProject[], onUpdate?: (items: LocalProject[]) => void, options?: {
+        force?: boolean;
+    }) => Promise<LocalProject[]>;
+}, options?: {
+    force?: boolean;
+    onUpdate?: (items: LocalProject[]) => void;
+}): Promise<LocalProject[]>;

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maxProgressiveIconHydrationProjects = void 0;
+exports.hydrateProjectMetadata = hydrateProjectMetadata;
+const project_metadata_1 = require("./project-metadata");
+exports.maxProgressiveIconHydrationProjects = 300;
+async function hydrateProjectMetadata(items, dependencies, options) {
+    const iconOwners = new Set(items.filter((item) => !item.relativePath || dependencies.discoverIcon(item.worktree)).map((item) => item.worktree));
+    const branchItems = items.filter((item) => Boolean(item.relativePath) && iconOwners.has(item.worktree));
+    const rootItems = items.filter((item) => !item.relativePath && iconOwners.has(item.worktree));
+    const hydratedBranches = await dependencies.hydrateIcons(branchItems, () => { }, options);
+    const progressive = Boolean(options?.onUpdate && items.length <= exports.maxProgressiveIconHydrationProjects);
+    const hydratedRoots = await dependencies.hydrateIcons(rootItems, progressive
+        ? (updated) => options?.onUpdate?.((0, project_metadata_1.mergeLocalProjectMetadata)(items, [...hydratedBranches, ...updated]))
+        : undefined, options);
+    return (0, project_metadata_1.mergeLocalProjectMetadata)(items, [...hydratedBranches, ...hydratedRoots]);
+}

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

@@ -0,0 +1,4 @@
+import type { LocalProject } from "./types";
+export type LocalProjectMetadata = Pick<LocalProject, "worktree"> & Partial<Pick<LocalProject, "name" | "worktreeName" | "tags" | "latestSessionTitle" | "icon" | "iconColor" | "startupCommand" | "sandboxCount" | "updatedAt" | "hasIcon" | "isSessionOnly" | "isFavorite" | "relatedIds">>;
+/** Merges consumer metadata into discovered projects and inherits repository icons for subpaths. */
+export declare function mergeLocalProjectMetadata(projects: LocalProject[], metadataItems: readonly LocalProjectMetadata[]): LocalProject[];