kennel 0.1.9 → 0.2.1

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nowMs = nowMs;
+exports.setLogsEnabled = setLogsEnabled;
+exports.isLogsEnabled = isLogsEnabled;
+exports.logEvent = logEvent;
+exports.logTiming = logTiming;
+const truthyLogValues = new Set(["1", "true", "yes", "on"]);
+let logsEnabled = isLogEnvironmentEnabled();
+function isLogEnvironmentEnabled() {
+    return [process.env.RAGGLE_LOGS, process.env.RGL_LOGS].some((value) => value ? truthyLogValues.has(value.toLowerCase()) : false);
+}
+function detailsSuffix(details) {
+    if (!details)
+        return "";
+    const definedDetails = Object.fromEntries(Object.entries(details).filter(([, value]) => value !== undefined));
+    return Object.keys(definedDetails).length ? ` ${JSON.stringify(definedDetails)}` : "";
+}
+function nowMs() {
+    return Date.now();
+}
+function setLogsEnabled(enabled) {
+    logsEnabled = enabled ?? isLogEnvironmentEnabled();
+}
+function isLogsEnabled() {
+    return logsEnabled;
+}
+function logEvent(namespace, label, details) {
+    if (!logsEnabled)
+        return;
+    console.error(`[${namespace}] ${label}${detailsSuffix(details)}`);
+}
+function logTiming(namespace, label, startedAt, details) {
+    if (!logsEnabled)
+        return;
+    logEvent(namespace, `${label} ${nowMs() - startedAt}ms`, details);
+}

package/node_modules/@raggle-ai/local/dist/core/markdown-file.d.ts

@@ -0,0 +1,20 @@
+export type LocalMarkdownFileSummary = {
+    path: string;
+    relativePath: string;
+    name: string;
+    size: number;
+    lastCommitAt?: number;
+    localEditAt?: number;
+    activityAt: number;
+};
+export type LocalMarkdownFile = LocalMarkdownFileSummary & {
+    content: string;
+};
+export type ListLocalMarkdownFilesOptions = {
+    folder: string;
+    limit?: number;
+};
+export type ReadLocalMarkdownFileOptions = {
+    folder: string;
+    relativePath: string;
+};

package/node_modules/@raggle-ai/local/dist/core/markdown-file.js

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

package/node_modules/@raggle-ai/local/dist/core/open-in.d.ts

@@ -0,0 +1,18 @@
+import { type AiChatClientId } from "@raggle-ai/clients";
+export type OpenInCategory = "terminal" | "ide" | "aiClient" | "documents" | "gitDiff";
+export type OpenInStrategy = {
+    type: "gui-app";
+} | {
+    type: "git-host";
+    hosts: string[];
+} | {
+    type: "ai-chat-client";
+    client: AiChatClientId;
+} | {
+    type: "terminal-script";
+    script: "terminal" | "iterm2";
+};
+export declare const DEFAULT_OPEN_IN_TARGETS: Record<OpenInCategory, string>;
+export declare function openInStrategy(target: string, browserHosts?: string[]): OpenInStrategy;
+export declare function defaultOpenInTarget(settings: Partial<Record<OpenInCategory, string>>, category: OpenInCategory): string;
+export declare function browserHost(browserUrl?: string): string | undefined;

package/node_modules/@raggle-ai/local/dist/core/open-in.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_OPEN_IN_TARGETS = void 0;
+exports.openInStrategy = openInStrategy;
+exports.defaultOpenInTarget = defaultOpenInTarget;
+exports.browserHost = browserHost;
+const clients_1 = require("@raggle-ai/clients");
+exports.DEFAULT_OPEN_IN_TARGETS = {
+    terminal: "terminal",
+    ide: "vscodium",
+    aiClient: "opencode",
+    documents: "zettlr",
+    gitDiff: "github-desktop",
+};
+const aiClients = new Set(clients_1.AI_CHAT_CLIENT_IDS);
+function openInStrategy(target, browserHosts) {
+    if (browserHosts?.length)
+        return { type: "git-host", hosts: browserHosts };
+    if (target === "terminal" || target === "iterm2")
+        return { type: "terminal-script", script: target };
+    if (aiClients.has(target))
+        return { type: "ai-chat-client", client: target };
+    return { type: "gui-app" };
+}
+function defaultOpenInTarget(settings, category) {
+    return settings[category] ?? exports.DEFAULT_OPEN_IN_TARGETS[category];
+}
+function browserHost(browserUrl) {
+    if (!browserUrl)
+        return undefined;
+    try {
+        return new URL(browserUrl).hostname.replace(/^www\./, "");
+    }
+    catch {
+        return undefined;
+    }
+}

