@qaecy/cue-sdk 0.0.1 → 0.0.2

package/{src/index.d.ts → index.d.ts}

@@ -1,6 +1,6 @@
 export { Cue } from './lib/cue';
 export { CueAuth } from './lib/auth';
 export { CueApi } from './lib/api';
-export type { CueSdkConfig, SsoProvider, PasswordCredentials, SearchRequest, SearchResponse, SearchSource, } from './lib/models';
+export { CueProjects } from './lib/project';
+export type { CueSdkConfig, SsoProvider, PasswordCredentials, SearchRequest, SearchResponse, SearchSource, ProjectData, ProjectSettings, CreateProjectOptions, SyncOptions, SyncResult, } from './lib/models';
 export type { AuthStateListener, Unsubscribe } from './lib/auth';
-//# sourceMappingURL=index.d.ts.map

package/index.js

@@ -0,0 +1,7 @@
+import { f as u, h as a, j as C, k as o } from "./index-BnBbVXtu.js";
+export {
+  u as Cue,
+  a as CueApi,
+  C as CueAuth,
+  o as CueProjects
+};

package/{src/lib → lib}/api.d.ts

@@ -1,9 +1,13 @@
-import type { CueAuth } from './auth';
-import type { SearchRequest, SearchResponse } from './models';
+import { CueAuth } from './auth';
+import { SearchRequest, SearchResponse } from './models';
+import { CueProjects } from './project';
+import { CueSyncApi } from './sync';
 export declare class CueApi {
     private readonly _auth;
     private readonly _gatewayUrl;
-    constructor(_auth: CueAuth, _gatewayUrl: string);
+    readonly projects: CueProjects;
+    readonly sync?: CueSyncApi | undefined;
+    constructor(_auth: CueAuth, _gatewayUrl: string, projects: CueProjects, sync?: CueSyncApi | undefined);
     private _authHeaders;
     /**
      * Search project documents using natural language.
@@ -16,4 +20,3 @@ export declare class CueApi {
      */
     sparql(query: string, projectId: string): Promise<unknown>;
 }
-//# sourceMappingURL=api.d.ts.map

package/{src/lib → lib}/auth.d.ts

@@ -1,15 +1,18 @@
 import { Auth, User } from 'firebase/auth';
