kennel 0.1.8 → 0.2.0

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

@@ -0,0 +1,401 @@
+"use strict";
+/**
+ * Generated from packages/local/schemas/cli-commands.json.
+ * Do not edit manually.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.raggleCliCommandAliases = exports.RAGGLE_CLI_COMMANDS = void 0;
+exports.splitRaggleCommandArgument = splitRaggleCommandArgument;
+exports.RAGGLE_CLI_COMMANDS = [
+    {
+        tokens: ["help"],
+        description: "Show the command reference",
+    },
+    {
+        tokens: ["init"],
+        description: "Create raggle.json in the current folder",
+    },
+    {
+        tokens: ["link"],
+        description: "Link a repository to this folder (notes, implementation, or dependency)",
+        argument: true,
+    },
+    {
+        tokens: ["unlink"],
+        description: "Remove a linked repository",
+        argument: true,
+    },
+    {
+        tokens: ["relation", "describe"],
+        description: "Describe a linked relation",
+        argument: true,
+    },
+    {
+        tokens: ["relation", "connect"],
+        description: "Connect a linked relation with a type and text",
+        argument: true,
+    },
+    {
+        tokens: ["relation", "sync"],
+        description: "Run the guarded relation sync cycle",
+    },
+    {
+        tokens: ["exclude"],
+        description: "Exclude a local folder subpath",
+        argument: true,
+    },
+    {
+        tokens: ["links", "sync"],
+        description: "Sync repository links",
+    },
+    {
+        tokens: ["links", "status"],
+        description: "Show repository link health",
+    },
+    {
+        tokens: ["base"],
+        description: "Show the configured base repository",
+    },
+    {
+        tokens: ["base", "worktree"],
+        description: "Print the base repository worktree path",
+    },
+    {
+        tokens: ["base", "paths"],
+        description: "List base repository paths",
+    },
+    {
+        tokens: ["base", "projects"],
+        description: "List base repository projects",
+    },
+    {
+        tokens: ["base", "set"],
+        description: "Save the machine-local base repository path",
+        argument: true,
+    },
+    {
+        tokens: ["base", "init"],
+        description: "Create a new base repository",
+        argument: true,
+    },
+    {
+        tokens: ["user"],
+        description: "Show the base GitHub user that search prioritizes",
+    },
+    {
+        tokens: ["user", "set"],
+        description: "Save the base GitHub user that search prioritizes",
+        argument: true,
+    },
+    {
+        tokens: ["workspace", "add"],
+        description: "Register a peer workspace",
+        argument: true,
+    },
+    {
+        tokens: ["workspace", "list"],
+        description: "List peer workspaces",
+    },
+    {
+        tokens: ["workspace", "discover"],
+        description: "Discover workspaces under a path as JSON",
+    },
+    {
+        tokens: ["project", "list"],
+        description: "List project-store entries",
+    },
+    {
+        tokens: ["project", "delete"],
+        description: "Remove project-store entries",
+        argument: true,
+    },
+    {
+        tokens: ["add"],
+        description: "Add repositories by URL to the project store",
+    },
+    {
+        tokens: ["add", "repos"],
+        description: "Add repositories by URL without cloning them inline",
+        argument: true,
+    },
+    {
+        tokens: ["repo", "mount"],
+        description: "Mount a remote repository at a local path",
+        argument: true,
+    },
+    {
+        tokens: ["repo", "add"],
+        description: "Add a remote repository to a workspace",
+        argument: true,
+    },
+    {
+        tokens: ["repo", "locate"],
+        description: "Locate a remote repository at a local path",
+        argument: true,
+    },
+    {
+        tokens: ["favorite"],
+        description: "Mark or unmark a project as favorite",
+        argument: true,
+    },
+    {
+        tokens: ["rename"],
+        description: "Rename the current project",
+        argument: true,
+    },
+    {
+        tokens: ["import", "sessions"],
+        description: "Import recent AI session projects",
+    },
+    {
+        tokens: ["list"],
+        description: "List direct project links and notes for a folder",
+    },
+    {
+        tokens: ["llm"],
+        description: "Print compact LLM context for the current folder",
+    },
+    {
+        tokens: ["agents"],
+        description: "Create or open personal Markdown instructions",
+    },
+    {
+        tokens: ["agents", "list"],
+        description: "List personal instruction profiles as JSON",
+    },
+    {
+        tokens: ["agents", "explain"],
+        description: "Explain selected instruction profiles as JSON",
+    },
+    {
+        tokens: ["paths"],
+        description: "List searchable paths as JSON",
+    },
+    {
+        tokens: ["path"],
+        description: "Browse subpath projects in an interactive picker",
+        interactive: true,
+    },
+    {
+        tokens: ["path", "add"],
+        description: "Add a configured subpath project",
+        argument: true,
+    },
+    {
+        tokens: ["path", "delete"],
+        description: "Delete a configured subpath project",
+        argument: true,
+    },
+    {
+        tokens: ["path", "list"],
+        description: "List configured subpath projects as JSON",
+    },
+    {
+        tokens: ["file", "list"],
+        description: "List searchable local files",
+    },
+    {
+        tokens: ["file"],
+        description: "Read one searchable local file",
+        argument: true,
+    },
+    {
+        tokens: ["files"],
+        description: "List room file paths",
+    },
+    {
+        tokens: ["metadata"],
+        description: "Print local metadata summary",
+    },
+    {
+        tokens: ["session"],
+        description: "Print one AI session as JSON",
+        argument: true,
+    },
+    {
+        tokens: ["session", "create"],
+        description: "Create a new AI chat session",
+        argument: true,
+    },
+    {
+        tokens: ["open"],
+        description: "Open a folder in a configured application",
+        argument: true,
+    },
+    {
+        tokens: ["clone-open"],
+        description: "Clone a repository, then open it",
+        argument: true,
+    },
+    {
+        tokens: ["deeplink"],
+        description: "Print the raggle:// deeplink for a folder",
+        argument: true,
+    },
+    {
+        tokens: ["serve"],
+        description: "Start the local Scout HTTP service",
+        interactive: true,
+    },
+    {
+        tokens: ["mcp"],
+        description: "Start the local MCP server over stdio",
+        interactive: true,
+    },
+    {
+        tokens: ["remote"],
+        description: "Print this folder's remote connection code as a QR code",
+        argument: true,
+    },
+    {
+        tokens: ["all"],
+        description: "Search every local workspace from a cached catalog",
+    },
+    {
+        tokens: ["search"],
+        description: "Search the whole local project catalog",
+    },
+    {
+        tokens: ["tui"],
+        description: "Launch the full-screen terminal search UI",
+        interactive: true,
+    },
+    {
+        tokens: ["shell", "install"],
+        description: "Install shell integration for cd-on-select",
+    },
+    {
+        tokens: ["shell", "uninstall"],
+        description: "Remove shell integration",
+    },
+    {
+        tokens: ["feed"],
+        description: "Fetch repositories and activity from the project feed",
+        argument: true,
+    },
+    {
+        tokens: ["config"],
+        description: "Show remote repository configuration",
+        argument: true,
+    },
+    {
+        tokens: ["config", "project-store", "get"],
+        description: "Show the configured project store",
+    },
+    {
+        tokens: ["config", "project-store", "set"],
+        description: "Configure the Turso project store",
+        argument: true,
+    },
+    {
+        tokens: ["config", "project-store", "unset"],
+        description: "Remove the project store configuration",
+    },
+    {
+        tokens: ["config", "project-store", "turso", "databases"],
+        description: "List Turso databases",
+    },
+    {
+        tokens: ["config", "project-store", "turso", "set"],
+        description: "Select the database used by the project store",
+        argument: true,
+    },
+    {
+        tokens: ["status"],
+        description: "Show Git sync, workspace, mount, and index health",
+    },
+    {
+        tokens: ["sync"],
+        description: "Run the guarded core-repository sync cycle",
+    },
+    {
+        tokens: ["account", "login"],
+        description: "Sign in to the Raggle account",
+    },
+    {
+        tokens: ["account", "logout"],
+        description: "Sign out of the Raggle account",
+    },
+    {
+        tokens: ["account", "status"],
+        description: "Show Raggle account status",
+    },
+    {
+        tokens: ["account", "projects"],
+        description: "List Raggle account projects",
+    },
+];
+/** Alias token(s) -> canonical form; single source for short command names. */
+exports.raggleCliCommandAliases = {
+    a: ["agents"],
+    i: ["init"],
+    lnk: ["link"],
+    ul: ["unlink"],
+    x: ["exclude"],
+    lsync: ["links", "sync"],
+    lst: ["links", "status"],
+    ls: ["list"],
+    ps: ["paths"],
+    fav: ["favorite"],
+    o: ["open"],
+    co: ["clone-open"],
+    ses: ["session"],
+    fl: ["file", "list"],
+    fs: ["files"],
+    meta: ["metadata"],
+    dl: ["deeplink"],
+    rem: ["remote"],
+    fd: ["file"],
+    rm: ["repo", "mount"],
+    ra: ["repo", "add"],
+    rl: ["repo", "locate"],
+    imps: ["import", "sessions"],
+    cfg: ["config"],
+    s: ["search"],
+    bs: ["base", "set"],
+    bi: ["base", "init"],
+    wa: ["workspace", "add"],
+    wl: ["workspace", "list"],
+    wd: ["workspace", "discover"],
+    p: ["project", "list"],
+    pl: ["project", "list"],
+    pd: ["project", "delete"],
+    st: ["status"],
+    sy: ["sync"],
+};
+/**
+ * Split the text typed after a slash command into argv tokens. Words split on
+ * whitespace; double or single quoted spans stay one token.
+ */
+function splitRaggleCommandArgument(argument) {
+    const tokens = [];
+    let current = "";
+    let quote;
+    let started = false;
+    for (const character of argument.trim()) {
+        if (quote) {
+            if (character === quote)
+                quote = undefined;
+            else
+                current += character;
+            continue;
+        }
+        if (character === '"' || character === "'") {
+            quote = character;
+            started = true;
+            continue;
+        }
+        if (/\s/.test(character)) {
+            if (started || current)
+                tokens.push(current);
+            current = "";
+            started = false;
+            continue;
+        }
+        current += character;
+        started = true;
+    }
+    if (started || current)
+        tokens.push(current);
+    return tokens;
+}

