@synap-core/client 0.1.0

package/dist/facade.d.ts

@@ -0,0 +1,188 @@
+/**
+ * Business Facade - Couche 2: Façade Métier
+ *
+ * High-level convenience methods that abstract the event-driven architecture.
+ * These methods provide a simple, semantic API for common operations.
+ */
+import type { TRPCClient } from '@trpc/client';
+import type { AppRouter } from './types.js';
+export { ContentFacade } from './facades/content.js';
+export { CapabilitiesFacade } from './facades/capabilities.js';
+/**
+ * Business Facade for Notes
+ */
+export declare class NotesFacade {
+    private rpc;
+    constructor(rpc: TRPCClient<AppRouter>);
+    /**
+     * Create a note
+     *
+     * @example
+     * ```typescript
+     * const result = await synap.notes.create({
+     *   content: '# My Note\n\nContent here',
+     *   title: 'My Note',
+     * });
+     * ```
+     */
+    create(input: {
+        content: string;
+        title?: string;
+        tags?: string[];
+    }): Promise<{
+        success: boolean;
+        status: 'pending';
+        requestId: string;
+        entityId: string;
+    }>;
+    /**
+     * List notes
+     */
+    list(options?: {
+        limit?: number;
+        offset?: number;
+        type?: 'note' | 'task' | 'all';
+    }): Promise<Array<{
+        id: string;
+        title: string | null;
+        preview: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+    }>>;
+    /**
+     * Get a note by ID
+     */
+    get(id: string): Promise<{
+        id: string;
+        title: string | null;
+        preview: string | null;
+        content?: string;
+        fileUrl?: string;
+        createdAt: Date;
+        updatedAt: Date;
+    }>;
+}
+/**
+ * Business Facade for Chat
+ */
+export declare class ChatFacade {
+    private rpc;
+    constructor(rpc: TRPCClient<AppRouter>);
+    /**
+     * Send a message to the AI assistant
+     *
+     * @example
+     * ```typescript
+     * const result = await synap.chat.sendMessage({
+     *   content: 'Create a note about AI',
+     *   threadId: 'thread-123',
+     * });
+     * ```
+     */
+    sendMessage(input: {
+        content: string;
+        threadId?: string;
+        parentId?: string;
+    }): Promise<{
+        success: boolean;
+        status: 'pending';
+        requestId: string;
+        threadId: string;
+        websocketUrl: string;
+    }>;
+    /**
+     * Get thread history
+     */
+    getThread(threadId: string): Promise<{
+        id: string;
+        messages: Array<{
+            id: string;
+            role: 'user' | 'assistant';
+            content: string;
+            createdAt: Date;
+        }>;
+    }>;
+    /**
+     * List all threads
+     */
+    listThreads(): Promise<Array<{
+        id: string;
+        preview: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+    }>>;
+}
+/**
+ * Business Facade for Tasks
+ *
+ * Note: Tasks are managed through the events API in the current architecture.
+ * This facade provides convenience methods that abstract the event-driven flow.
+ */
+export declare class TasksFacade {
+    private rpc;
+    constructor(rpc: TRPCClient<AppRouter>);
+    /**
+     * Complete a task
+     *
+     * This is a convenience method that publishes a task.completion.requested event.
+     *
+     * @example
+     * ```typescript
+     * await synap.tasks.complete('task-123');
+     * ```
+     */
+    complete(taskId: string): Promise<{
+        success: boolean;
+        eventId: string;
+    }>;
+}
+/**
+ * Business Facade for Capture
+ */
+export declare class CaptureFacade {
+    private rpc;
+    constructor(rpc: TRPCClient<AppRouter>);
+    /**
+     * Capture a raw thought
+     *
+     * The AI will analyze the thought and create appropriate entities.
+     *
+     * @example
+     * ```typescript
+     * await synap.capture.thought('I need to remember to buy milk');
+     * ```
+     */
+    thought(content: string, context?: Record<string, unknown>): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+}
+/**
+ * Business Facade for System
+ */
+export declare class SystemFacade {
+    private rpc;
+    constructor(rpc: TRPCClient<AppRouter>);
+    /**
+     * Health check
+     */
+    health(): Promise<{
+        status: string;
+        timestamp: string;
+    }>;
+    /**
+     * Get system information
+     */
+    info(): Promise<{
+        version: string;
+        environment: string;
+        database: {
+            dialect: string;
+            connected: boolean;
+        };
+        storage: {
+            provider: string;
+            configured: boolean;
+        };
+    }>;
+}

package/dist/facades/capabilities.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Capabilities Facade
+ * High-level API for discovering Data Pod capabilities
+ *
+ * DISABLED - capabilities router not implemented in @synap/api yet
+ */
+export declare class CapabilitiesFacade {
+    /**
+     * List all available capabilities
+     * - Core features
+     * - Installed plugins
+     * - Intelligence services
+     */
+    list(): Promise<any>;
+    /**
+     * Check if specific capability is available
+     */
+    has(_capability: string): Promise<boolean>;
+    /**
+     * Check if intelligence service with capability exists
+     */
+    hasIntelligence(_capability: string): Promise<boolean>;
+    /**
+     * Get list of available intelligence services
+     */
+    getIntelligenceServices(): Promise<any[]>;
+}

