@axiom-lattice/local-stores 1.0.1

package/src/stores/LocalWorkflowTrackingStore.ts

@@ -0,0 +1,299 @@
+/**
+ * Local SQLite implementation of WorkflowTrackingStore.
+ */
+
+import { DatabaseWrapper } from "../database";
+import type {
+  WorkflowTrackingStore,
+  WorkflowRun,
+  RunStep,
+  CreateWorkflowRunRequest,
+  UpdateWorkflowRunRequest,
+  CreateRunStepRequest,
+  UpdateRunStepRequest,
+  StepType,
+  WorkflowRunStatus,
+} from "@axiom-lattice/protocols";
+import { ensureTable, nowISO, parseISO } from "../database";
+
+const DDL = `
+CREATE TABLE IF NOT EXISTS lt_workflow_runs (
+  id TEXT PRIMARY KEY,
+  tenant_id TEXT NOT NULL,
+  assistant_id TEXT NOT NULL,
+  thread_id TEXT NOT NULL,
+  status TEXT NOT NULL DEFAULT 'running',
+  topology_edges TEXT NOT NULL DEFAULT '[]',
+  total_edges INTEGER NOT NULL DEFAULT 0,
+  completed_edges INTEGER NOT NULL DEFAULT 0,
+  error_message TEXT,
+  metadata TEXT DEFAULT '{}',
+  started_at TEXT NOT NULL,
+  completed_at TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_lt_wr_thread ON lt_workflow_runs(tenant_id, thread_id);
+CREATE INDEX IF NOT EXISTS idx_lt_wr_assistant ON lt_workflow_runs(tenant_id, assistant_id);
+
+CREATE TABLE IF NOT EXISTS lt_workflow_steps (
+  id TEXT NOT NULL,
+  run_id TEXT NOT NULL,
+  tenant_id TEXT NOT NULL,
+  step_type TEXT NOT NULL,
+  step_name TEXT NOT NULL,
+  edge_from TEXT,
+  edge_to TEXT,
+  edge_purpose TEXT,
+  input TEXT,
+  output TEXT,
+  status TEXT NOT NULL DEFAULT 'running',
+  error_message TEXT,
+  started_at TEXT NOT NULL,
+  completed_at TEXT,
+  duration_ms INTEGER,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (run_id, id)
+);
+CREATE INDEX IF NOT EXISTS idx_lt_ws_type ON lt_workflow_steps(run_id, step_type);
+`;
+
+interface RunRow {
+  id: string;
+  tenant_id: string;
+  assistant_id: string;
+  thread_id: string;
+  status: string;
+  topology_edges: string;
+  total_edges: number;
+  completed_edges: number;
+  error_message: string | null;
+  metadata: string;
+  started_at: string;
+  completed_at: string | null;
+  created_at: string;
+  updated_at: string;
+}
+
+interface StepRow {
+  id: string;
+  run_id: string;
+  tenant_id: string;
+  step_type: string;
+  step_name: string;
+  edge_from: string | null;
+  edge_to: string | null;
+  edge_purpose: string | null;
+  input: string | null;
+  output: string | null;
+  status: string;
+  error_message: string | null;
+  started_at: string;
+  completed_at: string | null;
+  duration_ms: number | null;
+  created_at: string;
+  updated_at: string;
+}
+
+export class LocalWorkflowTrackingStore implements WorkflowTrackingStore {
+  private db: DatabaseWrapper;
+
+  constructor(db: DatabaseWrapper) {
+    this.db = db;
+    ensureTable(db, DDL);
+  }
+
+  async createWorkflowRun(request: CreateWorkflowRunRequest): Promise<WorkflowRun> {
+    const now = nowISO();
+    const id = `${request.threadId}_${Date.now()}`;
+
+    this.db.prepare(
+      `INSERT INTO lt_workflow_runs (id, tenant_id, assistant_id, thread_id, status, topology_edges, total_edges, completed_edges, metadata, started_at, created_at, updated_at)
+       VALUES (?, ?, ?, ?, 'running', ?, ?, 0, ?, ?, ?, ?)`,
+    ).run(id, request.tenantId, request.assistantId, request.threadId,
+      JSON.stringify(request.topologyEdges), request.topologyEdges.length,
+      JSON.stringify(request.metadata || {}), now, now, now);
+
+    return {
+      id, tenantId: request.tenantId, assistantId: request.assistantId,
+      threadId: request.threadId, status: 'running',
+      topologyEdges: request.topologyEdges, totalEdges: request.topologyEdges.length,
+      completedEdges: 0, metadata: request.metadata,
+      startedAt: parseISO(now), completedAt: undefined,
+      createdAt: parseISO(now), updatedAt: parseISO(now),
+    };
+  }
+
+  async getWorkflowRun(runId: string): Promise<WorkflowRun | null> {
+    const row = this.db.prepare(`SELECT * FROM lt_workflow_runs WHERE id = ?`).get(runId) as unknown as RunRow | undefined;
+    return row ? mapRowToRun(row) : null;
+  }
+
+  async updateWorkflowRun(runId: string, updates: UpdateWorkflowRunRequest): Promise<WorkflowRun | null> {
+    const existing = await this.getWorkflowRun(runId);
+    if (!existing) return null;
+
+    const setClauses: string[] = [];
+    const values: unknown[] = [];
+
+    if (updates.status !== undefined) { setClauses.push("status = ?"); values.push(updates.status); }
+    if (updates.completedEdges !== undefined) { setClauses.push("completed_edges = ?"); values.push(updates.completedEdges); }
+    if (updates.errorMessage !== undefined) { setClauses.push("error_message = ?"); values.push(updates.errorMessage); }
+    if (updates.completedAt !== undefined) { setClauses.push("completed_at = ?"); values.push(updates.completedAt ? updates.completedAt.toISOString() : null); }
+    if (updates.metadata !== undefined) { setClauses.push("metadata = ?"); values.push(JSON.stringify(updates.metadata)); }
+
+    if (setClauses.length === 0) return existing;
+
+    const now = nowISO();
+    setClauses.push("updated_at = ?");
+    values.push(now);
+    values.push(runId);
+
+    this.db.prepare(
+      `UPDATE lt_workflow_runs SET ${setClauses.join(", ")} WHERE id = ?`,
+    ).run(...values);
+
+    return this.getWorkflowRun(runId);
+  }
+
+  async deleteWorkflowRun(runId: string): Promise<void> {
+    this.db.prepare(`DELETE FROM lt_workflow_runs WHERE id = ?`).run(runId);
+  }
+
+  async getWorkflowRunsByThreadId(tenantId: string, threadId: string): Promise<WorkflowRun[]> {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_workflow_runs WHERE tenant_id = ? AND thread_id = ? ORDER BY created_at DESC`,
+    ).all(tenantId, threadId) as unknown as RunRow[];
+    return rows.map(mapRowToRun);
+  }
+
+  async getWorkflowRunsByAssistantId(tenantId: string, assistantId: string): Promise<WorkflowRun[]> {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_workflow_runs WHERE tenant_id = ? AND assistant_id = ? ORDER BY created_at DESC`,
+    ).all(tenantId, assistantId) as unknown as RunRow[];
+    return rows.map(mapRowToRun);
+  }
+
+  async getWorkflowRunsByTenantId(tenantId: string): Promise<WorkflowRun[]> {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_workflow_runs WHERE tenant_id = ? ORDER BY created_at DESC`,
+    ).all(tenantId) as unknown as RunRow[];
+    return rows.map(mapRowToRun);
+  }
+
+  async createRunStep(request: CreateRunStepRequest): Promise<RunStep> {
+    const now = nowISO();
+    const id = `step_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+
+    this.db.prepare(
+      `INSERT INTO lt_workflow_steps (id, run_id, tenant_id, step_type, step_name, edge_from, edge_to, edge_purpose, input, status, started_at, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'running', ?, ?, ?)`,
+    ).run(id, request.runId, request.tenantId, request.stepType, request.stepName,
+      request.edgeFrom || null, request.edgeTo || null, request.edgePurpose || null,
+      request.input ? JSON.stringify(request.input) : null, now, now, now);
+
+    return {
+      id, runId: request.runId, tenantId: request.tenantId,
+      stepType: request.stepType, stepName: request.stepName,
+      edgeFrom: request.edgeFrom, edgeTo: request.edgeTo, edgePurpose: request.edgePurpose,
+      input: request.input, status: 'running', startedAt: parseISO(now),
+      createdAt: parseISO(now), updatedAt: parseISO(now),
+    };
+  }
+
+  async updateRunStep(runId: string, stepId: string, updates: UpdateRunStepRequest): Promise<RunStep | null> {
+    const setClauses: string[] = [];
+    const values: unknown[] = [];
+
+    if (updates.status !== undefined) { setClauses.push("status = ?"); values.push(updates.status); }
+    if (updates.output !== undefined) { setClauses.push("output = ?"); values.push(JSON.stringify(updates.output)); }
+    if (updates.errorMessage !== undefined) { setClauses.push("error_message = ?"); values.push(updates.errorMessage); }
+    if (updates.completedAt !== undefined) { setClauses.push("completed_at = ?"); values.push(updates.completedAt ? updates.completedAt.toISOString() : null); }
+    if (updates.durationMs !== undefined) { setClauses.push("duration_ms = ?"); values.push(updates.durationMs); }
+
+    if (setClauses.length === 0) {
+      return this.getStepById(runId, stepId);
+    }
+
+    const now = nowISO();
+    setClauses.push("updated_at = ?");
+    values.push(now);
+    values.push(runId, stepId);
+
+    this.db.prepare(
+      `UPDATE lt_workflow_steps SET ${setClauses.join(", ")} WHERE run_id = ? AND id = ?`,
+    ).run(...values);
+
+    return this.getStepById(runId, stepId);
+  }
+
+  async getRunSteps(runId: string): Promise<RunStep[]> {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_workflow_steps WHERE run_id = ? ORDER BY created_at ASC`,
+    ).all(runId) as unknown as StepRow[];
+    return rows.map(mapRowToStep);
+  }
+
+  async getRunStepsByType(runId: string, stepType: StepType): Promise<RunStep[]> {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_workflow_steps WHERE run_id = ? AND step_type = ? ORDER BY created_at ASC`,
+    ).all(runId, stepType) as unknown as StepRow[];
+    return rows.map(mapRowToStep);
+  }
+
+  async getInterruptedSteps(runId: string): Promise<RunStep[]> {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_workflow_steps WHERE run_id = ? AND status = 'interrupted' ORDER BY created_at ASC`,
+    ).all(runId) as unknown as StepRow[];
+    return rows.map(mapRowToStep);
+  }
+
+  private getStepById(runId: string, id: string): RunStep | null {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_workflow_steps WHERE run_id = ? AND id = ?`,
+    ).get(runId, id) as unknown as StepRow | undefined;
+    return row ? mapRowToStep(row) : null;
+  }
+}
+
+function mapRowToRun(row: RunRow): WorkflowRun {
+  return {
+    id: row.id,
+    tenantId: row.tenant_id,
+    assistantId: row.assistant_id,
+    threadId: row.thread_id,
+    status: row.status as WorkflowRunStatus,
+    topologyEdges: JSON.parse(row.topology_edges || "[]"),
+    totalEdges: row.total_edges,
+    completedEdges: row.completed_edges,
+    errorMessage: row.error_message || undefined,
+    metadata: JSON.parse(row.metadata || "{}"),
+    startedAt: parseISO(row.started_at),
+    completedAt: row.completed_at ? parseISO(row.completed_at) : undefined,
+    createdAt: parseISO(row.created_at),
+    updatedAt: parseISO(row.updated_at),
+  };
+}
+
+function mapRowToStep(row: StepRow): RunStep {
+  return {
+    id: row.id,
+    runId: row.run_id,
+    tenantId: row.tenant_id,
+    stepType: row.step_type as StepType,
+    stepName: row.step_name,
+    edgeFrom: row.edge_from || undefined,
+    edgeTo: row.edge_to || undefined,
+    edgePurpose: row.edge_purpose || undefined,
+    input: row.input ? JSON.parse(row.input) : undefined,
+    output: row.output ? JSON.parse(row.output) : undefined,
+    status: row.status as RunStep["status"],
+    errorMessage: row.error_message || undefined,
+    startedAt: parseISO(row.started_at),
+    completedAt: row.completed_at ? parseISO(row.completed_at) : undefined,
+    durationMs: row.duration_ms ?? undefined,
+    createdAt: parseISO(row.created_at),
+    updatedAt: parseISO(row.updated_at),
+  };
+}