package/node_modules/@raggle-ai/local/dist/core/git-change.d.ts

@@ -0,0 +1,9 @@
+export type LocalGitChangeStatus = "added" | "modified" | "deleted" | "renamed" | "untracked" | "conflicted";
+export type LocalGitChange = {
+    path: string;
+    relativePath: string;
+    previousRelativePath?: string;
+    status: LocalGitChangeStatus;
+    staged: boolean;
+    unstaged: boolean;
+};

package/node_modules/@raggle-ai/local/dist/core/git-change.js

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

package/node_modules/@raggle-ai/local/dist/core/indexed-search.d.ts

@@ -0,0 +1,32 @@
+export type IndexedSearchCache<T, Q> = {
+    source: readonly T[];
+    query: Q;
+    candidates: T[];
+};
+type IndexedSearchOptionsBase<T, Q> = {
+    limit?: number;
+    order: (item: T) => number;
+    canNarrow?: (previousQuery: Q, nextQuery: Q) => boolean;
+};
+type MatchAndScoreSearchOptions<T, Q> = IndexedSearchOptionsBase<T, Q> & {
+    matches: (item: T, query: Q) => boolean;
+    score: (item: T, query: Q) => number;
+    evaluate?: never;
+};
+type EvaluatedSearchOptions<T, Q> = IndexedSearchOptionsBase<T, Q> & {
+    evaluate: (item: T, query: Q) => number | undefined;
+    matches?: never;
+    score?: never;
+};
+export type IndexedSearchOptions<T, Q> = MatchAndScoreSearchOptions<T, Q> | EvaluatedSearchOptions<T, Q>;
+export declare function searchIndexedItems<T, Q>(source: readonly T[], query: Q, options: IndexedSearchOptions<T, Q>, previous?: IndexedSearchCache<T, Q>): {
+    items: T[];
+    total: number;
+    scanned: number;
+    cache: {
+        source: readonly T[];
+        query: Q;
+        candidates: T[];
+    };
+};
+export {};

