kennel 0.1.9 → 0.2.0

package/node_modules/@raggle-ai/local/dist/adapters/project-feed.js

@@ -0,0 +1,141 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hydrateProjectActivity = hydrateProjectActivity;
+exports.listLocalProjectFeed = listLocalProjectFeed;
+const node_child_process_1 = require("node:child_process");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const node_util_1 = require("node:util");
+const native_bridge_1 = require("../native-bridge");
+const native_bridge_2 = require("../native-bridge");
+const catalog_project_1 = require("../core/catalog-project");
+const scanner_1 = require("../discovery/scanner");
+const project_feed_assets_1 = require("./project-feed-assets");
+const user_settings_1 = require("./user-settings");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+const activityBatchSize = 12;
+function projectPathspec(project) {
+    return project.relativePath?.trim() || ".";
+}
+async function gitOutput(repositoryRoot, args) {
+    try {
+        const { stdout } = await execFileAsync("git", args, {
+            cwd: repositoryRoot,
+            encoding: "utf8",
+            maxBuffer: 4 * 1024 * 1024,
+        });
+        return stdout;
+    }
+    catch {
+        return "";
+    }
+}
+async function modifiedAt(repositoryRoot, relativePath) {
+    let candidate = node_path_1.default.resolve(repositoryRoot, relativePath);
+    const root = node_path_1.default.resolve(repositoryRoot);
+    while (candidate === root || candidate.startsWith(`${root}${node_path_1.default.sep}`)) {
+        try {
+            return (await (0, promises_1.stat)(candidate)).mtimeMs;
+        }
+        catch {
+            if (candidate === root)
+                return undefined;
+            candidate = node_path_1.default.dirname(candidate);
+        }
+    }
+    return undefined;
+}
+async function gitActivity(project) {
+    if (!project.isCloned)
+        return {};
+    const pathspec = projectPathspec(project);
+    const [commitOutput, unstagedOutput, stagedOutput, untrackedOutput] = await Promise.all([
+        gitOutput(project.repositoryRoot, ["log", "-1", "--format=%ct", "--", pathspec]),
+        gitOutput(project.repositoryRoot, ["diff", "--name-only", "-z", "--", pathspec]),
+        gitOutput(project.repositoryRoot, ["diff", "--cached", "--name-only", "-z", "--", pathspec]),
+        gitOutput(project.repositoryRoot, ["ls-files", "--others", "--exclude-standard", "-z", "--", pathspec]),
+    ]);
+    const commitSeconds = Number(commitOutput.trim());
+    const lastCommitAt = Number.isFinite(commitSeconds) && commitSeconds > 0 ? commitSeconds * 1_000 : undefined;
+    const changedPaths = [unstagedOutput, stagedOutput, untrackedOutput]
+        .flatMap((output) => output.split("\0"))
+        .filter(Boolean);
+    const editTimestamps = await Promise.all(changedPaths.map((changedPath) => modifiedAt(project.repositoryRoot, changedPath)));
+    const localEditAt = editTimestamps
+        .filter((timestamp) => timestamp !== undefined)
+        .sort((a, b) => b - a)[0];
+    return { lastCommitAt, localEditAt };
+}
+async function hydrateProjectActivity(projects, additionalActivityByWorktree) {
+    const items = new Array(projects.length);
+    for (let start = 0; start < projects.length; start += activityBatchSize) {
+        await Promise.all(projects.slice(start, start + activityBatchSize).map(async (project, batchIndex) => {
+            const activity = await gitActivity(project);
+            const item = {
+                ...project,
+                ...activity,
+                activityAt: additionalActivityByWorktree?.get(project.worktree),
+            };
+            item.activityAt = (0, native_bridge_1.projectActivityTimestamp)(item);
+            items[start + batchIndex] = item;
+        }));
+    }
+    return items;
+}
+/** Lists projects and deduplicated mobile-safe icon assets from this machine. */
+async function listLocalProjectFeed(options) {
+    const { orderBy = "name", limit, includeIcons, addEmojis, includeActivity = true, includeNestedProjects = true, iconItemLimit, maxIconBytes, additionalActivityByWorktree, cloneDirectory, includeFolderRoot = false, scan, } = options;
+    const folder = cloneDirectory ?? process.cwd();
+    const rootIsRepository = includeFolderRoot && (0, scanner_1.discoverRepository)(folder) !== undefined;
+    const [folderProjects, rootProjects] = await Promise.all([
+        (0, native_bridge_2.discoverProjectsUnderFolder)({
+            folder,
+            scanMaxRepos: scan?.maxRepos,
+            scanTimeoutMs: scan?.timeoutMs,
+        }),
+        rootIsRepository ? (0, native_bridge_2.buildProjectCatalog)({ projectRoots: [folder], schemaScanRoots: [folder] }) : [],
+    ]);
+    const catalogProjects = [
+        ...new Map([...rootProjects, ...folderProjects].map((project) => [project.worktree, project])).values(),
+    ];
+    const discoveredProjects = (0, native_bridge_1.applyProjectFavorites)(catalogProjects.map(catalog_project_1.catalogProjectToLocalProject), (0, user_settings_1.readRaggleUserSettings)().favoriteProjects);
+    const projects = includeNestedProjects
+        ? discoveredProjects
+        : discoveredProjects.filter((project) => !project.relativePath);
+    const displayProjects = projects.map((project) => ({ ...project, name: (0, project_feed_assets_1.projectFeedName)(project) }));
+    const activityProjects = includeActivity
+        ? await hydrateProjectActivity(displayProjects, additionalActivityByWorktree)
+        : displayProjects;
+    const ordered = (0, native_bridge_1.sortProjectList)(activityProjects, orderBy);
+    const selected = limit === undefined ? ordered : ordered.slice(0, Math.max(0, limit));
+    const { presentations, assets } = await (0, project_feed_assets_1.buildProjectFeedPresentation)(selected, {
+        includeIcons,
+        addEmojis,
+        iconItemLimit,
+        maxIconBytes,
+    });
+    return {
+        schemaVersion: 2,
+        items: selected.map((project, index) => ({
+            id: project.id,
+            worktree: project.worktree,
+            description: project.description,
+            keywords: project.keywords,
+            relativePath: project.relativePath,
+            isFavorite: project.isFavorite,
+            relatedProjectIDs: project.relatedIds,
+            searchPriority: project.searchPriority,
+            remoteUrl: project.remoteUrl,
+            relatedRepositories: project.relatedRepositories,
+            relatedOrganisations: project.relatedOrganisations,
+            lastCommitAt: project.lastCommitAt,
+            localEditAt: project.localEditAt,
+            activityAt: project.activityAt,
+            ...presentations[index],
+        })),
+        assets,
+    };
+}