package/src/stores/LocalWorkspaceStore.ts

@@ -0,0 +1,143 @@
+/**
+ * Local SQLite implementation of WorkspaceStore.
+ */
+
+import { DatabaseWrapper } from "../database";
+import type {
+  WorkspaceStore,
+  Workspace,
+  CreateWorkspaceRequest,
+  UpdateWorkspaceRequest,
+} from "@axiom-lattice/protocols";
+import { ensureTable, nowISO, parseISO } from "../database";
+
+const DDL = `
+CREATE TABLE IF NOT EXISTS lt_workspaces (
+  id TEXT NOT NULL,
+  tenant_id TEXT NOT NULL,
+  name TEXT NOT NULL,
+  description TEXT,
+  storage_type TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (tenant_id, id)
+);
+`;
+
+interface WorkspaceRow {
+  id: string;
+  tenant_id: string;
+  name: string;
+  description: string | null;
+  storage_type: string;
+  created_at: string;
+  updated_at: string;
+}
+
+export class LocalWorkspaceStore implements WorkspaceStore {
+  private db: DatabaseWrapper;
+
+  constructor(db: DatabaseWrapper) {
+    this.db = db;
+    ensureTable(db, DDL);
+  }
+
+  async getAllWorkspaces(tenantId: string): Promise<Workspace[]> {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_workspaces WHERE tenant_id = ? ORDER BY created_at DESC`,
+    ).all(tenantId) as unknown as WorkspaceRow[];
+    return rows.map(mapRowToWorkspace);
+  }
+
+  async getWorkspaceById(tenantId: string, id: string): Promise<Workspace | null> {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_workspaces WHERE tenant_id = ? AND id = ?`,
+    ).get(tenantId, id) as unknown as WorkspaceRow | undefined;
+    return row ? mapRowToWorkspace(row) : null;
+  }
+
+  async createWorkspace(
+    tenantId: string,
+    id: string,
+    data: CreateWorkspaceRequest,
+  ): Promise<Workspace> {
+    const now = nowISO();
+
+    this.db.prepare(
+      `INSERT INTO lt_workspaces (id, tenant_id, name, description, storage_type, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(tenant_id, id) DO UPDATE SET
+         name = excluded.name,
+         description = excluded.description,
+         storage_type = excluded.storage_type,
+         updated_at = excluded.updated_at`,
+    ).run(id, tenantId, data.name, data.description || null, data.storageType, now, now);
+
+    return {
+      id,
+      tenantId,
+      name: data.name,
+      description: data.description,
+      storageType: data.storageType,
+      createdAt: parseISO(now),
+      updatedAt: parseISO(now),
+    };
+  }
+
+  async updateWorkspace(
+    tenantId: string,
+    id: string,
+    updates: UpdateWorkspaceRequest,
+  ): Promise<Workspace | null> {
+    const existing = await this.getWorkspaceById(tenantId, id);
+    if (!existing) return null;
+
+    const setClauses: string[] = [];
+    const values: unknown[] = [];
+
+    if (updates.name !== undefined) {
+      setClauses.push("name = ?");
+      values.push(updates.name);
+    }
+    if (updates.description !== undefined) {
+      setClauses.push("description = ?");
+      values.push(updates.description || null);
+    }
+    if (updates.storageType !== undefined) {
+      setClauses.push("storage_type = ?");
+      values.push(updates.storageType);
+    }
+
+    if (setClauses.length === 0) return existing;
+
+    const now = nowISO();
+    setClauses.push("updated_at = ?");
+    values.push(now);
+    values.push(tenantId, id);
+
+    this.db.prepare(
+      `UPDATE lt_workspaces SET ${setClauses.join(", ")} WHERE tenant_id = ? AND id = ?`,
+    ).run(...values);
+
+    return this.getWorkspaceById(tenantId, id);
+  }
+
+  async deleteWorkspace(tenantId: string, id: string): Promise<boolean> {
+    const result = this.db.prepare(
+      `DELETE FROM lt_workspaces WHERE tenant_id = ? AND id = ?`,
+    ).run(tenantId, id);
+    return result.changes > 0;
+  }
+}
+
+function mapRowToWorkspace(row: WorkspaceRow): Workspace {
+  return {
+    id: row.id,
+    tenantId: row.tenant_id,
+    name: row.name,
+    description: row.description || undefined,
+    storageType: row.storage_type as Workspace["storageType"],
+    createdAt: parseISO(row.created_at),
+    updatedAt: parseISO(row.updated_at),
+  };
+}

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "preserve",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "moduleResolution": "Bundler",
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "types": ["node"],
+    "sourceMap": true,
+    "incremental": true,
+    "tsBuildInfoFile": "./.tsbuildinfo"
+  },
+  "include": ["src/index.ts"],
+  "exclude": ["node_modules", "dist"]
+}