package/node_modules/@raggle-ai/local/dist/core/personal-relations-sync.d.ts

@@ -0,0 +1,27 @@
+export declare const personalRelationsSyncSchemaVersion = 1;
+/** Local portable repository identity -> SaaS `repo:<provider>:<owner>/<repo>` id. */
+export declare function cloudProjectId(identity: string): string | undefined;
+/** SaaS `repo:<provider>:<owner>/<repo>` id -> local portable repository identity. */
+export declare function repositoryUrlFromCloudId(id: string): string | undefined;
+export type RelationSyncCounts = {
+    pull: number;
+    push: number;
+    update: number;
+    unchanged: number;
+    conflicts: number;
+    skipped: number;
+};
+export type RelationSyncResult = {
+    schemaVersion: 1;
+    action: "sync";
+    dryRun: boolean;
+    source: string;
+    baseUrl: string;
+    counts: RelationSyncCounts;
+};
+export type RelationSyncOptions = {
+    folder: string;
+    dryRun?: boolean;
+    baseUrl?: string;
+};
+export declare function syncPersonalRelations(options: RelationSyncOptions): Promise<RelationSyncResult>;

package/node_modules/@raggle-ai/local/dist/core/personal-relations-sync.js

@@ -0,0 +1,231 @@
+"use strict";
+// Two-way upsert sync between the machine-local personal relation overlay
+// (`~/.config/raggle/settings.json` `personalRelations.edges`) and the SaaS
+// relation-annotations API.
+//
+// Natural key (matches the SaaS `isSameRelationEdge` uniqueness rule):
+//   (sourceProjectId, targetId, direction, relationType, edgeOrigin)
+// Local personal edges always sync as `direction=outgoing` and
+// `edgeOrigin=personal`. Sync is additive: it pulls, pushes, and updates, but
+// never propagates deletes. Conflict behavior is documented in
+// `docs/cli/relation.md`.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.personalRelationsSyncSchemaVersion = void 0;
+exports.cloudProjectId = cloudProjectId;
+exports.repositoryUrlFromCloudId = repositoryUrlFromCloudId;
+exports.syncPersonalRelations = syncPersonalRelations;
+const git_repository_1 = require("../adapters/git-repository");
+const relation_annotations_api_1 = require("../adapters/relation-annotations-api");
+const personal_relations_1 = require("./personal-relations");
+exports.personalRelationsSyncSchemaVersion = 1;
+/** Local portable repository identity -> SaaS `repo:<provider>:<owner>/<repo>` id. */
+function cloudProjectId(identity) {
+    const trimmed = identity.trim();
+    if (!trimmed)
+        return undefined;
+    if (trimmed.startsWith("/") || trimmed.startsWith("~") || trimmed.startsWith("."))
+        return undefined;
+    const canonical = (0, git_repository_1.canonicalRepositoryIdentity)(trimmed);
+    if (!canonical?.repository?.startsWith("https://"))
+        return undefined;
+    const slash = canonical.key.indexOf("/");
+    if (slash <= 0)
+        return undefined;
+    const host = canonical.key.slice(0, slash);
+    const repositoryPath = canonical.key.slice(slash + 1);
+    if (!host || !repositoryPath)
+        return undefined;
+    const provider = host === "github.com" || host.endsWith(".github.com") ? "github" : host;
+    return `repo:${provider}:${repositoryPath}`;
+}
+/** SaaS `repo:<provider>:<owner>/<repo>` id -> local portable repository identity. */
+function repositoryUrlFromCloudId(id) {
+    if (!id.startsWith("repo:"))
+        return undefined;
+    const value = id.slice("repo:".length);
+    const colon = value.indexOf(":");
+    if (colon <= 0)
+        return undefined;
+    const provider = value.slice(0, colon);
+    const repositoryPath = value.slice(colon + 1);
+    if (!provider || !repositoryPath)
+        return undefined;
+    const host = provider === "github" ? "github.com" : provider;
+    return `https://${host}/${repositoryPath}`;
+}
+function naturalKey(sourceProjectId, targetId, direction, relationType, edgeOrigin) {
+    return [sourceProjectId, targetId, direction, relationType, edgeOrigin].join("\u0000");
+}
+function reconcileBoth(entry, annotation) {
+    // Never synced (no cloud id/timestamp): local data wins so existing user
+    // annotations are preserved and reconciled into the cloud.
+    if (!entry.annotationId || !entry.updatedAt)
+        return "push-update";
+    if (entry.updatedAt > annotation.updatedAt)
+        return "push-update";
+    if (entry.updatedAt < annotation.updatedAt)
+        return "pull-update";
+    return entry.text === annotation.reason ? "unchanged" : "conflict";
+}
+async function syncPersonalRelations(options) {
+    const { folder } = options;
+    const dryRun = options.dryRun === true;
+    const { token, baseUrl } = (0, relation_annotations_api_1.readRelationsApiCredentials)({ baseUrl: options.baseUrl });
+    if (!token) {
+        throw new Error(`RAGGLE_RELATIONS_API_TOKEN is not set. Create a machine API token with relations:read and relations:write ` +
+            `in the Raggle dashboard and export it. The token is read from the environment only and is never written to disk.`);
+    }
+    const source = (0, personal_relations_1.resolveSourceIdentity)(folder);
+    const sourceCloudId = cloudProjectId(source.identity);
+    if (!sourceCloudId) {
+        throw new Error(`Cannot sync relations for ${folder}: the source project "${source.identity}" has no portable repository identity.`);
+    }
+    const store = (0, personal_relations_1.readPersonalRelations)();
+    const sourceEdgesInput = store.edges[source.identity] ?? {};
+    const localByKey = new Map();
+    const localByTarget = new Map();
+    let skipped = 0;
+    for (const [targetIdentity, entry] of Object.entries(sourceEdgesInput)) {
+        const targetCloudId = cloudProjectId(targetIdentity);
+        const record = { targetIdentity, targetCloudId: targetCloudId ?? "", entry };
+        localByTarget.set(targetIdentity, record);
+        if (!targetCloudId) {
+            skipped += 1;
+            continue;
+        }
+        localByKey.set(naturalKey(sourceCloudId, targetCloudId, "outgoing", entry.type, "personal"), record);
+    }
+    const client = { baseUrl, apiToken: token };
+    const annotations = await (0, relation_annotations_api_1.listRelationAnnotations)(client);
+    const cloudByKey = new Map();
+    for (const annotation of annotations) {
+        if (annotation.edgeOrigin !== "personal" || annotation.direction !== "outgoing")
+            continue;
+        if (annotation.sourceProjectId !== sourceCloudId)
+            continue;
+        cloudByKey.set(naturalKey(annotation.sourceProjectId, annotation.targetId, annotation.direction, annotation.relationType, annotation.edgeOrigin), annotation);
+    }
+    let pull = 0;
+    let push = 0;
+    let update = 0;
+    let unchanged = 0;
+    let conflicts = 0;
+    const plans = [];
+    const plannedLocalKeys = new Set();
+    for (const [key, stored] of localByKey) {
+        const annotation = cloudByKey.get(key);
+        if (!annotation) {
+            plans.push({ kind: "push", stored });
+            continue;
+        }
+        plannedLocalKeys.add(key);
+        plans.push({ kind: "both", stored, annotation, action: reconcileBoth(stored.entry, annotation) });
+    }
+    for (const [key, annotation] of cloudByKey) {
+        if (plannedLocalKeys.has(key))
+            continue;
+        const targetIdentity = repositoryUrlFromCloudId(annotation.targetId);
+        if (!targetIdentity) {
+            skipped += 1;
+            continue;
+        }
+        const sameTarget = localByTarget.get(targetIdentity);
+        if (sameTarget && sameTarget.entry.type !== annotation.relationType) {
+            // Same source->target but a different relation type cannot be represented
+            // in the local single-type-per-target model; surface it as a conflict
+            // instead of overwriting either side.
+            conflicts += 1;
+            continue;
+        }
+        plans.push({ kind: "pull", targetIdentity, annotation });
+    }
+    const nextSourceEdges = { ...sourceEdgesInput };
+    let localChanged = false;
+    for (const plan of plans) {
+        if (plan.kind === "push") {
+            push += 1;
+            if (dryRun)
+                continue;
+            const created = await (0, relation_annotations_api_1.createRelationAnnotation)(client, {
+                sourceProjectId: sourceCloudId,
+                targetId: plan.stored.targetCloudId,
+                direction: "outgoing",
+                relationType: plan.stored.entry.type,
+                edgeOrigin: "personal",
+                reason: plan.stored.entry.text,
+            });
+            nextSourceEdges[plan.stored.targetIdentity] = {
+                ...plan.stored.entry,
+                annotationId: created.id,
+                createdAt: created.createdAt,
+                updatedAt: created.updatedAt,
+            };
+            localChanged = true;
+            continue;
+        }
+        if (plan.kind === "pull") {
+            pull += 1;
+            if (dryRun)
+                continue;
+            nextSourceEdges[plan.targetIdentity] = {
+                type: plan.annotation.relationType,
+                text: plan.annotation.reason,
+                createdAt: plan.annotation.createdAt,
+                updatedAt: plan.annotation.updatedAt,
+                annotationId: plan.annotation.id,
+            };
+            localChanged = true;
+            continue;
+        }
+        if (plan.action === "push-update") {
+            update += 1;
+            if (dryRun)
+                continue;
+            const updated = await (0, relation_annotations_api_1.updateRelationAnnotation)(client, plan.annotation.id, { reason: plan.stored.entry.text });
+            nextSourceEdges[plan.stored.targetIdentity] = {
+                ...plan.stored.entry,
+                annotationId: updated.id,
+                createdAt: updated.createdAt,
+                updatedAt: updated.updatedAt,
+            };
+            localChanged = true;
+            continue;
+        }
+        if (plan.action === "pull-update") {
+            update += 1;
+            if (dryRun)
+                continue;
+            nextSourceEdges[plan.stored.targetIdentity] = {
+                type: plan.stored.entry.type,
+                text: plan.annotation.reason,
+                createdAt: plan.stored.entry.createdAt ?? plan.annotation.createdAt,
+                updatedAt: plan.annotation.updatedAt,
+                annotationId: plan.annotation.id,
+            };
+            localChanged = true;
+            continue;
+        }
+        if (plan.action === "unchanged") {
+            unchanged += 1;
+            if (dryRun)
+                continue;
+            if (!plan.stored.entry.annotationId) {
+                nextSourceEdges[plan.stored.targetIdentity] = { ...plan.stored.entry, annotationId: plan.annotation.id };
+                localChanged = true;
+            }
+            continue;
+        }
+        conflicts += 1;
+    }
+    if (localChanged && !dryRun) {
+        (0, personal_relations_1.writePersonalRelations)({ ...store, edges: { ...store.edges, [source.identity]: nextSourceEdges } });
+    }
+    return {
+        schemaVersion: exports.personalRelationsSyncSchemaVersion,
+        action: "sync",
+        dryRun,
+        source: source.identity,
+        baseUrl,
+        counts: { pull, push, update, unchanged, conflicts, skipped },
+    };
+}