package/node_modules/@raggle-ai/local/dist/adapters/project-icons.d.ts

@@ -0,0 +1,3 @@
+import type { LocalProject } from "../core/types";
+export { discoverFolderIcon, discoverProjectIcon, projectIconExtensions } from "../folder-metadata/icons";
+export declare function projectRemoteUrlForIcon(project: Pick<LocalProject, "remoteMismatch" | "remoteUrl" | "relatedIds">): string;

package/node_modules/@raggle-ai/local/dist/adapters/project-icons.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectIconExtensions = exports.discoverProjectIcon = exports.discoverFolderIcon = void 0;
+exports.projectRemoteUrlForIcon = projectRemoteUrlForIcon;
+// Preserve the existing public exports while discovery lives in folder-metadata.
+var icons_1 = require("../folder-metadata/icons");
+Object.defineProperty(exports, "discoverFolderIcon", { enumerable: true, get: function () { return icons_1.discoverFolderIcon; } });
+Object.defineProperty(exports, "discoverProjectIcon", { enumerable: true, get: function () { return icons_1.discoverProjectIcon; } });
+Object.defineProperty(exports, "projectIconExtensions", { enumerable: true, get: function () { return icons_1.projectIconExtensions; } });
+function projectRemoteUrlForIcon(project) {
+    return (project.remoteMismatch?.actualRemoteUrl ??
+        project.remoteUrl ??
+        project.relatedIds.find((id) => id.includes("github.com")));
+}

package/node_modules/@raggle-ai/local/dist/adapters/project-recents.d.ts

@@ -0,0 +1,11 @@
+export type ProjectRecentsMutationResult = {
+    schemaVersion: 1;
+    recentProjects: string[];
+    localSettings: {
+        path: string;
+        changed: boolean;
+    };
+};
+export declare function recordRecentProject(worktree: string): ProjectRecentsMutationResult;
+export declare function resetRecentProject(worktree: string): ProjectRecentsMutationResult;
+export declare function replaceRecentProjects(recentProjects: string[]): ProjectRecentsMutationResult;

