@avocadostudio-ai/orchestrator-core 0.1.0

package/dist/state/sqlite-store.js

@@ -0,0 +1,421 @@
+import { mkdirSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import Database from "better-sqlite3";
+// ---------------------------------------------------------------------------
+// Caps (mirrors limits used by in-memory state)
+// ---------------------------------------------------------------------------
+export const HISTORY_DEPTH_CAP = 50;
+export const VERSION_LOG_CAP = 100;
+export const RECENT_EDITS_CAP = 10;
+export const CHAT_HISTORY_CAP = 6;
+export const PUBLISH_LOG_CAP = 200;
+// ---------------------------------------------------------------------------
+// Schema
+// ---------------------------------------------------------------------------
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS meta (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS sessions (
+  session TEXT PRIMARY KEY,
+  version INTEGER NOT NULL DEFAULT 0
+);
+
+CREATE TABLE IF NOT EXISTS pages (
+  session TEXT NOT NULL,
+  slug    TEXT NOT NULL,
+  kind    TEXT NOT NULL CHECK (kind IN ('draft','published')),
+  doc     TEXT NOT NULL,
+  PRIMARY KEY (session, slug, kind)
+);
+
+CREATE TABLE IF NOT EXISTS history (
+  session   TEXT NOT NULL,
+  slug      TEXT NOT NULL,
+  direction TEXT NOT NULL CHECK (direction IN ('undo','redo')),
+  seq       INTEGER NOT NULL,
+  snapshot  TEXT,
+  PRIMARY KEY (session, slug, direction, seq)
+);
+
+CREATE TABLE IF NOT EXISTS version_log (
+  session TEXT NOT NULL,
+  seq     INTEGER NOT NULL,
+  entry   TEXT NOT NULL,
+  PRIMARY KEY (session, seq)
+);
+
+CREATE TABLE IF NOT EXISTS recent_edits (
+  session TEXT NOT NULL,
+  seq     INTEGER NOT NULL,
+  entry   TEXT NOT NULL,
+  PRIMARY KEY (session, seq)
+);
+
+CREATE TABLE IF NOT EXISTS chat_history (
+  session TEXT NOT NULL,
+  seq     INTEGER NOT NULL,
+  role    TEXT NOT NULL CHECK (role IN ('user','assistant')),
+  content TEXT NOT NULL,
+  PRIMARY KEY (session, seq)
+);
+
+CREATE TABLE IF NOT EXISTS site_configs (
+  session TEXT PRIMARY KEY,
+  config  TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS issue_touched (
+  issue_key  TEXT PRIMARY KEY,
+  slugs      TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS publish_log (
+  session     TEXT NOT NULL,
+  seq         INTEGER NOT NULL,
+  id          TEXT NOT NULL,
+  site_id     TEXT NOT NULL,
+  target      TEXT NOT NULL,
+  status      TEXT NOT NULL CHECK (status IN ('triggered','success','failed')),
+  at          TEXT NOT NULL,
+  updated_at  TEXT NOT NULL,
+  entry       TEXT NOT NULL,
+  PRIMARY KEY (session, seq)
+);
+
+CREATE INDEX IF NOT EXISTS publish_log_by_id ON publish_log(id);
+CREATE INDEX IF NOT EXISTS publish_log_by_session_at ON publish_log(session, at DESC);
+`;
+const SCHEMA_VERSION = 1;
+export class SqliteStore {
+    db;
+    stmt;
+    constructor(options) {
+        const { file } = options;
+        const useWal = options.wal ?? (file !== ":memory:");
+        if (file !== ":memory:") {
+            mkdirSync(dirname(resolve(file)), { recursive: true });
+        }
+        this.db = new Database(file);
+        this.db.pragma("foreign_keys = ON");
+        if (useWal) {
+            this.db.pragma("journal_mode = WAL");
+            this.db.pragma("synchronous = NORMAL");
+        }
+        this.db.exec(SCHEMA);
+        this.ensureSchemaVersion();
+        this.stmt = this.prepareAll();
+        options.onLog?.(`SqliteStore opened: ${file}`);
+    }
+    ensureSchemaVersion() {
+        const row = this.db
+            .prepare("SELECT value FROM meta WHERE key = 'schema_version'")
+            .get();
+        if (!row) {
+            this.db
+                .prepare("INSERT INTO meta(key, value) VALUES ('schema_version', ?)")
+                .run(String(SCHEMA_VERSION));
+        }
+    }
+    prepareAll() {
+        const db = this.db;
+        return {
+            upsertPage: db.prepare(`INSERT INTO pages(session, slug, kind, doc) VALUES (?, ?, ?, ?)
+         ON CONFLICT(session, slug, kind) DO UPDATE SET doc = excluded.doc`),
+            deletePage: db.prepare(`DELETE FROM pages WHERE session = ? AND slug = ? AND kind = ?`),
+            selectPage: db.prepare(`SELECT doc FROM pages WHERE session = ? AND slug = ? AND kind = ?`),
+            listPagesBySessionKind: db.prepare(`SELECT slug, doc FROM pages WHERE session = ? AND kind = ? ORDER BY slug`),
+            listAllDraftSessions: db.prepare(`SELECT DISTINCT session FROM pages WHERE kind = 'draft' ORDER BY session`),
+            insertHistory: db.prepare(`INSERT INTO history(session, slug, direction, seq, snapshot) VALUES (?, ?, ?, ?, ?)`),
+            popHistoryTop: db.prepare(`SELECT seq, snapshot FROM history
+         WHERE session = ? AND slug = ? AND direction = ?
+         ORDER BY seq DESC LIMIT 1`),
+            deleteHistoryRow: db.prepare(`DELETE FROM history WHERE session = ? AND slug = ? AND direction = ? AND seq = ?`),
+            clearHistoryDirection: db.prepare(`DELETE FROM history WHERE session = ? AND slug = ? AND direction = ?`),
+            listHistory: db.prepare(`SELECT seq, snapshot FROM history
+         WHERE session = ? AND slug = ? AND direction = ?
+         ORDER BY seq ASC`),
+            trimHistory: db.prepare(`DELETE FROM history
+         WHERE session = ? AND slug = ? AND direction = ?
+           AND seq NOT IN (
+             SELECT seq FROM history
+             WHERE session = ? AND slug = ? AND direction = ?
+             ORDER BY seq DESC LIMIT ?
+           )`),
+            nextHistorySeq: db.prepare(`SELECT COALESCE(MAX(seq), 0) + 1 AS next FROM history
+         WHERE session = ? AND slug = ? AND direction = ?`),
+            upsertSession: db.prepare(`INSERT INTO sessions(session, version) VALUES (?, ?)
+         ON CONFLICT(session) DO UPDATE SET version = excluded.version`),
+            selectSessionVersion: db.prepare(`SELECT version FROM sessions WHERE session = ?`),
+            bumpSessionVersion: db.prepare(`INSERT INTO sessions(session, version) VALUES (?, 1)
+         ON CONFLICT(session) DO UPDATE SET version = version + 1
+         RETURNING version`),
+            insertVersionLog: db.prepare(`INSERT INTO version_log(session, seq, entry) VALUES (?, ?, ?)`),
+            listVersionLog: db.prepare(`SELECT entry FROM version_log WHERE session = ? ORDER BY seq ASC`),
+            listVersionLogForSlug: db.prepare(`SELECT entry FROM version_log
+         WHERE session = ? AND json_extract(entry, '$.slug') = ?
+         ORDER BY seq ASC`),
+            trimVersionLog: db.prepare(`DELETE FROM version_log
+         WHERE session = ?
+           AND seq NOT IN (
+             SELECT seq FROM version_log
+             WHERE session = ?
+             ORDER BY seq DESC LIMIT ?
+           )`),
+            nextVersionLogSeq: db.prepare(`SELECT COALESCE(MAX(seq), 0) + 1 AS next FROM version_log WHERE session = ?`),
+            insertRecentEdit: db.prepare(`INSERT INTO recent_edits(session, seq, entry) VALUES (?, ?, ?)`),
+            listRecentEdits: db.prepare(`SELECT entry FROM recent_edits WHERE session = ? ORDER BY seq ASC`),
+            trimRecentEdits: db.prepare(`DELETE FROM recent_edits
+         WHERE session = ?
+           AND seq NOT IN (
+             SELECT seq FROM recent_edits
+             WHERE session = ?
+             ORDER BY seq DESC LIMIT ?
+           )`),
+            nextRecentEditSeq: db.prepare(`SELECT COALESCE(MAX(seq), 0) + 1 AS next FROM recent_edits WHERE session = ?`),
+            insertChatMessage: db.prepare(`INSERT INTO chat_history(session, seq, role, content) VALUES (?, ?, ?, ?)`),
+            listChatHistory: db.prepare(`SELECT role, content FROM chat_history WHERE session = ? ORDER BY seq ASC`),
+            trimChatHistory: db.prepare(`DELETE FROM chat_history
+         WHERE session = ?
+           AND seq NOT IN (
+             SELECT seq FROM chat_history
+             WHERE session = ?
+             ORDER BY seq DESC LIMIT ?
+           )`),
+            nextChatSeq: db.prepare(`SELECT COALESCE(MAX(seq), 0) + 1 AS next FROM chat_history WHERE session = ?`),
+            upsertSiteConfig: db.prepare(`INSERT INTO site_configs(session, config) VALUES (?, ?)
+         ON CONFLICT(session) DO UPDATE SET config = excluded.config`),
+            selectSiteConfig: db.prepare(`SELECT config FROM site_configs WHERE session = ?`),
+            listSiteConfigs: db.prepare(`SELECT session, config FROM site_configs`),
+            upsertIssueTouched: db.prepare(`INSERT INTO issue_touched(issue_key, slugs, updated_at) VALUES (?, ?, ?)
+         ON CONFLICT(issue_key) DO UPDATE SET
+           slugs = excluded.slugs,
+           updated_at = excluded.updated_at`),
+            selectIssueTouched: db.prepare(`SELECT slugs, updated_at FROM issue_touched WHERE issue_key = ?`),
+            listIssueTouched: db.prepare(`SELECT issue_key, slugs, updated_at FROM issue_touched ORDER BY updated_at ASC`),
+            trimIssueTouched: db.prepare(`DELETE FROM issue_touched
+         WHERE issue_key NOT IN (
+           SELECT issue_key FROM issue_touched
+           ORDER BY updated_at DESC LIMIT ?
+         )`),
+            insertPublishLog: db.prepare(`INSERT INTO publish_log(session, seq, id, site_id, target, status, at, updated_at, entry)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`),
+            updatePublishLogById: db.prepare(`UPDATE publish_log
+           SET status = ?, updated_at = ?, entry = ?
+         WHERE id = ?`),
+            selectPublishLogById: db.prepare(`SELECT entry FROM publish_log WHERE id = ?`),
+            selectPublishLogByDeploymentId: db.prepare(`SELECT entry FROM publish_log
+         WHERE session = ?
+           AND json_extract(entry, '$.deploymentId') = ?
+         ORDER BY seq DESC LIMIT 1`),
+            selectPublishLogByMostRecentTriggered: db.prepare(`SELECT entry FROM publish_log
+         WHERE session = ? AND status = 'triggered'
+         ORDER BY seq DESC LIMIT 1`),
+            listPublishLog: db.prepare(`SELECT entry FROM publish_log
+         WHERE session = ?
+         ORDER BY seq ASC`),
+            listAllPublishLogSessions: db.prepare(`SELECT DISTINCT session FROM publish_log`),
+            trimPublishLog: db.prepare(`DELETE FROM publish_log
+         WHERE session = ?
+           AND seq NOT IN (
+             SELECT seq FROM publish_log
+             WHERE session = ?
+             ORDER BY seq DESC LIMIT ?
+           )`),
+            nextPublishLogSeq: db.prepare(`SELECT COALESCE(MAX(seq), 0) + 1 AS next FROM publish_log WHERE session = ?`),
+        };
+    }
+    // -------------------------------------------------------------------------
+    // Pages
+    // -------------------------------------------------------------------------
+    setPage(session, page, kind = "draft") {
+        this.stmt.upsertPage.run(session, page.slug, kind, JSON.stringify(page));
+    }
+    getPage(session, slug, kind = "draft") {
+        const row = this.stmt.selectPage.get(session, slug, kind);
+        return row ? JSON.parse(row.doc) : null;
+    }
+    removePage(session, slug, kind = "draft") {
+        this.stmt.deletePage.run(session, slug, kind);
+    }
+    listPages(session, kind = "draft") {
+        const rows = this.stmt.listPagesBySessionKind.all(session, kind);
+        return rows.map((r) => JSON.parse(r.doc));
+    }
+    listDraftSessions() {
+        const rows = this.stmt.listAllDraftSessions.all();
+        return rows.map((r) => r.session);
+    }
+    // -------------------------------------------------------------------------
+    // History (undo/redo) — capped at HISTORY_DEPTH_CAP per (session,slug,direction)
+    // -------------------------------------------------------------------------
+    pushHistory(session, slug, direction, snapshot) {
+        const nextRow = this.stmt.nextHistorySeq.get(session, slug, direction);
+        const payload = snapshot === null ? null : JSON.stringify(snapshot);
+        this.stmt.insertHistory.run(session, slug, direction, nextRow.next, payload);
+        this.stmt.trimHistory.run(session, slug, direction, session, slug, direction, HISTORY_DEPTH_CAP);
+    }
+    popHistory(session, slug, direction) {
+        const row = this.stmt.popHistoryTop.get(session, slug, direction);
+        if (!row)
+            return undefined;
+        this.stmt.deleteHistoryRow.run(session, slug, direction, row.seq);
+        return row.snapshot === null ? null : JSON.parse(row.snapshot);
+    }
+    clearHistory(session, slug, direction) {
+        this.stmt.clearHistoryDirection.run(session, slug, direction);
+    }
+    listHistory(session, slug, direction) {
+        const rows = this.stmt.listHistory.all(session, slug, direction);
+        return rows.map((r) => (r.snapshot === null ? null : JSON.parse(r.snapshot)));
+    }
+    // -------------------------------------------------------------------------
+    // Version counter
+    // -------------------------------------------------------------------------
+    getVersion(session) {
+        const row = this.stmt.selectSessionVersion.get(session);
+        return row?.version ?? 0;
+    }
+    setVersion(session, version) {
+        this.stmt.upsertSession.run(session, version);
+    }
+    bumpVersion(session) {
+        const row = this.stmt.bumpSessionVersion.get(session);
+        return row.version;
+    }
+    // -------------------------------------------------------------------------
+    // Version log — capped at VERSION_LOG_CAP per session
+    // -------------------------------------------------------------------------
+    pushVersionLog(session, entry) {
+        const next = this.stmt.nextVersionLogSeq.get(session);
+        this.stmt.insertVersionLog.run(session, next.next, JSON.stringify(entry));
+        this.stmt.trimVersionLog.run(session, session, VERSION_LOG_CAP);
+    }
+    listVersionLog(session, slug, limit = 50) {
+        const rows = (slug
+            ? this.stmt.listVersionLogForSlug.all(session, slug)
+            : this.stmt.listVersionLog.all(session));
+        const parsed = rows.map((r) => JSON.parse(r.entry));
+        return parsed.slice(-limit);
+    }
+    // -------------------------------------------------------------------------
+    // Recent edits — capped at RECENT_EDITS_CAP per session
+    // -------------------------------------------------------------------------
+    pushRecentEdit(session, entry) {
+        const next = this.stmt.nextRecentEditSeq.get(session);
+        this.stmt.insertRecentEdit.run(session, next.next, JSON.stringify(entry));
+        this.stmt.trimRecentEdits.run(session, session, RECENT_EDITS_CAP);
+    }
+    listRecentEdits(session) {
+        const rows = this.stmt.listRecentEdits.all(session);
+        return rows.map((r) => JSON.parse(r.entry));
+    }
+    // -------------------------------------------------------------------------
+    // Chat history — capped at CHAT_HISTORY_CAP messages per session
+    // -------------------------------------------------------------------------
+    pushChatMessage(session, role, content) {
+        const next = this.stmt.nextChatSeq.get(session);
+        this.stmt.insertChatMessage.run(session, next.next, role, content);
+        this.stmt.trimChatHistory.run(session, session, CHAT_HISTORY_CAP);
+    }
+    listChatHistory(session) {
+        const rows = this.stmt.listChatHistory.all(session);
+        return rows.map((r) => ({ role: r.role, content: r.content }));
+    }
+    // -------------------------------------------------------------------------
+    // Site configs
+    // -------------------------------------------------------------------------
+    setSiteConfig(session, config) {
+        this.stmt.upsertSiteConfig.run(session, JSON.stringify(config));
+    }
+    getSiteConfig(session) {
+        const row = this.stmt.selectSiteConfig.get(session);
+        return row ? JSON.parse(row.config) : null;
+    }
+    listSiteConfigs() {
+        const rows = this.stmt.listSiteConfigs.all();
+        return rows.map((r) => ({ session: r.session, config: JSON.parse(r.config) }));
+    }
+    // -------------------------------------------------------------------------
+    // Issue-touched slugs
+    // -------------------------------------------------------------------------
+    setIssueTouched(issueKey, row, cap = 200) {
+        this.stmt.upsertIssueTouched.run(issueKey, JSON.stringify(row.slugs), row.updatedAt);
+        this.stmt.trimIssueTouched.run(cap);
+    }
+    getIssueTouched(issueKey) {
+        const row = this.stmt.selectIssueTouched.get(issueKey);
+        if (!row)
+            return null;
+        return { slugs: JSON.parse(row.slugs), updatedAt: row.updated_at };
+    }
+    listIssueTouched() {
+        const rows = this.stmt.listIssueTouched.all();
+        return rows.map((r) => ({
+            issueKey: r.issue_key,
+            row: { slugs: JSON.parse(r.slugs), updatedAt: r.updated_at },
+        }));
+    }
+    // -------------------------------------------------------------------------
+    // Publish log — capped at PUBLISH_LOG_CAP per session.
+    // Append-only with per-id UPDATE for async deploy-status transitions.
+    // -------------------------------------------------------------------------
+    pushPublishLog(entry) {
+        const next = this.stmt.nextPublishLogSeq.get(entry.session);
+        this.stmt.insertPublishLog.run(entry.session, next.next, entry.id, entry.siteId, entry.target, entry.status, entry.at, entry.updatedAt, JSON.stringify(entry));
+        this.stmt.trimPublishLog.run(entry.session, entry.session, PUBLISH_LOG_CAP);
+    }
+    getPublishLogById(id) {
+        const row = this.stmt.selectPublishLogById.get(id);
+        return row ? JSON.parse(row.entry) : null;
+    }
+    getPublishLogByDeploymentId(session, deploymentId) {
+        const row = this.stmt.selectPublishLogByDeploymentId.get(session, deploymentId);
+        return row ? JSON.parse(row.entry) : null;
+    }
+    getMostRecentTriggeredPublishLog(session) {
+        const row = this.stmt.selectPublishLogByMostRecentTriggered.get(session);
+        return row ? JSON.parse(row.entry) : null;
+    }
+    /**
+     * Patch an existing publish-log row. Merges `patch` into the stored JSON,
+     * bumps `updatedAt`, and updates the hoisted `status` column. Returns the
+     * full updated entry, or null if the id was not found.
+     */
+    updatePublishLogById(id, patch) {
+        const existing = this.getPublishLogById(id);
+        if (!existing)
+            return null;
+        const next = {
+            ...existing,
+            ...patch,
+            id: existing.id,
+            session: existing.session,
+            at: existing.at,
+            updatedAt: new Date().toISOString(),
+        };
+        this.stmt.updatePublishLogById.run(next.status, next.updatedAt, JSON.stringify(next), id);
+        return next;
+    }
+    listPublishLog(session, limit = 50) {
+        const rows = this.stmt.listPublishLog.all(session);
+        const parsed = rows.map((r) => JSON.parse(r.entry));
+        return parsed.slice(-limit);
+    }
+    listPublishLogSessions() {
+        const rows = this.stmt.listAllPublishLogSessions.all();
+        return rows.map((r) => r.session);
+    }
+    // -------------------------------------------------------------------------
+    // Transactions — per-request boundary. Nested calls reuse the outer txn.
+    // -------------------------------------------------------------------------
+    transaction(fn) {
+        return this.db.transaction(fn)();
+    }
+    close() {
+        this.db.close();
+    }
+}

package/dist/telemetry/chat-telemetry.d.ts

@@ -0,0 +1,105 @@
+export type ChatTelemetryPhase = "received" | "milestone" | "forced_plan" | "deterministic_plan_generated" | "plan_attempt_failed" | "plan_generated" | "plan_apply_failed" | "repair_attempt" | "repair_generated" | "tool_call" | "result";
+export type ChatTelemetryEntry = {
+    id: string;
+    at: string;
+    phase: ChatTelemetryPhase;
+    session: string;
+    requestedSlug: string;
+    effectiveSlug: string;
+    plannerSource: "openai" | "anthropic" | "gemini" | "demo";
+    modelKey: string;
+    modelUsed: string;
+    promptHash: string;
+    promptExcerpt: string;
+    promptLength: number;
+    outcome?: string;
+    timelineStage?: "request_received" | "first_token" | "first_structured_progress" | "plan_ready" | "first_op_applied" | "done";
+    reason?: string;
+    reasonCategory?: string;
+    opCount?: number;
+    opTypes?: string[];
+    skippedOpCount?: number;
+    intent?: string;
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+    cacheCreationInputTokens?: number;
+    cacheReadInputTokens?: number;
+    estimatedUsd?: number | null;
+    totalDurationMs?: number;
+    planningDurationMs?: number;
+    firstPlanningTokenMs?: number;
+    applyDurationMs?: number;
+    imageResolutionDurationMs?: number;
+    planningAttempts?: number;
+    contextPackBytes?: number;
+    contractMode?: "minimal" | "targeted" | "full";
+    contractBytes?: number;
+    contractBlockCount?: number;
+    strictJsonEnabled?: boolean;
+    schemaRetryUsed?: boolean;
+    plannerRefusal?: boolean;
+    plannerIncomplete?: boolean;
+    compactContextEnabled?: boolean;
+    minimalContextEnabled?: boolean;
+    plannerTier?: "forced_deterministic" | "deterministic" | "llm_intent_router" | "full_llm" | "demo";
+    toolName?: string;
+    toolOk?: boolean;
+    toolLatencyMs?: number;
+    toolAttempts?: number;
+    toolErrorCode?: string;
+    correlationId?: string;
+};
+type Logger = {
+    info: (payload: Record<string, unknown>, message?: string) => void;
+    error: (payload: Record<string, unknown>, message?: string) => void;
+};
+type CreateChatTelemetryStoreArgs = {
+    filePath: string;
+    limit: number;
+    persistEnabled: boolean;
+    logger: Logger;
+    onPush?: (entry: ChatTelemetryEntry) => void;
+};
+export declare function createChatTelemetryStore(args: CreateChatTelemetryStoreArgs): {
+    promptExcerpt: (message: string) => string;
+    promptHash: (message: string) => string;
+    push: (entry: ChatTelemetryEntry) => void;
+    loadFromDisk: () => Promise<void>;
+    list: (args: {
+        limit?: number;
+        outcome?: string;
+        phase?: string;
+        session?: string;
+    }) => {
+        totalBuffered: number;
+        returned: number;
+        byOutcome: Record<string, number>;
+        byReasonCategory: Record<string, number>;
+        rows: ChatTelemetryEntry[];
+    };
+    review: (args: {
+        limit?: number;
+        session?: string;
+    }) => {
+        analyzed: number;
+        appliedCount: number;
+        failedCount: number;
+        failureRate: number;
+        plannerRefusalCount: number;
+        plannerIncompleteCount: number;
+        failureByOutcome: Record<string, number>;
+        failureByReasonCategory: Record<string, number>;
+        topFailedPrompts: {
+            promptExcerpt: string;
+            count: number;
+            outcomes: Record<string, number>;
+            reasonCategories: Record<string, number>;
+            lastAt: string;
+            promptHash: string;
+        }[];
+        recommendations: string[];
+    };
+};
+export type ChatTelemetryStore = ReturnType<typeof createChatTelemetryStore>;
+export {};