package/node_modules/@raggle-ai/local/dist/core/personal-relations.d.ts

@@ -0,0 +1,34 @@
+import { type PersonalRelationEdgeEntry, type PersonalRelationsSettings } from "../adapters/user-settings";
+import type { RepositoryLinkType } from "./project-schema";
+export declare const personalRelationsSchemaVersion = 1;
+export declare function emptyPersonalRelations(): PersonalRelationsSettings;
+export declare function readPersonalRelations(): PersonalRelationsSettings;
+export declare function writePersonalRelations(store: PersonalRelationsSettings): void;
+export type ResolvedRelationSource = {
+    /** Portable source identity: canonical repository URL, else local worktree path. */
+    identity: string;
+    worktree: string;
+    repository?: string;
+};
+/** Resolves the `--folder` source project using its repository identity when available. */
+export declare function resolveSourceIdentity(folder: string): ResolvedRelationSource;
+export type ResolvedRelationTarget = {
+    /** Canonical target identity: repository URL when available, else local worktree path. */
+    identity: string;
+    repository?: string;
+    worktree?: string;
+};
+/** Resolves a relation target (path, owner/repo, or URL) to a portable identity and optional worktree. */
+export declare function resolveTargetRepository(target: string): Promise<ResolvedRelationTarget>;
+/** Locates a stored target identity on disk using repository locations or the user project catalog. */
+export declare function resolveStoredTargetWorktree(targetIdentity: string): Promise<string | undefined>;
+export declare function setPersonalReason(store: PersonalRelationsSettings, source: string, target: string, text: string): {
+    store: PersonalRelationsSettings;
+    changed: boolean;
+};
+export declare function setPersonalEdge(store: PersonalRelationsSettings, source: string, target: string, type: RepositoryLinkType, text: string): {
+    store: PersonalRelationsSettings;
+    changed: boolean;
+};
+export declare function personalReason(store: PersonalRelationsSettings, source: string, target: string): string | undefined;
+export declare function personalEdge(store: PersonalRelationsSettings, source: string, target: string): PersonalRelationEdgeEntry | undefined;