package/node_modules/@raggle-ai/local/dist/adapters/project-recents.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordRecentProject = recordRecentProject;
+exports.resetRecentProject = resetRecentProject;
+exports.replaceRecentProjects = replaceRecentProjects;
+const user_settings_1 = require("./user-settings");
+const native_bridge_1 = require("../native-bridge");
+function persistRecentProjects(settings, nextRecentProjects) {
+    const normalized = (0, user_settings_1.normalizeRecentProjects)(nextRecentProjects);
+    const changed = normalized.join("\0") !== settings.recentProjects.join("\0");
+    if (changed) {
+        (0, user_settings_1.writeRaggleUserSettings)({
+            ...settings,
+            recentProjects: normalized,
+        });
+    }
+    return {
+        schemaVersion: 1,
+        recentProjects: normalized,
+        localSettings: {
+            path: (0, user_settings_1.raggleUserSettingsPath)(),
+            changed,
+        },
+    };
+}
+function recordRecentProject(worktree) {
+    const settings = (0, user_settings_1.readRaggleUserSettings)();
+    return persistRecentProjects(settings, (0, native_bridge_1.recordRecentSelection)(settings.recentProjects, worktree));
+}
+function resetRecentProject(worktree) {
+    const settings = (0, user_settings_1.readRaggleUserSettings)();
+    return persistRecentProjects(settings, (0, native_bridge_1.resetRecentSelection)(settings.recentProjects, worktree));
+}
+function replaceRecentProjects(recentProjects) {
+    return persistRecentProjects((0, user_settings_1.readRaggleUserSettings)(), recentProjects);
+}

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