package/dist/facades/content.d.ts

@@ -0,0 +1,138 @@
+/**
+ * Content Facade
+ *
+ * Unified API for creating content using schema-driven events:
+ * - Entities: Notes, tasks, projects (→ entities.create.requested)
+ * - Documents: PDFs, code files (→ documents.create.requested)
+ *
+ * Supports metadata for AI context and tags.
+ */
+import type { AppRouter } from '@synap/api';
+import type { TRPCClient } from '@trpc/client';
+/**
+ * Entity types supported by the entities worker
+ */
+export type EntityType = 'note' | 'task' | 'project' | 'contact' | 'meeting' | 'idea';
+/**
+ * Options for creating an entity (note, task, project, etc.)
+ */
+export interface CreateEntityOptions {
+    /** Type of entity to create */
+    entityType: EntityType;
+    /** Main content (for notes: markdown, for tasks: description) */
+    content?: string;
+    /** Title of the entity */
+    title?: string;
+    /** Additional metadata (type-specific: dueDate for tasks, etc.) */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Legacy: Options for creating a note (kept for backward compatibility)
+ * @deprecated Use CreateEntityOptions with entityType: 'note' instead
+ */
+export interface CreateNoteOptions {
+    content: string;
+    type?: 'note' | 'task';
+    metadata?: {
+        title?: string;
+        tags?: string[];
+    };
+}
+/**
+ * Options for uploading a file
+ */
+export interface UploadFileOptions {
+    file: File | Buffer;
+    filename: string;
+    contentType: string;
+    targetType: 'note' | 'document';
+    metadata?: {
+        title?: string;
+        description?: string;
+        tags?: string[];
+    };
+}
+/**
+ * Result of a content creation request
+ */
+export interface CreateResult {
+    success: boolean;
+    status: 'pending' | 'completed';
+    requestId: string;
+    entityId?: string;
+    documentId?: string;
+}
+export declare class ContentFacade {
+    private rpc;
+    constructor(rpc: TRPCClient<AppRouter>);
+    /**
+     * Create entity (note, task, project, etc.)
+     *
+     * This is the new schema-driven API that uses the consolidated entities worker.
+     *
+     * @example
+     * ```ts
+     * // Create a note
+     * await client.content.createEntity({
+     *   entityType: 'note',
+     *   content: '# My Note\n\nContent here...',
+     *   title: 'My Note',
+     * });
+     *
+     * // Create a task with metadata
+     * await client.content.createEntity({
+     *   entityType: 'task',
+     *   content: 'Implement feature X',
+     *   title: 'Feature X',
+     *   metadata: {
+     *     dueDate: '2024-12-31',
+     *     priority: 1,
+     *     tags: ['dev', 'urgent'],
+     *   },
+     * });
+     * ```
+     */
+    createEntity(options: CreateEntityOptions): Promise<CreateResult>;
+    /**
+     * Create note from text input
+     *
+     * @deprecated Use createEntity({ entityType: 'note', ... }) instead
+     *
+     * @example
+     * ```ts
+     * await client.content.createNote({
+     *   content: "# Project Ideas\n\nBuild a knowledge graph...",
+     *   type: 'note',
+     *   metadata: { title: 'Q1 Ideas', tags: ['planning'] }
+     * });
+     * ```
+     */
+    createNote(options: CreateNoteOptions): Promise<CreateResult>;
+    /**
+     * Upload file (direct upload or AI-generated)
+     *
+     * @example
+     * ```ts
+     * // Upload PDF as document
+     * await client.content.uploadFile({
+     *   file: pdfBuffer,
+     *   filename: 'report.pdf',
+     *   contentType: 'application/pdf',
+     *   targetType: 'document'
+     * });
+     *
+     * // Upload markdown as note
+     * await client.content.uploadFile({
+     *   file: markdownFile,
+     *   filename: 'ideas.md',
+     *   contentType: 'text/markdown',
+     *   targetType: 'note'
+     * });
+     * ```
+     */
+    uploadFile(options: UploadFileOptions): Promise<CreateResult>;
+    /**
+     * Helper: Convert File to Buffer (browser/Node.js compatible)
+     */
+    private fileToBuffer;
+}

package/dist/index.cjs

@@ -0,0 +1,43 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createSynapClient: () => createSynapClient,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+var import_client = require("@trpc/client");
+function createSynapClient(config) {
+  return (0, import_client.createTRPCClient)({
+    links: [
+      (0, import_client.httpBatchLink)({
+        url: `${config.url}/trpc`,
+        headers: config.headers,
+        fetch: config.fetch
+      })
+    ]
+  });
+}
+var index_default = createSynapClient;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createSynapClient
+});