orbitmap 0.3.0 → 0.4.1

package/dist/agent-instructions.js.map

@@ -1 +1 @@
-{"version":3,"file":"agent-instructions.js","sourceRoot":"","sources":["../src/agent-instructions.ts"],"names":[],"mappings":"AAAA,yEAAyE;AACzE,EAAE;AACF,2DAA2D;AAC3D,oFAAoF;AACpF,oFAAoF;AACpF,oFAAoF;AACpF,+EAA+E;AAC/E,iFAAiF;AACjF,mFAAmF;AACnF,0EAA0E;AAC1E,wFAAwF;AACxF,uFAAuF;AACvF,gFAAgF;AAChF,gFAAgF;AAChF,EAAE;AACF,uCAAuC;AACvC,oFAAoF;AAEpF,MAAM,CAAC,MAAM,UAAU,GAAG,UAAU,CAAC;AAErC,MAAM,CAAC,MAAM,YAAY,GAAG,yBAAyB,CAAC;AACtD,MAAM,CAAC,MAAM,UAAU,GAAG,uBAAuB,CAAC;AAElD,mFAAmF;AACnF,+EAA+E;AAC/E,0CAA0C;AAC1C,MAAM,CAAC,MAAM,iBAAiB,GAC5B,0EAA0E;IAC1E,6EAA6E;IAC7E,iFAAiF;IACjF,4EAA4E;IAC5E,wEAAwE;IACxE,8EAA8E;IAC9E,kBAAkB,CAAC;AAErB,gFAAgF;AAEhF,MAAM,CAAC,MAAM,iBAAiB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4EAwN2C,CAAC;AAE7E,wDAAwD;AAExD,mFAAmF;AACnF,MAAM,CAAC,MAAM,gBAAgB,GAAG;;;;;;;;sGAQsE,CAAC;AAEvG,2FAA2F;AAC3F,MAAM,CAAC,MAAM,iBAAiB,GAAG;;;;;;;;8DAQ6B,CAAC;AAE/D,yBAAyB;AAEzB,oEAAoE;AACpE,MAAM,UAAU,cAAc;IAC5B,OAAO,cAAc,UAAU,kBAAkB,iBAAiB,YAAY,iBAAiB,IAAI,CAAC;AACtG,CAAC;AAED,2EAA2E;AAC3E,MAAM,UAAU,eAAe;IAC7B,OAAO,GAAG,YAAY,KAAK,gBAAgB,KAAK,UAAU,EAAE,CAAC;AAC/D,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,iBAAiB;IAC/B,OAAO,GAAG,YAAY,KAAK,iBAAiB,OAAO,iBAAiB,KAAK,UAAU,EAAE,CAAC;AACxF,CAAC"}
+{"version":3,"file":"agent-instructions.js","sourceRoot":"","sources":["../src/agent-instructions.ts"],"names":[],"mappings":"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"}

package/dist/api-client.d.ts