-import type { FirebaseApp } from 'firebase/app';
-import type { PasswordCredentials, SsoProvider } from './models';
+import { FirebaseApp } from 'firebase/app';
+import { CueEndpoints, PasswordCredentials, SsoProvider } from './models';
 export type AuthStateListener = (user: User | null) => void;
 export type Unsubscribe = () => void;
 export declare class CueAuth {
     private readonly _auth;
-    constructor(app: FirebaseApp, useEmulator?: boolean);
+    private readonly _endpoints;
+    constructor(app: FirebaseApp, useEmulator: boolean | undefined, endpoints: CueEndpoints);
     /** Sign in with Google or Microsoft via browser popup */
     signIn(provider: SsoProvider): Promise<User>;
     /** Sign in with email and password */
     signIn(provider: 'password', credentials: PasswordCredentials): Promise<User>;
+    /** Sign in with a Cue API key */
+    signInWithApiKey(cueApiKey: string, projectId: string): Promise<User>;
     /** Sign out the current user */
     signOut(): Promise<void>;
     /** Currently signed-in user, or null if not authenticated */
@@ -21,4 +24,3 @@ export declare class CueAuth {
     /** Raw Firebase Auth instance, for advanced use cases */
     get firebaseAuth(): Auth;
 }
-//# sourceMappingURL=auth.d.ts.map

package/lib/cue-node.d.ts

@@ -0,0 +1,21 @@
+import { CueApi } from './api';
+import { Cue } from './cue';
+import { CueProjects } from './project';
+import { CueSyncApi } from './sync';
+import { CueSdkConfig } from './models';
+/**
+ * Node.js entry point for the QAECY SDK.
+ * Extends `Cue` with file-sync capabilities that require Node.js APIs.
+ *
+ * @example
+ * const cue = new CueNode({ apiKey: '...', appId: '...', measurementId: '...' });
+ * await cue.auth.signInWithApiKey(key);
+ * await cue.api.sync.sync(localFiles, { spaceId, providerId, userId });
+ */
+export declare class CueNode extends Cue {
+    readonly api: CueApi & {
+        sync: CueSyncApi;
+    };
+    constructor(config: CueSdkConfig);
+    protected _buildApi(projects: CueProjects): CueApi;
+}

package/lib/cue.d.ts

@@ -0,0 +1,26 @@
+import { FirebaseApp } from 'firebase/app';
+import { CueAuth } from './auth';
+import { CueApi } from './api';
+import { CueProjects } from './project';
+import { CueEndpoints, CueSdkConfig } from './models';
+/**
+ * Main entry point for the QAECY SDK (browser-safe).
+ * For Node.js use with file-sync capabilities, use `CueNode` from `js-cue-sdk/node`.
+ *
+ * @example
+ * const cue = new Cue({ apiKey: '...', appId: '...', measurementId: '...' });
+ * await cue.auth.signIn('google');
+ * const results = await cue.api.search({ term: 'my query', projectId: 'project-id' });
+ */
+export declare class Cue {
+    readonly auth: CueAuth;
+    readonly api: CueApi;
+    protected readonly _app: FirebaseApp;
+    protected readonly _endpoints: CueEndpoints;
+    protected readonly _isEmulator: boolean;
+    constructor(config: CueSdkConfig);
+    /** Override in subclasses to provide a custom CueApi (e.g. with sync). */
+    protected _buildApi(projects: CueProjects): CueApi;
+    /** Convenience: get the current user's Firebase ID token */
+    getToken(forceRefresh?: boolean): Promise<string | null>;
+}

package/lib/models.d.ts

@@ -0,0 +1,103 @@
+export type CueEnvironment = 'production' | 'emulator';
+export interface CueEndpoints {
+    /** API gateway base URL */
+    gatewayUrl: string;
+    /** Token exchange endpoint for API key sign-in */
+    tokenUrl: string;
+    /** Firebase Auth emulator URL */
+    authEmulatorUrl: string;
+}
+export interface CueSdkConfig {
+    /** Firebase API key for this project */
+    apiKey: string;
+    /** Firebase App ID */
+    appId: string;
+    /** Firebase Measurement ID */
+    measurementId: string;
+    /** Target environment. Defaults to 'production'. */
+    environment?: CueEnvironment;
+    /** Override individual endpoint URLs. Takes precedence over environment. */
+    endpoints?: Partial<CueEndpoints>;
+}
+export type SsoProvider = 'google' | 'microsoft';
+export interface PasswordCredentials {
+    email: string;
+    password: string;
+}
+export interface SearchRequest {
+    /** Natural language query or search term */
+    term: string;
+    /** Project ID to search within */
+    projectId: string;
+    /** Optional category filters */
+    categories?: string[];
+}
+export interface SearchSource {
+    item: string;
+    parent: string;
+    content: string;
+}
+export interface SearchResponse {
+    id: string;
+    question: string;
+    questionHTML: string;
+    response: string;
+    sources: SearchSource[];
+    rankedSources: SearchSource[];
+}
+export interface ProjectSettings {
+    views?: Array<{
+        id: string;
+        pinned?: boolean;
+    }>;
+    chatDisabled: boolean;
+    graph?: {
+        type: string;
+        uri: string;
+    };
+}
+export interface ProjectData {
+    id: string;
+    name: string;
+    organizationID: string;
+    created: string;
+    lastSync: string | null;
+    isPublic: boolean;
+    members: string[];
+    syncers: string[];
+    admins: string[];
+    alternativeIDs: string[];
+    projectSettings: ProjectSettings;
+}
+export interface CreateProjectOptions {
+    /** The organization this project belongs to */
+    organizationID: string;
+    /** Human-readable project name */
+    name: string;
+    /** Explicit project ID. Defaults to a new UUID. */
+    id?: string;
+}
+export interface SyncOptions {
+    /** The project/space ID to sync into */
+    spaceId: string;
+    /** Provider ID identifying the file source (e.g. 'local', 's3') */
+    providerId: string;
+    /** Authenticated user ID */
+    userId: string;
+    /** Enable verbose logging */
+    verbose?: boolean;
+}
+export interface SyncResult {
+    /** Number of files successfully synced in this run */
+    syncCount: number;
+    /** Total bytes synced in this run */
+    syncSize: number;
+    /** Number of files that failed to upload */
+    failedUploads: number;
+    /** Total file count (local + remote combined) */
+    totalCount: number;
+    /** Total size across all files */
+    totalSize: number;
+    /** Whether any RDF metadata was written */
+    rdfWritten: boolean;
+}

package/lib/project.d.ts

@@ -0,0 +1,21 @@
+import { FirebaseApp } from 'firebase/app';
+import { CueAuth } from './auth';
+import { CreateProjectOptions, ProjectData } from './models';
+export declare class CueProjects {
+    private readonly _auth;
+    private readonly _db;
+    constructor(_auth: CueAuth, app: FirebaseApp, useEmulator?: boolean);
+    private _requireUser;
+    /**
+     * Create a new project. The authenticated user is automatically set as admin, syncer, and member.
+     * Throws if a project with the given ID already exists.
+     */
+    createProject(options: CreateProjectOptions): Promise<ProjectData>;
+    /**
+     * List all projects where the authenticated user appears in the members, syncers, or admins array.
+     * Runs three parallel Firestore queries and deduplicates by project ID.
+     */
+    listProjects(): Promise<ProjectData[]>;
+    /** Fetch a single project by ID. Returns null if not found. */
+    getProject(projectId: string): Promise<ProjectData | null>;
+}

package/lib/sync.d.ts

@@ -0,0 +1,21 @@
+import { CueBlobStorage } from 'js-databases';
+import { LocalFile } from 'js-sync-tools';
+import { CueAuth } from './auth';
+import { CueProjects } from './project';
+import { SyncOptions, SyncResult } from './models';
+export declare class CueSyncApi {
+    private readonly _auth;
+    private readonly _projects;
+    private readonly _blob;
+    private readonly _gatewayUrl;
+    private readonly _serviceId;
+    private readonly _rdfBase;
+    private readonly _graphMap;
+    constructor(_auth: CueAuth, _projects: CueProjects, _blob: CueBlobStorage, _gatewayUrl: string, _serviceId?: string, _rdfBase?: string);
+    sync(localFiles: LocalFile[], options: SyncOptions): Promise<SyncResult>;
+    private _getOrCreateGraph;
+    private _listRemoteFiles;
+    private _getGraphFiles;
+    private _uploadRdfMetadata;
+    private _logProgress;
+}

package/node.d.ts

@@ -0,0 +1,3 @@
+export * from './index';
+export { CueNode } from './lib/cue-node';
+export { CueSyncApi } from './lib/sync';