@@ -0,0 +1,46 @@
+import { type ImportedRepository, type ImportedRepositoryRow } from "./import";
+import { type AddProjectValues } from "../core/project-add";
+import { type ProjectSourceSettings } from "../core/project-source-settings";
+import type { LocalProject } from "../core/types";
+export type ProjectSourceOptions = ProjectSourceSettings & {
+    projectListFile: string;
+    tursoCachePath: string;
+};
+export declare function projectSourceKey(options: ProjectSourceOptions): string;
+export declare function readProjectSourceRows(options: ProjectSourceOptions): Promise<ImportedRepositoryRow[]>;
+export declare function readCachedProjectSourceRows(options: ProjectSourceOptions): ImportedRepositoryRow[] | undefined;
+export declare function applyProjectSourceActionPlugins(repositories: ImportedRepository[], options: Pick<ProjectSourceOptions, "projectActionsDirectory">): ImportedRepository[];
+export declare function saveNewProject(options: ProjectSourceOptions, values: AddProjectValues): Promise<{
+    row: ImportedRepositoryRow;
+    normalizedUrl: string;
+}>;
+export declare function setProjectSourceFavorite(options: ProjectSourceOptions, project: Pick<LocalProject, "remoteUrl">, favorite: boolean): Promise<{
+    type: "json-file" | "turso";
+    changed: boolean;
+}>;
+export declare function setProjectSourceName(options: ProjectSourceOptions, url: string, name: string): Promise<{
+    type: "json-file" | "turso";
+    changed: boolean;
+}>;
+/** Resolves the CLI project source options from the connected project store (or Turso env vars). */
+export declare function projectSourceOptionsForCli(): ProjectSourceOptions;
+export declare function loadProjectSourceRows(rows: ImportedRepositoryRow[]): {
+    remoteUrl: string;
+    repository: string;
+    name: string | undefined;
+    description: string | undefined;
+    hasCustomName: boolean;
+    tags: string[];
+    subpaths: import("./import").ImportedRepositorySubpath[];
+    allSubpath: boolean;
+    collapseSubpaths: boolean;
+    allTopLevelFolders: boolean;
+    folderDepth: number;
+    folders: string[];
+    clonePathTemplate: string | undefined;
+    plugins: string[];
+    removePathFromName: boolean;
+    searchPriority: number;
+    linkedRepositories: never[];
+    linkedOrganisations: never[];
+}[];

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

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectSourceKey = projectSourceKey;
+exports.readProjectSourceRows = readProjectSourceRows;
+exports.readCachedProjectSourceRows = readCachedProjectSourceRows;
+exports.applyProjectSourceActionPlugins = applyProjectSourceActionPlugins;
+exports.saveNewProject = saveNewProject;
+exports.setProjectSourceFavorite = setProjectSourceFavorite;
+exports.setProjectSourceName = setProjectSourceName;
+exports.projectSourceOptionsForCli = projectSourceOptionsForCli;
+exports.loadProjectSourceRows = loadProjectSourceRows;
+const node_path_1 = __importDefault(require("node:path"));
+const import_1 = require("./import");
+const project_add_1 = require("../core/project-add");
+const git_repository_1 = require("./git-repository");
+const project_action_plugins_1 = require("./project-action-plugins");
+const turso_project_source_1 = require("./turso-project-source");
+const project_source_settings_1 = require("../core/project-source-settings");
+const user_settings_1 = require("./user-settings");
+function tursoSettings(options) {
+    return { ...options, cachePath: options.tursoCachePath };
+}
+function normalizedSubpathPattern(input) {
+    return input
+        .trim()
+        .replace(/^\/+|\/+$/g, "")
+        .split("/")
+        .filter(Boolean)
+        .join("/")
+        .toLowerCase();
+}
+function projectSourceKey(options) {
+    const actionsSuffix = options.projectActionsDirectory?.length
+        ? `:actions:${options.projectActionsDirectory.join(",")}`
+        : "";
+    const ignoredSubpathsSuffix = options.globalIgnoredSubpaths?.length
+        ? `:ignored-subpaths:${options.globalIgnoredSubpaths.map(normalizedSubpathPattern).filter(Boolean).join(",")}`
+        : "";
+    return options.projectSource === "turso"
+        ? `turso:${options.tursoDatabaseUrl ?? "unconfigured"}${actionsSuffix}${ignoredSubpathsSuffix}`
+        : `${options.projectListFile}${actionsSuffix}${ignoredSubpathsSuffix}`;
+}
+function readProjectSourceRows(options) {
+    return options.projectSource === "turso"
+        ? (0, turso_project_source_1.readTursoProjectRows)(tursoSettings(options))
+        : Promise.resolve((0, import_1.readImportedRepositoryRows)(options.projectListFile));
+}
+function readCachedProjectSourceRows(options) {
+    if ((0, project_source_settings_1.needsTursoProjectSourceSetup)(options) || options.projectSource !== "turso")
+        return undefined;
+    return (0, turso_project_source_1.readCachedTursoProjectRows)(tursoSettings(options))?.rows;
+}
+function applyProjectSourceActionPlugins(repositories, options) {
+    return (0, project_action_plugins_1.applyProjectActionPlugins)(repositories, options.projectActionsDirectory ?? []);
+}
+async function saveNewProject(options, values) {
+    const rows = await readProjectSourceRows(options);
+    const newRow = (0, project_add_1.projectRowFromValues)(values);
+    const normalizedUrl = newRow.url;
+    if (rows.some((row) => (0, git_repository_1.normalizeRepositoryUrl)(row.url) === normalizedUrl)) {
+        throw new Error(`Repository ${normalizedUrl} already exists`);
+    }
+    if (options.projectSource === "turso") {
+        await (0, turso_project_source_1.upsertTursoProjectRow)(tursoSettings(options), newRow);
+    }
+    else {
+        (0, import_1.writeImportedRepositoryRows)(options.projectListFile, [...rows, newRow]);
+    }
+    return { row: newRow, normalizedUrl };
+}
+async function setProjectSourceFavorite(options, project, favorite) {
+    if (options.projectSource !== "turso")
+        return { type: "json-file", changed: false };
+    return {
+        type: "turso",
+        changed: await (0, turso_project_source_1.setTursoProjectDeviceFavorite)(tursoSettings(options), project.remoteUrl, favorite),
+    };
+}
+async function setProjectSourceName(options, url, name) {
+    if (options.projectSource !== "turso")
+        return { type: "json-file", changed: false };
+    return { type: "turso", changed: await (0, turso_project_source_1.setTursoProjectName)(tursoSettings(options), url, name) };
+}
+function defaultTursoCachePath() {
+    return node_path_1.default.join(node_path_1.default.dirname((0, user_settings_1.raggleUserSettingsPath)()), "turso-project-rows.json");
+}
+/** Resolves the CLI project source options from the connected project store (or Turso env vars). */
+function projectSourceOptionsForCli() {
+    const userSettings = (0, user_settings_1.readRaggleUserSettings)();
+    const projectStore = userSettings.projectStore;
+    const settings = (0, project_source_settings_1.normalizeProjectSourceSettings)({
+        projectSource: "turso",
+        tursoDatabaseUrl: projectStore?.connection.url ?? process.env.TURSO_DATABASE_URL,
+        tursoAuthToken: projectStore?.connection.authToken ?? process.env.TURSO_AUTH_TOKEN,
+    });
+    return {
+        ...settings,
+        projectListFile: "",
+        tursoCachePath: defaultTursoCachePath(),
+    };
+}
+function loadProjectSourceRows(rows) {
+    return (0, import_1.loadImportedRepositoriesFromRows)(rows);
+}