@@ -1,239 +1,8 @@
-export declare class OrbitMapClient {
-    private readonly apiKey;
-    private readonly baseUrl;
-    private readonly projectId?;
-    constructor(apiKey: string, projectId?: string, apiUrl?: string);
-    private request;
-    getContext(projectId?: string): Promise<unknown>;
-    getTasks(options?: {
-        status?: string;
-        priority?: string;
-        projectId?: string;
-        orbit?: string;
-    }): Promise<unknown>;
-    getTask(taskId: string): Promise<unknown>;
-    getTaskByNumber(taskNumber: string): Promise<unknown>;
-    startTask(taskId?: string): Promise<unknown>;
-    updateTaskStatus(taskId: string, status?: string, deliveryStatus?: string | null): Promise<unknown>;
-    createSubtasks(parentId: string, subtasks: Array<{
-        title: string;
-        description?: string;
-        priority?: string;
-        estimated_effort?: string;
-    }>): Promise<unknown>;
-    createTask(data: {
-        title: string;
-        description?: string;
-        status?: string;
-        priority?: string;
-        agent_instructions?: string;
-        branch_name?: string;
-        estimated_effort?: string;
-        agent_id?: string;
-        project_id?: string;
-        source_issue_id?: string;
-    }): Promise<unknown>;
-    assignTask(taskId: string, assignment: {
-        agent_id: string;
-    } | {
-        user_id: number;
-    }): Promise<unknown>;
-    editTaskContent(taskId: string, data: {
-        title?: string;
-        description?: string;
-        agent_instructions?: string;
-    }): Promise<unknown>;
-    addTaskDependency(taskId: string, data: {
-        target_task_id: string;
-        type?: string;
-        note?: string;
-    }): Promise<unknown>;
-    removeTaskDependency(taskId: string, targetTaskId: string, type?: string): Promise<unknown>;
-    logWork(taskId: string, type: string, content: string, metadata?: Record<string, unknown>): Promise<unknown>;
-    getDocuments(options?: {
-        type?: string;
-        search?: string;
-        projectId?: string;
-    }): Promise<unknown>;
-    getDocument(idOrSlug: string, mode?: 'inline' | 'file', options?: {
-        full?: boolean;
-        section?: string;
-    }): Promise<unknown>;
-    importDocument(data: {
-        title: string;
-        type: string;
-        content: string;
-        source_path?: string;
-        context?: string;
-        workspace_id?: string;
-    }): Promise<unknown>;
-    updateDocument(idOrSlug: string, content: string, changelog?: string): Promise<unknown>;
-    patchDocument(idOrSlug: string, operations: Array<Record<string, unknown>>, baseVersion: number, changelog?: string): Promise<unknown>;
-    requestUploadUrl(data: {
-        title: string;
-        type: string;
-        filename?: string;
-        source_path?: string;
-        context?: string;
-        workspace_id?: string;
-    }): Promise<{
-        data: {
-            upload_id: string;
-            document_id: string;
-            presigned_url: string;
-            storage_path: string;
-            expires_at: string;
-        };
-    }>;
-    confirmUpload(uploadId: string): Promise<{
-        data: {
-            document_id: string;
-            slug: string;
-            imported: boolean;
-        };
-    }>;
-    requestUpdateUploadUrl(idOrSlug: string, changelog?: string): Promise<{
-        data: {
-            upload_id: string;
-            document_id: string;
-            version: number;
-            presigned_url: string;
-            storage_path: string;
-            expires_at: string;
-        };
-    }>;
-    confirmUpdateUpload(idOrSlug: string, uploadId: string): Promise<{
-        data: {
-            document_id: string;
-            version: number;
-            updated: boolean;
-        };
-    }>;
-    uploadToPresignedUrl(presignedUrl: string, filePath: string, onProgress?: (bytesUploaded: number, totalBytes: number) => void): Promise<void>;
-    /**
-     * Attempts presigned URL upload for a new document.
-     * Returns null if the endpoint is not available (404), signaling caller to fall back.
-     */
-    presignedImport(filePath: string, data: {
-        title: string;
-        type: string;
-        source_path?: string;
-        context?: string;
-        workspace_id?: string;
-    }, onProgress?: (bytesUploaded: number, totalBytes: number) => void): Promise<{
-        data: {
-            document_id: string;
-            slug: string;
-            imported: boolean;
-        };
-        upload_method: string;
-    } | null>;
-    /**
-     * Attempts presigned URL upload for updating a document.
-     * Returns null if the endpoint is not available (404), signaling caller to fall back.
-     */
-    presignedUpdate(idOrSlug: string, filePath: string, changelog?: string, onProgress?: (bytesUploaded: number, totalBytes: number) => void): Promise<{
-        data: {
-            document_id: string;
-            version: number;
-            updated: boolean;
-        };
-        upload_method: string;
-    } | null>;
-    shareDocument(documentId: string, projectId: string, agentIds?: string[]): Promise<unknown>;
-    unshareDocument(documentId: string, projectId: string): Promise<unknown>;
-    setDocumentVisibility(documentId: string, projectId: string, agentIds: string[]): Promise<unknown>;
-    getProjects(): Promise<unknown>;
-    getProjectMembers(projectId: string): Promise<unknown>;
-    getProjectOverview(projectId: string): Promise<unknown>;
-    createProject(data: {
-        name: string;
-        description?: string;
-        slug?: string;
-    }): Promise<unknown>;
-    registerIssue(data: {
-        title: string;
-        description: string;
-        severity?: string;
-        related_task_id?: string;
-    }): Promise<unknown>;
-    listIssues(options?: {
-        status?: string;
-        severity?: string;
-        limit?: string;
-    }): Promise<unknown>;
-    getIssue(idOrNumber: string): Promise<unknown>;
-    getIssueByNumber(issueNumber: string): Promise<unknown>;
-    resolveIssueByNumber(issueNumber: string, data: {
-        status: string;
-        resolution?: string;
-        resolved_by_task_id?: string;
-    }): Promise<unknown>;
-    resolveIssue(idOrNumber: string, data: {
-        status: string;
-        resolution?: string;
-        resolved_by_task_id?: string;
-    }): Promise<unknown>;
-    updateIssueStatus(idOrNumber: string, data: {
-        status: string;
-        resolution?: string;
-        resolved_task_id?: string;
-    }): Promise<unknown>;
-    updateIssueStatusByNumber(issueNumber: string, data: {
-        status: string;
-        resolution?: string;
-        resolved_task_id?: string;
-    }): Promise<unknown>;
-    logVibe(data: {
-        content: string;
-        type: string;
-        title?: string;
-        task_id?: string;
-    }): Promise<unknown>;
-    listVibes(options?: {
-        type?: string;
-        since?: string;
-        limit?: string;
-    }): Promise<unknown>;
-    getVibe(id: string): Promise<unknown>;
-    updateVibe(id: string, data: {
-        type?: string;
-        title?: string;
-        content?: string;
-        metadata?: Record<string, unknown>;
-    }): Promise<unknown>;
-    listIdeas(options?: {
-        status?: string;
-        priority?: string;
-        limit?: string;
-    }): Promise<unknown>;
-    getIdea(idOrNumber: string): Promise<unknown>;
-    getIdeaByNumber(ideaNumber: string): Promise<unknown>;
-    createIdea(data: {
-        content: string;
-        title?: string;
-        priority?: string;
-        metadata?: Record<string, unknown>;
-    }): Promise<unknown>;
-    updateIdeaStatus(idOrNumber: string, data: {
-        status: string;
-    }): Promise<unknown>;
-    updateIdeaStatusByNumber(ideaNumber: string, data: {
-        status: string;
-    }): Promise<unknown>;
-    getOrbitItems(orbitIdOrSlug: string, options?: {
-        type?: string;
-    }): Promise<unknown>;
-    orbitAttach(orbitIdOrSlug: string, data: {
-        item_type: string;
-        item_id: string;
-        note?: string;
-    }): Promise<unknown>;
-    orbitDetach(orbitIdOrSlug: string, data: {
-        item_type: string;
-        item_id: string;
-    }): Promise<unknown>;
-    getWorkPrompt(): Promise<unknown>;
-    getImportDocsPrompt(): Promise<unknown>;
-}
-export declare function createClient(explicitProjectId?: string): Promise<OrbitMapClient>;
+/**
+ * Compatibility shim.
+ *
+ * The API client now lives in `src/adapters/cloud.ts` as `CloudAdapter`
+ * (re-exported here under its historical name `OrbitMapClient`). New code
+ * should import `createAdapter` from `./adapters/factory.js` instead.
+ */
+export * from './adapters/cloud.js';