package/node_modules/@raggle-ai/local/dist/core/indexed-search.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchIndexedItems = searchIndexedItems;
+function isBetter(left, right) {
+    return left.score > right.score || (left.score === right.score && left.order < right.order);
+}
+function isWorse(left, right) {
+    return isBetter(right, left);
+}
+function moveWorstDown(heap, startIndex) {
+    let index = startIndex;
+    while (true) {
+        const leftIndex = index * 2 + 1;
+        const rightIndex = leftIndex + 1;
+        let worstIndex = index;
+        if (leftIndex < heap.length && isWorse(heap[leftIndex], heap[worstIndex]))
+            worstIndex = leftIndex;
+        if (rightIndex < heap.length && isWorse(heap[rightIndex], heap[worstIndex]))
+            worstIndex = rightIndex;
+        if (worstIndex === index)
+            return;
+        [heap[index], heap[worstIndex]] = [heap[worstIndex], heap[index]];
+        index = worstIndex;
+    }
+}
+function moveWorstUp(heap, startIndex) {
+    let index = startIndex;
+    while (index > 0) {
+        const parentIndex = Math.floor((index - 1) / 2);
+        if (!isWorse(heap[index], heap[parentIndex]))
+            return;
+        [heap[index], heap[parentIndex]] = [heap[parentIndex], heap[index]];
+        index = parentIndex;
+    }
+}
+function addRankedItem(heap, rankedItem, limit) {
+    if (heap.length < limit) {
+        heap.push(rankedItem);
+        moveWorstUp(heap, heap.length - 1);
+    }
+    else if (isBetter(rankedItem, heap[0])) {
+        heap[0] = rankedItem;
+        moveWorstDown(heap, 0);
+    }
+}
+function sortRankedItems(heap) {
+    return heap.sort((left, right) => (isBetter(left, right) ? -1 : isBetter(right, left) ? 1 : 0));
+}
+function boundedRank(items, query, options) {
+    const limit = Math.max(0, options.limit ?? items.length);
+    if (limit === 0)
+        return [];
+    const heap = [];
+    for (const item of items) {
+        const rankedItem = { item, score: options.score(item, query), order: options.order(item) };
+        addRankedItem(heap, rankedItem, limit);
+    }
+    return sortRankedItems(heap);
+}
+function evaluateAndRank(items, query, options) {
+    const limit = Math.max(0, options.limit ?? items.length);
+    const candidates = [];
+    const heap = [];
+    for (const item of items) {
+        const score = options.evaluate(item, query);
+        if (score === undefined)
+            continue;
+        candidates.push(item);
+        if (limit > 0)
+            addRankedItem(heap, { item, score, order: options.order(item) }, limit);
+    }
+    return { candidates, rankedItems: sortRankedItems(heap) };
+}
+function usesEvaluator(options) {
+    return options.evaluate !== undefined;
+}
+function searchIndexedItems(source, query, options, previous) {
+    const canReuseCandidates = previous?.source === source && Boolean(options.canNarrow?.(previous.query, query));
+    const candidatesToScan = canReuseCandidates ? previous.candidates : source;
+    let candidates;
+    let rankedItems;
+    if (usesEvaluator(options)) {
+        ({ candidates, rankedItems } = evaluateAndRank(candidatesToScan, query, options));
+    }
+    else {
+        candidates = candidatesToScan.filter((item) => options.matches(item, query));
+        rankedItems = boundedRank(candidates, query, options);
+    }
+    return {
+        items: rankedItems.map((rankedItem) => rankedItem.item),
+        total: candidates.length,
+        scanned: candidatesToScan.length,
+        cache: { source, query, candidates },
+    };
+}