package/node_modules/@raggle-ai/local/dist/adapters/raggle-account-api.d.ts

@@ -0,0 +1,25 @@
+export type AccountTokenResponse = {
+    accessToken?: unknown;
+    refreshToken?: unknown;
+    organizationId?: unknown;
+    user?: {
+        id?: unknown;
+        email?: unknown;
+        firstName?: unknown;
+        lastName?: unknown;
+    };
+};
+export declare function requestDeviceAuthorization(apiBaseUrl: string): Promise<{
+    deviceCode: string;
+    userCode: string;
+    verificationUri: string;
+    verificationUriComplete: string | undefined;
+    expiresIn: number;
+    interval: number;
+}>;
+export declare function pollForAccountToken(options: {
+    apiBaseUrl: string;
+    deviceCode: string;
+    expiresIn: number;
+    interval: number;
+}): Promise<AccountTokenResponse>;

package/node_modules/@raggle-ai/local/dist/adapters/raggle-account-api.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestDeviceAuthorization = requestDeviceAuthorization;
+exports.pollForAccountToken = pollForAccountToken;
+function assertString(value, field) {
+    if (typeof value !== "string" || !value.trim())
+        throw new Error(`Raggle API response is missing ${field}.`);
+    return value;
+}
+async function postJson(url, body) {
+    const response = await fetch(url, {
+        method: "POST",
+        headers: { Accept: "application/json", ...(body ? { "Content-Type": "application/json" } : {}) },
+        ...(body ? { body: JSON.stringify(body) } : {}),
+    });
+    const data = (await response.json().catch(() => ({})));
+    return { response, data };
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function requestDeviceAuthorization(apiBaseUrl) {
+    const { response, data } = await postJson(`${apiBaseUrl}/auth/device/start`);
+    if (!response.ok)
+        throw new Error(`Raggle API device authorization failed with HTTP ${response.status}.`);
+    const authorization = data;
+    return {
+        deviceCode: assertString(authorization.deviceCode, "deviceCode"),
+        userCode: assertString(authorization.userCode, "userCode"),
+        verificationUri: assertString(authorization.verificationUri, "verificationUri"),
+        verificationUriComplete: typeof authorization.verificationUriComplete === "string" ? authorization.verificationUriComplete : undefined,
+        expiresIn: typeof authorization.expiresIn === "number" ? authorization.expiresIn : 300,
+        interval: typeof authorization.interval === "number" ? authorization.interval : 5,
+    };
+}
+async function pollForAccountToken(options) {
+    const expiresAt = Date.now() + options.expiresIn * 1000;
+    let interval = Math.max(1, options.interval);
+    while (Date.now() < expiresAt) {
+        const { response, data } = await postJson(`${options.apiBaseUrl}/auth/device/token`, {
+            deviceCode: options.deviceCode,
+        });
+        if (response.ok)
+            return data;
+        const error = typeof data.error === "string" ? data.error : undefined;
+        if (error === "authorization_pending") {
+            await sleep(interval * 1000);
+            continue;
+        }
+        if (error === "slow_down") {
+            interval += 1;
+            await sleep(interval * 1000);
+            continue;
+        }
+        if (error === "access_denied")
+            throw new Error("Authorization was denied.");
+        if (error === "expired_token")
+            throw new Error("Authorization expired.");
+        throw new Error(`Raggle API token polling failed with HTTP ${response.status}.`);
+    }
+    throw new Error("Authorization timed out.");
+}

package/node_modules/@raggle-ai/local/dist/adapters/relation-annotations-api.d.ts

@@ -0,0 +1,72 @@
+export declare const DEFAULT_RELATIONS_API_BASE_URL = "https://otelapi.raggle.co";
+export declare const RELATIONS_API_TOKEN_ENV = "RAGGLE_RELATIONS_API_TOKEN";
+export declare const RELATIONS_API_BASE_URL_ENV = "RAGGLE_RELATIONS_API_BASE_URL";
+export declare const listRelationAnnotationsPath = "/v1/relation-annotations";
+export declare const postRelationAnnotationPath = "/v1/relation-annotations";
+export declare const updateRelationAnnotationPath = "/v1/relation-annotations/{id}";
+export declare const delRelationAnnotationPath = "/v1/relation-annotations/{id}";
+export declare const relationAnnotationTypes: readonly ["notes", "implementation", "dependency"];
+export type RelationAnnotationType = (typeof relationAnnotationTypes)[number];
+export declare const relationAnnotationDirections: readonly ["incoming", "outgoing"];
+export type RelationAnnotationDirection = (typeof relationAnnotationDirections)[number];
+export declare const relationAnnotationEdgeOrigins: readonly ["core", "personal"];
+export type RelationAnnotationEdgeOrigin = (typeof relationAnnotationEdgeOrigins)[number];
+export declare const relationAnnotationFieldNames: readonly ["id", "ownerUserId", "organizationId", "sourceProjectId", "targetId", "direction", "relationType", "edgeOrigin", "reason", "createdAt", "updatedAt"];
+export declare const createRelationAnnotationRequestFields: readonly ["sourceProjectId", "targetId", "direction", "relationType", "edgeOrigin", "reason"];
+export declare const updateRelationAnnotationRequestFields: readonly ["reason", "direction", "relationType", "edgeOrigin"];
+export interface RepositoryRelationAnnotation {
+    readonly id: string;
+    readonly ownerUserId: string;
+    readonly organizationId: string | null;
+    readonly sourceProjectId: string;
+    readonly targetId: string;
+    readonly direction: RelationAnnotationDirection;
+    readonly relationType: RelationAnnotationType;
+    readonly edgeOrigin: RelationAnnotationEdgeOrigin;
+    readonly reason: string;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}
+export interface RepositoryRelationAnnotationListResponse {
+    readonly annotations: RepositoryRelationAnnotation[];
+}
+export interface RepositoryRelationAnnotationResponse {
+    readonly annotation: RepositoryRelationAnnotation;
+}
+export interface CreateRepositoryRelationAnnotationRequest {
+    readonly sourceProjectId: string;
+    readonly targetId: string;
+    readonly direction: RelationAnnotationDirection;
+    readonly relationType: RelationAnnotationType;
+    readonly edgeOrigin: RelationAnnotationEdgeOrigin;
+    readonly reason: string;
+}
+export interface UpdateRepositoryRelationAnnotationRequest {
+    readonly reason?: string;
+    readonly direction?: RelationAnnotationDirection;
+    readonly relationType?: RelationAnnotationType;
+    readonly edgeOrigin?: RelationAnnotationEdgeOrigin;
+}
+export interface RelationsApiClientOptions {
+    readonly baseUrl: string;
+    readonly apiToken: string;
+    readonly fetchImpl?: typeof fetch;
+    readonly timeoutSeconds?: number;
+}
+export interface RelationsApiCredentials {
+    readonly baseUrl: string;
+    readonly token?: string;
+}
+export declare class RelationsApiError extends Error {
+    readonly status: number;
+    readonly code?: string | undefined;
+    constructor(message: string, status: number, code?: string | undefined);
+}
+/** Reads sync credentials from the environment. The token never touches disk. */
+export declare function readRelationsApiCredentials(options?: {
+    baseUrl?: string;
+}): RelationsApiCredentials;
+export declare function listRelationAnnotations(client: RelationsApiClientOptions): Promise<RepositoryRelationAnnotation[]>;
+export declare function createRelationAnnotation(client: RelationsApiClientOptions, body: CreateRepositoryRelationAnnotationRequest): Promise<RepositoryRelationAnnotation>;
+export declare function updateRelationAnnotation(client: RelationsApiClientOptions, id: string, body: UpdateRepositoryRelationAnnotationRequest): Promise<RepositoryRelationAnnotation>;
+export declare function deleteRelationAnnotation(client: RelationsApiClientOptions, id: string): Promise<void>;