package/dist/api-client.js

@@ -1,404 +1,9 @@
-import { createReadStream, statSync } from 'node:fs';
-import { basename, extname } from 'node:path';
-import { OrbitMapAPIError } from './errors.js';
-import { resolveAuth } from './config.js';
-export class OrbitMapClient {
-    apiKey;
-    baseUrl;
-    projectId;
-    constructor(apiKey, projectId, apiUrl) {
-        this.apiKey = apiKey;
-        this.projectId = projectId;
-        this.baseUrl = (apiUrl ?? 'https://orbitmap.app/api/agent').replace(/\/$/, '');
-    }
-    async request(method, path, options) {
-        const url = new URL(`${this.baseUrl}${path}`);
-        if (options?.params) {
-            for (const [key, value] of Object.entries(options.params)) {
-                if (value !== undefined) {
-                    url.searchParams.set(key, value);
-                }
-            }
-        }
-        const headers = {
-            Authorization: `Bearer ${this.apiKey}`,
-            Accept: 'application/json',
-        };
-        if (this.projectId) {
-            headers['X-OrbitMap-Project'] = this.projectId;
-        }
-        if (options?.body !== undefined) {
-            headers['Content-Type'] = 'application/json';
-        }
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), 30_000);
-        try {
-            const response = await fetch(url.toString(), {
-                method,
-                headers,
-                body: options?.body !== undefined ? JSON.stringify(options.body) : undefined,
-                signal: controller.signal,
-            });
-            // Handle 204 No Content — no body to parse
-            if (response.status === 204) {
-                return undefined;
-            }
-            const text = await response.text();
-            let json;
-            try {
-                json = JSON.parse(text);
-            }
-            catch {
-                if (!response.ok) {
-                    throw new OrbitMapAPIError(`HTTP ${response.status}: ${text}`, 'HTTP_ERROR', response.status);
-                }
-                throw new OrbitMapAPIError('Invalid JSON response from API', 'PARSE_ERROR', response.status);
-            }
-            if (!response.ok) {
-                if (OrbitMapAPIError.isApiErrorBody(json)) {
-                    throw OrbitMapAPIError.fromResponse(json);
-                }
-                throw new OrbitMapAPIError(`HTTP ${response.status}`, 'HTTP_ERROR', response.status);
-            }
-            return json;
-        }
-        catch (error) {
-            if (error instanceof OrbitMapAPIError)
-                throw error;
-            if (error instanceof DOMException && error.name === 'AbortError') {
-                throw new OrbitMapAPIError('Request timed out after 30s', 'TIMEOUT', 0);
-            }
-            throw error;
-        }
-        finally {
-            clearTimeout(timeout);
-        }
-    }
-    // ── Context ──
-    async getContext(projectId) {
-        return this.request('GET', '/context', {
-            params: { project_id: projectId },
-        });
-    }
-    // ── Tasks ──
-    async getTasks(options) {
-        return this.request('GET', '/tasks', {
-            params: {
-                status: options?.status,
-                priority: options?.priority,
-                project_id: options?.projectId,
-                orbit_id: options?.orbit,
-            },
-        });
-    }
-    async getTask(taskId) {
-        return this.request('GET', `/tasks/${taskId}`);
-    }
-    async getTaskByNumber(taskNumber) {
-        return this.request('GET', `/tasks/by-number/${taskNumber}`);
-    }
-    async startTask(taskId) {
-        if (taskId) {
-            return this.request('POST', `/tasks/${taskId}/start`);
-        }
-        return this.request('POST', '/tasks/start');
-    }
-    async updateTaskStatus(taskId, status, deliveryStatus) {
-        const body = {};
-        if (status !== undefined)
-            body.status = status;
-        if (deliveryStatus !== undefined)
-            body.delivery_status = deliveryStatus;
-        return this.request('PATCH', `/tasks/${taskId}/status`, { body });
-    }
-    async createSubtasks(parentId, subtasks) {
-        return this.request('POST', `/tasks/${parentId}/subtasks`, {
-            body: { subtasks },
-        });
-    }
-    async createTask(data) {
-        return this.request('POST', '/tasks', { body: data });
-    }
-    async assignTask(taskId, assignment) {
-        return this.request('PATCH', `/tasks/${taskId}/assign`, {
-            body: assignment,
-        });
-    }
-    async editTaskContent(taskId, data) {
-        return this.request('PATCH', `/tasks/${taskId}/content`, {
-            body: data,
-        });
-    }
-    // ── Task Dependencies ──
-    async addTaskDependency(taskId, data) {
-        return this.request('POST', `/tasks/${taskId}/dependencies`, { body: data });
-    }
-    async removeTaskDependency(taskId, targetTaskId, type) {
-        return this.request('DELETE', `/tasks/${taskId}/dependencies/${targetTaskId}`, {
-            params: { type },
-        });
-    }
-    // ── Logs ──
-    async logWork(taskId, type, content, metadata) {
-        return this.request('POST', `/tasks/${taskId}/logs`, {
-            body: { type, content, metadata },
-        });
-    }
-    // ── Documents ──
-    async getDocuments(options) {
-        return this.request('GET', '/documents', {
-            params: {
-                type: options?.type,
-                search: options?.search,
-                project_id: options?.projectId,
-            },
-        });
-    }
-    async getDocument(idOrSlug, mode, options) {
-        return this.request('GET', `/documents/${idOrSlug}`, {
-            params: {
-                mode,
-                full: options?.full ? 'true' : undefined,
-                section: options?.section,
-            },
-        });
-    }
-    async importDocument(data) {
-        return this.request('POST', '/documents', { body: data });
-    }
-    async updateDocument(idOrSlug, content, changelog) {
-        return this.request('PUT', `/documents/${idOrSlug}`, {
-            body: { content, changelog },
-        });
-    }
-    async patchDocument(idOrSlug, operations, baseVersion, changelog) {
-        return this.request('PATCH', `/documents/${idOrSlug}`, {
-            body: { base_version: baseVersion, operations, changelog },
-        });
-    }
-    // ── Presigned URL upload ──
-    async requestUploadUrl(data) {
-        return this.request('POST', '/documents/upload-url', { body: data });
-    }
-    async confirmUpload(uploadId) {
-        return this.request('POST', '/documents/confirm-upload', {
-            body: { upload_id: uploadId },
-        });
-    }
-    async requestUpdateUploadUrl(idOrSlug, changelog) {
-        return this.request('POST', `/documents/${idOrSlug}/upload-url`, {
-            body: changelog ? { changelog } : {},
-        });
-    }
-    async confirmUpdateUpload(idOrSlug, uploadId) {
-        return this.request('POST', `/documents/${idOrSlug}/confirm-upload`, {
-            body: { upload_id: uploadId },
-        });
-    }
-    async uploadToPresignedUrl(presignedUrl, filePath, onProgress) {
-        const stat = statSync(filePath);
-        const totalBytes = stat.size;
-        const ext = extname(filePath).toLowerCase();
-        const contentType = ext === '.md' ? 'text/markdown' : 'application/octet-stream';
-        const stream = createReadStream(filePath);
-        // Collect chunks for progress tracking and body assembly
-        const chunks = [];
-        let bytesRead = 0;
-        for await (const chunk of stream) {
-            const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-            chunks.push(buf);
-            bytesRead += buf.length;
-            onProgress?.(bytesRead, totalBytes);
-        }
-        const body = Buffer.concat(chunks);
-        const response = await fetch(presignedUrl, {
-            method: 'PUT',
-            headers: {
-                'Content-Type': contentType,
-                'Content-Length': String(totalBytes),
-            },
-            body,
-        });
-        if (!response.ok) {
-            const text = await response.text();
-            throw new OrbitMapAPIError(`R2 upload failed: HTTP ${response.status} — ${text.slice(0, 200)}`, 'UPLOAD_FAILED', response.status);
-        }
-    }
-    /**
-     * Attempts presigned URL upload for a new document.
-     * Returns null if the endpoint is not available (404), signaling caller to fall back.
-     */
-    async presignedImport(filePath, data, onProgress) {
-        let uploadResponse;
-        try {
-            uploadResponse = await this.requestUploadUrl({
-                title: data.title,
-                type: data.type,
-                filename: basename(filePath),
-                source_path: data.source_path,
-                context: data.context,
-                workspace_id: data.workspace_id,
-            });
-        }
-        catch (err) {
-            if (err instanceof OrbitMapAPIError && err.status === 404) {
-                return null; // endpoint not available — fallback
-            }
-            throw err;
-        }
-        await this.uploadToPresignedUrl(uploadResponse.data.presigned_url, filePath, onProgress);
-        const confirmed = await this.confirmUpload(uploadResponse.data.upload_id);
-        return { data: confirmed.data, upload_method: 'presigned' };
-    }
-    /**
-     * Attempts presigned URL upload for updating a document.
-     * Returns null if the endpoint is not available (404), signaling caller to fall back.
-     */
-    async presignedUpdate(idOrSlug, filePath, changelog, onProgress) {
-        let uploadResponse;
-        try {
-            uploadResponse = await this.requestUpdateUploadUrl(idOrSlug, changelog);
-        }
-        catch (err) {
-            if (err instanceof OrbitMapAPIError && err.status === 404) {
-                return null; // endpoint not available — fallback
-            }
-            throw err;
-        }
-        await this.uploadToPresignedUrl(uploadResponse.data.presigned_url, filePath, onProgress);
-        const confirmed = await this.confirmUpdateUpload(idOrSlug, uploadResponse.data.upload_id);
-        return { data: confirmed.data, upload_method: 'presigned' };
-    }
-    // ── Document sharing ──
-    async shareDocument(documentId, projectId, agentIds) {
-        return this.request('POST', `/documents/${documentId}/share`, {
-            body: { project_id: projectId, agent_ids: agentIds },
-        });
-    }
-    async unshareDocument(documentId, projectId) {
-        return this.request('DELETE', `/documents/${documentId}/share/${projectId}`);
-    }
-    async setDocumentVisibility(documentId, projectId, agentIds) {
-        return this.request('PUT', `/documents/${documentId}/share/${projectId}/visibility`, { body: { agent_ids: agentIds } });
-    }
-    // ── Projects ──
-    async getProjects() {
-        return this.request('GET', '/projects');
-    }
-    async getProjectMembers(projectId) {
-        return this.request('GET', `/projects/${projectId}/members`);
-    }
-    async getProjectOverview(projectId) {
-        return this.request('GET', `/projects/${projectId}/overview`);
-    }
-    async createProject(data) {
-        return this.request('POST', '/projects', { body: data });
-    }
-    // ── Issues ──
-    async registerIssue(data) {
-        return this.request('POST', '/issues', { body: data });
-    }
-    async listIssues(options) {
-        return this.request('GET', '/issues', {
-            params: {
-                status: options?.status,
-                severity: options?.severity,
-                limit: options?.limit,
-            },
-        });
-    }
-    async getIssue(idOrNumber) {
-        return this.request('GET', `/issues/${idOrNumber}`);
-    }
-    async getIssueByNumber(issueNumber) {
-        return this.request('GET', `/issues/by-number/${issueNumber}`);
-    }
-    async resolveIssueByNumber(issueNumber, data) {
-        return this.request('PATCH', `/issues/by-number/${issueNumber}/resolve`, {
-            body: data,
-        });
-    }
-    async resolveIssue(idOrNumber, data) {
-        return this.request('PATCH', `/issues/${idOrNumber}/resolve`, {
-            body: data,
-        });
-    }
-    async updateIssueStatus(idOrNumber, data) {
-        return this.request('PATCH', `/issues/${idOrNumber}/status`, {
-            body: data,
-        });
-    }
-    async updateIssueStatusByNumber(issueNumber, data) {
-        return this.request('PATCH', `/issues/by-number/${issueNumber}/status`, {
-            body: data,
-        });
-    }
-    // ── Vibes ──
-    async logVibe(data) {
-        return this.request('POST', '/vibes', { body: data });
-    }
-    async listVibes(options) {
-        return this.request('GET', '/vibes', {
-            params: {
-                type: options?.type,
-                since: options?.since,
-                limit: options?.limit,
-            },
-        });
-    }
-    async getVibe(id) {
-        return this.request('GET', `/vibes/${id}`);
-    }
-    async updateVibe(id, data) {
-        return this.request('PATCH', `/vibes/${id}`, { body: data });
-    }
-    // ── Ideas ──
-    async listIdeas(options) {
-        return this.request('GET', '/ideas', {
-            params: { status: options?.status, priority: options?.priority, limit: options?.limit },
-        });
-    }
-    async getIdea(idOrNumber) {
-        return this.request('GET', `/ideas/${idOrNumber}`);
-    }
-    async getIdeaByNumber(ideaNumber) {
-        return this.request('GET', `/ideas/by-number/${ideaNumber}`);
-    }
-    async createIdea(data) {
-        return this.request('POST', '/ideas', { body: data });
-    }
-    async updateIdeaStatus(idOrNumber, data) {
-        return this.request('PATCH', `/ideas/${idOrNumber}/status`, { body: data });
-    }
-    async updateIdeaStatusByNumber(ideaNumber, data) {
-        return this.request('PATCH', `/ideas/by-number/${ideaNumber}/status`, { body: data });
-    }
-    // ── Orbits ──
-    async getOrbitItems(orbitIdOrSlug, options) {
-        return this.request('GET', `/orbits/${orbitIdOrSlug}/items`, {
-            params: { type: options?.type },
-        });
-    }
-    async orbitAttach(orbitIdOrSlug, data) {
-        return this.request('POST', `/orbits/${orbitIdOrSlug}/items`, {
-            body: { action: 'attach', ...data },
-        });
-    }
-    async orbitDetach(orbitIdOrSlug, data) {
-        return this.request('POST', `/orbits/${orbitIdOrSlug}/items`, {
-            body: { action: 'detach', ...data },
-        });
-    }
-    // ── Prompts ──
-    async getWorkPrompt() {
-        return this.request('GET', '/prompts/work-on-next-task');
-    }
-    async getImportDocsPrompt() {
-        return this.request('GET', '/prompts/import-docs');
-    }
-}
-export async function createClient(explicitProjectId) {
-    const auth = await resolveAuth();
-    return new OrbitMapClient(auth.apiKey, explicitProjectId ?? auth.projectId, auth.apiUrl);
-}
+/**
+ * Compatibility shim.
+ *
+ * The API client now lives in `src/adapters/cloud.ts` as `CloudAdapter`
+ * (re-exported here under its historical name `OrbitMapClient`). New code
+ * should import `createAdapter` from `./adapters/factory.js` instead.
+ */
+export * from './adapters/cloud.js';
 //# sourceMappingURL=api-client.js.map