package/node_modules/@raggle-ai/local/dist/core/personal-relations.js

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.personalRelationsSchemaVersion = void 0;
+exports.emptyPersonalRelations = emptyPersonalRelations;
+exports.readPersonalRelations = readPersonalRelations;
+exports.writePersonalRelations = writePersonalRelations;
+exports.resolveSourceIdentity = resolveSourceIdentity;
+exports.resolveTargetRepository = resolveTargetRepository;
+exports.resolveStoredTargetWorktree = resolveStoredTargetWorktree;
+exports.setPersonalReason = setPersonalReason;
+exports.setPersonalEdge = setPersonalEdge;
+exports.personalReason = personalReason;
+exports.personalEdge = personalEdge;
+const node_fs_1 = require("node:fs");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const git_repository_1 = require("../adapters/git-repository");
+const user_settings_1 = require("../adapters/user-settings");
+const scanner_1 = require("../discovery/scanner");
+const user_projects_1 = require("./user-projects");
+exports.personalRelationsSchemaVersion = 1;
+function canonicalPath(filePath) {
+    try {
+        return (0, node_fs_1.realpathSync)(filePath);
+    }
+    catch {
+        return node_path_1.default.resolve(filePath);
+    }
+}
+function emptyPersonalRelations() {
+    return { schemaVersion: 1, reasons: {}, edges: {} };
+}
+function readPersonalRelations() {
+    return (0, user_settings_1.readRaggleUserSettings)().personalRelations ?? emptyPersonalRelations();
+}
+function writePersonalRelations(store) {
+    (0, user_settings_1.writeRaggleUserSettings)({ ...(0, user_settings_1.readRaggleUserSettings)(), personalRelations: store });
+}
+/** Resolves the `--folder` source project using its repository identity when available. */
+function resolveSourceIdentity(folder) {
+    if (!(0, node_fs_1.statSync)(folder, { throwIfNoEntry: false })?.isDirectory()) {
+        throw new Error(`Folder does not exist: ${folder}`);
+    }
+    const discovered = (0, scanner_1.discoverRepository)(folder);
+    if (discovered) {
+        const repository = (0, git_repository_1.canonicalRepositoryIdentity)(discovered.remoteUrl)?.repository;
+        return {
+            identity: repository ?? discovered.worktree,
+            worktree: discovered.worktree,
+            ...(repository ? { repository } : {}),
+        };
+    }
+    const worktree = canonicalPath(folder);
+    return { identity: worktree, worktree };
+}
+/** Resolves a relation target (path, owner/repo, or URL) to a portable identity and optional worktree. */
+async function resolveTargetRepository(target) {
+    const expanded = target === "~" ? node_os_1.default.homedir() : target.startsWith("~/") ? node_path_1.default.join(node_os_1.default.homedir(), target.slice(2)) : target;
+    const resolved = node_path_1.default.resolve(expanded);
+    const existing = (0, node_fs_1.statSync)(resolved, { throwIfNoEntry: false });
+    if (existing?.isDirectory()) {
+        const discovered = (0, scanner_1.discoverRepository)(resolved);
+        if (discovered) {
+            const repository = (0, git_repository_1.canonicalRepositoryIdentity)(discovered.remoteUrl)?.repository;
+            return {
+                identity: repository ?? discovered.worktree,
+                worktree: discovered.worktree,
+                ...(repository ? { repository } : {}),
+            };
+        }
+        const worktree = canonicalPath(resolved);
+        return { identity: worktree, worktree };
+    }
+    if (node_path_1.default.isAbsolute(target) || target.startsWith(".") || target.startsWith("~")) {
+        throw new Error(`Cannot resolve relation target: ${target}`);
+    }
+    const identity = (0, git_repository_1.canonicalRepositoryIdentity)(target);
+    if (!identity)
+        throw new Error(`Cannot resolve relation target: ${target}`);
+    const worktree = await resolveStoredTargetWorktree(identity.repository);
+    return { identity: identity.repository, repository: identity.repository, ...(worktree ? { worktree } : {}) };
+}
+/** Locates a stored target identity on disk using repository locations or the user project catalog. */
+async function resolveStoredTargetWorktree(targetIdentity) {
+    if (node_path_1.default.isAbsolute(targetIdentity) && (0, node_fs_1.statSync)(targetIdentity, { throwIfNoEntry: false })?.isDirectory()) {
+        return canonicalPath(targetIdentity);
+    }
+    const key = (0, git_repository_1.repositoryLocationKey)(targetIdentity);
+    if (!key)
+        return undefined;
+    const settings = (0, user_settings_1.readRaggleUserSettings)();
+    const preferredWorktree = settings.repositoryLocations?.[key]?.preferredWorktree;
+    if (preferredWorktree && (0, node_fs_1.statSync)(preferredWorktree, { throwIfNoEntry: false })?.isDirectory()) {
+        return canonicalPath(preferredWorktree);
+    }
+    const projects = await (0, user_projects_1.loadUserProjects)();
+    const project = projects.find((candidate) => candidate.remoteUrl && (0, git_repository_1.repositoryLocationKey)(candidate.remoteUrl) === key);
+    return project ? canonicalPath(project.worktree) : undefined;
+}
+function setPersonalReason(store, source, target, text) {
+    const normalized = text.trim();
+    const current = store.reasons[source]?.[target]?.text;
+    if (current === normalized)
+        return { store, changed: false };
+    const targets = { ...(store.reasons[source] ?? {}) };
+    targets[target] = { text: normalized };
+    const reasons = { ...store.reasons, [source]: targets };
+    return { store: { schemaVersion: 1, reasons, edges: store.edges }, changed: true };
+}
+function setPersonalEdge(store, source, target, type, text) {
+    const normalized = text.trim();
+    const current = store.edges[source]?.[target];
+    if (current && current.type === type && current.text === normalized)
+        return { store, changed: false };
+    const targets = { ...(store.edges[source] ?? {}) };
+    targets[target] = { type, text: normalized };
+    const edges = { ...store.edges, [source]: targets };
+    return { store: { schemaVersion: 1, reasons: store.reasons, edges }, changed: true };
+}
+function personalReason(store, source, target) {
+    return store.reasons[source]?.[target]?.text;
+}
+function personalEdge(store, source, target) {
+    return store.edges[source]?.[target];
+}

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

@@ -0,0 +1,2 @@
+import type { ProjectActionConfig } from "./project-actions";
+export declare function projectActionConfigFromSource(sourceText: string): ProjectActionConfig | undefined;