contiss-ai 1.0.0

package/index.d.ts

@@ -0,0 +1,208 @@
+export type MemoryType = "fact" | "decision" | "plan" | "summary" | "note";
+export type SearchMode = "semantic" | "fulltext" | "hybrid";
+export type AgentStatus = "active" | "idle" | "offline";
+export type Namespace = "shared" | "private";
+
+export interface ContissOptions {
+  apiKey?: string;
+  baseUrl?: string;
+}
+
+export interface MemoryWriteParams {
+  orgId: string;
+  projectId: string;
+  content: string;
+  type?: MemoryType;
+  title?: string;
+  tags?: string[];
+  sources?: string[];
+  confidence?: number;
+  requiresReview?: boolean;
+  supersedesId?: string;
+  agentId?: string;
+  namespace?: Namespace;
+}
+
+export interface MemoryWriteResult {
+  id: string;
+  root_id: string;
+  version: number;
+  is_current: boolean;
+  requires_review: boolean;
+  type: string;
+  consolidated: boolean;
+  duplicates_found: boolean;
+}
+
+export interface MemorySearchParams {
+  orgId: string;
+  projectId: string;
+  query: string;
+  limit?: number;
+  types?: MemoryType[];
+  tags?: string[];
+  searchMode?: SearchMode;
+  agentId?: string;
+  namespace?: Namespace;
+}
+
+export interface MemorySearchResult {
+  items: any[];
+  total: number;
+  query: string;
+  search_mode: string;
+}
+
+export interface MemoryBundleParams {
+  orgId: string;
+  projectId: string;
+  task: string;
+  maxItems?: number;
+  maxChars?: number;
+  types?: string[];
+  tags?: string[];
+}
+
+export interface MemoryBundleResult {
+  bundle_version: string;
+  project_id: string;
+  generated_at: string;
+  high_confidence_facts: any[];
+  relevant_decisions: any[];
+  active_plans: any[];
+  recent_summaries: any[];
+  warnings: string[];
+}
+
+export interface MemoryBatchItem {
+  orgId: string;
+  projectId: string;
+  content: string;
+  type?: MemoryType;
+  title?: string;
+  tags?: string[];
+  sources?: string[];
+  confidence?: number;
+  requiresReview?: boolean;
+  supersedesId?: string;
+  agentId?: string;
+  namespace?: Namespace;
+}
+
+export interface MemoryBatchResult {
+  results: MemoryWriteResult[];
+}
+
+export interface ProjectCreateParams {
+  name: string;
+  description?: string;
+}
+
+export interface Project {
+  id: string;
+  name: string;
+  description: string | null;
+  created_at: string;
+  updated_at: string;
+  stats?: { memories: number; agents: number; documents: number };
+}
+
+export interface ProjectResponse {
+  project: Project;
+}
+
+export interface ProjectListResponse {
+  projects: Project[];
+}
+
+export interface ProjectUpdateParams {
+  name?: string;
+  description?: string;
+}
+
+export interface AgentRegisterParams {
+  projectId: string;
+  agentId: string;
+  name: string;
+  role?: string;
+  capabilities?: string[];
+  metadata?: Record<string, any>;
+}
+
+export interface Agent {
+  id: string;
+  project_id: string;
+  agent_id: string;
+  name: string;
+  role?: string;
+  capabilities: string[];
+  metadata: Record<string, any>;
+  status: string;
+  last_active_at?: string;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface AgentRegisterResponse {
+  agent: Agent;
+  message: string;
+}
+
+export interface AgentListResponse {
+  agents: Agent[];
+}
+
+export interface AgentGetResponse {
+  agent: Agent;
+}
+
+export interface AgentStatsResponse {
+  memory_count: number;
+  [key: string]: any;
+}
+
+export interface HealthResponse {
+  ok: boolean;
+  [key: string]: any;
+}
+
+export class ContissAPIError extends Error {
+  readonly error: string;
+  readonly statusCode: number;
+  constructor(statusCode: number, error: string, message: string);
+}
+
+declare class MemoryResource {
+  write(params: MemoryWriteParams): Promise<MemoryWriteResult>;
+  search(params: MemorySearchParams): Promise<MemorySearchResult>;
+  bundle(params: MemoryBundleParams): Promise<MemoryBundleResult>;
+  writeBatch(memories: MemoryBatchItem[]): Promise<MemoryBatchResult>;
+}
+
+declare class ProjectsResource {
+  list(): Promise<ProjectListResponse>;
+  create(params: ProjectCreateParams): Promise<ProjectResponse>;
+  get(projectId: string): Promise<ProjectResponse>;
+  update(projectId: string, params: ProjectUpdateParams): Promise<ProjectResponse>;
+  delete(projectId: string): Promise<void>;
+}
+
+declare class AgentsResource {
+  register(params: AgentRegisterParams): Promise<AgentRegisterResponse>;
+  list(projectId: string): Promise<AgentListResponse>;
+  get(projectId: string, agentId: string): Promise<AgentGetResponse>;
+  updateStatus(projectId: string, agentId: string, status: AgentStatus): Promise<void>;
+  touch(projectId: string, agentId: string): Promise<void>;
+  stats(projectId: string, agentId: string): Promise<AgentStatsResponse>;
+  delete(projectId: string, agentId: string): Promise<void>;
+}
+
+export class Contiss {
+  readonly memory: MemoryResource;
+  readonly projects: ProjectsResource;
+  readonly agents: AgentsResource;
+  constructor(opts?: ContissOptions);
+  health(): Promise<HealthResponse>;
+}
+
+export default Contiss;

package/index.js

@@ -0,0 +1,255 @@
+"use strict";
+
+/**
+ * Contiss AI SDK — Persistent memory for AI agents.
+ *
+ * Works with both CommonJS (require) and ESM (import).
+ * Zero dependencies — uses native fetch (Node 18+).
+ *
+ * @example
+ * const { Contiss } = require('contiss');
+ * const client = new Contiss({ apiKey: 'sk_live_...' });
+ *
+ * await client.memory.write({
+ *   orgId: '...', projectId: '...',
+ *   content: 'User prefers dark mode',
+ *   type: 'fact',
+ * });
+ */
+
+const DEFAULT_URL =
+  "https://main-backend-963363632208.europe-west1.run.app";
+
+// ── Error ──
+
+class ContissAPIError extends Error {
+  constructor(statusCode, error, message) {
+    super(`${error}: ${message}`);
+    this.name = "ContissAPIError";
+    this.error = error;
+    this.statusCode = statusCode;
+  }
+}
+
+// ── HTTP client ──
+
+class HttpClient {
+  constructor(baseUrl, apiKey) {
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+    this.apiKey = apiKey;
+  }
+
+  async request(method, path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = {
+      "X-API-Key": this.apiKey,
+      "Content-Type": "application/json",
+    };
+
+    const res = await fetch(url, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : undefined,
+    });
+
+    if (res.status === 204) return undefined;
+
+    const data = await res.json();
+
+    if (!res.ok) {
+      throw new ContissAPIError(
+        res.status,
+        data.error || "api_error",
+        data.message || res.statusText,
+      );
+    }
+
+    return data;
+  }
+}
+
+// ── Helpers ──
+
+function buildWriteBody(p) {
+  const body = {
+    org_id: p.orgId,
+    project_id: p.projectId,
+    content: p.content,
+    type: p.type || "note",
+    confidence: p.confidence ?? 0.6,
+    requires_review: p.requiresReview ?? false,
+    namespace: p.namespace || "shared",
+  };
+  if (p.title) body.title = p.title;
+  if (p.tags) body.tags = p.tags;
+  if (p.sources) body.sources = p.sources;
+  if (p.supersedesId) body.supersedes_id = p.supersedesId;
+  if (p.agentId) body.agent_id = p.agentId;
+  return body;
+}
+
+// ── Resources ──
+
+class MemoryResource {
+  constructor(http) {
+    this._http = http;
+  }
+
+  async write(params) {
+    return this._http.request("POST", "/memory/write", buildWriteBody(params));
+  }
+
+  async search(params) {
+    const body = {
+      org_id: params.orgId,
+      project_id: params.projectId,
+      query: params.query,
+      limit: params.limit ?? 20,
+      searchMode: params.searchMode || "hybrid",
+    };
+    if (params.types) body.types = params.types;
+    if (params.tags) body.tags = params.tags;
+    if (params.agentId) body.agent_id = params.agentId;
+    if (params.namespace) body.namespace = params.namespace;
+    return this._http.request("POST", "/memory/search", body);
+  }
+
+  async bundle(params) {
+    return this._http.request("POST", "/memory/bundle", {
+      org_id: params.orgId,
+      project_id: params.projectId,
+      task: params.task,
+      limits: {
+        max_items: params.maxItems ?? 12,
+        max_chars: params.maxChars ?? 6000,
+      },
+      filters: {
+        types: params.types || ["fact", "decision", "plan", "summary"],
+        tags: params.tags || [],
+      },
+    });
+  }
+
+  async writeBatch(memories) {
+    return this._http.request("POST", "/memory/batch", {
+      memories: memories.map(buildWriteBody),
+    });
+  }
+}
+
+class ProjectsResource {
+  constructor(http) {
+    this._http = http;
+  }
+
+  async list() {
+    return this._http.request("GET", "/projects/");
+  }
+
+  async create(params) {
+    return this._http.request("POST", "/projects/", params);
+  }
+
+  async get(projectId) {
+    return this._http.request("GET", `/projects/${projectId}/`);
+  }
+
+  async update(projectId, params) {
+    return this._http.request("PUT", `/projects/${projectId}/`, params);
+  }
+
+  async delete(projectId) {
+    return this._http.request("DELETE", `/projects/${projectId}/`);
+  }
+}
+
+class AgentsResource {
+  constructor(http) {
+    this._http = http;
+  }
+
+  async register(params) {
+    return this._http.request("POST", "/agents/register", {
+      project_id: params.projectId,
+      agent_id: params.agentId,
+      name: params.name,
+      role: params.role,
+      capabilities: params.capabilities,
+      metadata: params.metadata,
+    });
+  }
+
+  async list(projectId) {
+    return this._http.request("POST", "/agents/list", {
+      project_id: projectId,
+    });
+  }
+
+  async get(projectId, agentId) {
+    const data = await this._http.request(
+      "GET",
+      `/agents/${projectId}/${agentId}`,
+    );
+    if (data && data.agent_id) return { agent: data };
+    return data;
+  }
+
+  async updateStatus(projectId, agentId, status) {
+    return this._http.request(
+      "PUT",
+      `/agents/${projectId}/${agentId}/status`,
+      { status },
+    );
+  }
+
+  async touch(projectId, agentId) {
+    return this._http.request(
+      "POST",
+      `/agents/${projectId}/${agentId}/touch`,
+    );
+  }
+
+  async stats(projectId, agentId) {
+    return this._http.request(
+      "GET",
+      `/agents/${projectId}/${agentId}/stats`,
+    );
+  }
+
+  async delete(projectId, agentId) {
+    return this._http.request(
+      "DELETE",
+      `/agents/${projectId}/${agentId}`,
+    );
+  }
+}
+
+// ── Main client ──
+
+class Contiss {
+  constructor(opts = {}) {
+    const apiKey = opts.apiKey || process.env.CONTISS_API_KEY;
+    if (!apiKey) {
+      throw new Error(
+        "API key required. Pass apiKey or set CONTISS_API_KEY env var. " +
+          "Create one at https://contiss.ai/dashboard/keys",
+      );
+    }
+
+    const baseUrl = opts.baseUrl || process.env.CONTISS_BASE_URL || DEFAULT_URL;
+    this._http = new HttpClient(baseUrl, apiKey);
+
+    this.memory = new MemoryResource(this._http);
+    this.projects = new ProjectsResource(this._http);
+    this.agents = new AgentsResource(this._http);
+  }
+
+  async health() {
+    return this._http.request("GET", "/health");
+  }
+}
+
+// ── Exports ──
+
+module.exports = { Contiss, ContissAPIError };
+module.exports.default = Contiss;

package/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "contiss-ai",
+  "version": "1.0.0",
+  "description": "Contiss AI SDK — Persistent memory for AI agents",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "files": ["index.js", "index.d.ts"],
+  "keywords": ["contiss", "ai", "memory", "agents", "sdk"],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}