@jini-ai/chat 0.3.10 → 0.5.0

package/dist/store/legacy/sqlite/conversations.js

@@ -0,0 +1,274 @@
+import { rows } from '@jini-ai/db/core';
+/**
+ * Returns all conversations for a project, newest first, each enriched with message count,
+ * the latest assistant run summary, and total accumulated run duration across all terminal runs.
+ * @param db Open SQLite database handle.
+ * @param projectId The project whose conversations to list.
+ */
+export function listConversations({ db, projectId }) {
+    return rows(db
+        .prepare(`WITH project_conversations AS (
+          SELECT id, project_id AS projectId, title, session_mode AS sessionMode,
+                 created_at AS createdAt, updated_at AS updatedAt
+            FROM conversations
+           WHERE project_id = ?
+        ),
+        latest_runs AS (
+          SELECT conversation_id AS conversationId,
+                 run_status AS latestRunStatus,
+                 started_at AS latestRunStartedAt,
+                 ended_at AS latestRunEndedAt,
+                 events_json AS latestRunEventsJson
+            FROM (
+              SELECT m.conversation_id,
+                     m.run_status,
+                     m.started_at,
+                     m.ended_at,
+                     m.events_json,
+                     ROW_NUMBER() OVER (
+                       PARTITION BY m.conversation_id
+                       ORDER BY m.position DESC
+                     ) AS rn
+                FROM messages m
+                JOIN project_conversations c ON c.id = m.conversation_id
+               WHERE m.role = 'assistant'
+                 AND m.run_status IS NOT NULL
+            )
+           WHERE rn = 1
+        ),
+        message_counts AS (
+          SELECT m.conversation_id AS conversationId,
+                 COUNT(*) AS messageCount
+            FROM messages m
+            JOIN project_conversations c ON c.id = m.conversation_id
+           GROUP BY m.conversation_id
+        ),
+        total_run_durations AS (
+          SELECT m.conversation_id AS conversationId,
+                 SUM(${terminalRunDurationSql('m')}) AS totalDurationMs
+            FROM messages m
+            JOIN project_conversations c ON c.id = m.conversation_id
+           WHERE m.role = 'assistant'
+             AND m.run_status IN ('succeeded', 'failed', 'canceled')
+           GROUP BY m.conversation_id
+        )
+        SELECT c.id, c.projectId, c.title, c.sessionMode, c.createdAt, c.updatedAt,
+               COALESCE(mc.messageCount, 0) AS messageCount,
+               lr.latestRunStatus, lr.latestRunStartedAt,
+               lr.latestRunEndedAt, lr.latestRunEventsJson,
+               trd.totalDurationMs
+          FROM project_conversations c
+          LEFT JOIN latest_runs lr ON lr.conversationId = c.id
+          LEFT JOIN message_counts mc ON mc.conversationId = c.id
+          LEFT JOIN total_run_durations trd ON trd.conversationId = c.id
+         ORDER BY c.updatedAt DESC`)
+        .all(projectId)).map(normalizeConversation);
+}
+/**
+ * Fetches a single conversation by id with its latest run summary and total run duration.
+ * Returns null when no matching conversation exists.
+ * @param db Open SQLite database handle.
+ * @param id Conversation id.
+ */
+export function getConversation({ db, id }) {
+    const r = db
+        .prepare(`SELECT id, project_id AS projectId, title, session_mode AS sessionMode,
+              created_at AS createdAt, updated_at AS updatedAt,
+              (SELECT COUNT(*) FROM messages WHERE conversation_id = conversations.id) AS messageCount
+         FROM conversations WHERE id = ?`)
+        .get(id);
+    if (!r)
+        return null;
+    return {
+        ...normalizeConversation(r),
+        latestRun: latestConversationRunSummary(db, r.id) ?? undefined,
+        ...numberProperty('totalDurationMs', totalConversationRunDurationMs(db, r.id)),
+    };
+}
+/** @internal Shapes a raw SQLite row into the canonical conversation object, including run summary. */
+function normalizeConversation(r) {
+    const latestRun = conversationRunSummaryFromRow({
+        runStatus: r.latestRunStatus,
+        startedAt: r.latestRunStartedAt,
+        endedAt: r.latestRunEndedAt,
+        eventsJson: r.latestRunEventsJson,
+    });
+    return {
+        id: r.id,
+        projectId: r.projectId,
+        title: r.title ?? null,
+        sessionMode: normalizeConversationSessionMode({ value: r.sessionMode }),
+        messageCount: Number(r.messageCount),
+        createdAt: Number(r.createdAt),
+        updatedAt: Number(r.updatedAt),
+        ...numberProperty('totalDurationMs', r.totalDurationMs),
+        latestRun: latestRun ?? undefined,
+    };
+}
+/**
+ * Coerces an arbitrary database value to a valid ChatSessionMode, defaulting to 'design'.
+ * Upholds the invariant that no conversation ever carries an unknown session mode.
+ * @param value Raw value read from the session_mode column.
+ * @returns A valid ChatSessionMode: 'chat', 'plan', or 'design'.
+ */
+export function normalizeConversationSessionMode({ value }) {
+    return value === 'chat' || value === 'plan' ? value : 'design';
+}
+/**
+ * @internal Produces a single-key object `{ [key]: number }` only when value is a finite number,
+ * omitting the key entirely otherwise. Generic over `key` (rather than plain `string`) so the
+ * spread of its return type into a caller's object literal carries a real, statically-known
+ * optional property instead of collapsing to an index signature the compiler then can't see
+ * through at the call site.
+ */
+function numberProperty(key, value) {
+    const n = value == null ? undefined : Number(value);
+    return typeof n === 'number' && Number.isFinite(n)
+        ? { [key]: n }
+        : {};
+}
+/** @internal Queries the most recent assistant run summary for a conversation (used by getConversation's per-row fetch path). */
+function latestConversationRunSummary(db, conversationId) {
+    const row = db
+        .prepare(`SELECT run_status AS runStatus,
+              started_at AS startedAt,
+              ended_at AS endedAt,
+              events_json AS eventsJson
+         FROM messages
+        WHERE conversation_id = ?
+          AND role = 'assistant'
+          AND run_status IS NOT NULL
+        ORDER BY position DESC
+        LIMIT 1`)
+        .get(conversationId);
+    return conversationRunSummaryFromRow(row);
+}
+/** @internal Sums terminal-run duration across all succeeded/failed/canceled assistant messages in a conversation. */
+function totalConversationRunDurationMs(db, conversationId) {
+    const row = db
+        .prepare(`SELECT SUM(${terminalRunDurationSql()}) AS totalDurationMs
+         FROM messages
+        WHERE conversation_id = ?
+          AND role = 'assistant'
+          AND run_status IN ('succeeded', 'failed', 'canceled')`)
+        .get(conversationId);
+    return row?.totalDurationMs == null ? undefined : Number(row.totalDurationMs);
+}
+/** @internal Emits the SQL CASE expression that resolves a terminal run's duration: wall-clock diff when both timestamps exist, otherwise the latest usage event's durationMs. */
+function terminalRunDurationSql(alias) {
+    const p = alias ? `${alias}.` : '';
+    return `CASE
+            WHEN ${p}started_at IS NOT NULL AND ${p}ended_at IS NOT NULL THEN
+              CASE
+                WHEN CAST(${p}ended_at AS INTEGER) >= CAST(${p}started_at AS INTEGER)
+                  THEN CAST(${p}ended_at AS INTEGER) - CAST(${p}started_at AS INTEGER)
+                ELSE 0
+              END
+            ELSE (
+              SELECT CASE
+                       WHEN json_extract(usage_event.value, '$.durationMs') >= 0
+                         THEN json_extract(usage_event.value, '$.durationMs')
+                       ELSE 0
+                     END
+                FROM json_each(
+                  CASE
+                    WHEN json_valid(${p}events_json) AND json_type(${p}events_json) = 'array'
+                      THEN ${p}events_json
+                    ELSE '[]'
+                  END
+                ) AS usage_event
+               WHERE usage_event.type = 'object'
+                 AND json_extract(usage_event.value, '$.kind') = 'usage'
+                 AND json_type(usage_event.value, '$.durationMs') IN ('integer', 'real')
+               ORDER BY CAST(usage_event.key AS INTEGER) DESC
+               LIMIT 1
+            )
+          END`;
+}
+/** @internal Converts a raw message row (runStatus/startedAt/endedAt/eventsJson) into a run summary object, or null when no run status is present. */
+function conversationRunSummaryFromRow(row) {
+    if (!row || typeof row.runStatus !== 'string')
+        return null;
+    const startedAt = row.startedAt == null ? undefined : Number(row.startedAt);
+    const endedAt = row.endedAt == null ? undefined : Number(row.endedAt);
+    const usageDurationMs = latestUsageDurationMs(row.eventsJson);
+    const durationMs = Number.isFinite(startedAt) && Number.isFinite(endedAt)
+        ? Math.max(0, endedAt - startedAt)
+        : usageDurationMs;
+    return {
+        status: row.runStatus,
+        ...(Number.isFinite(startedAt) ? { startedAt } : {}),
+        ...(Number.isFinite(endedAt) ? { endedAt } : {}),
+        ...(typeof durationMs === 'number' && Number.isFinite(durationMs)
+            ? { durationMs }
+            : {}),
+    };
+}
+/** @internal Parses events_json to find the most recent usage event's durationMs; returns undefined when events_json is absent or malformed. */
+function latestUsageDurationMs(eventsJson) {
+    if (typeof eventsJson !== 'string' || eventsJson.length === 0)
+        return undefined;
+    try {
+        const events = JSON.parse(eventsJson);
+        if (!Array.isArray(events))
+            return undefined;
+        for (let i = events.length - 1; i >= 0; i -= 1) {
+            const event = events[i];
+            if (event &&
+                typeof event === 'object' &&
+                event.kind === 'usage' &&
+                typeof event.durationMs === 'number' &&
+                Number.isFinite(event.durationMs)) {
+                return Math.max(0, event.durationMs);
+            }
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+/**
+ * Inserts a new conversation row and returns the full conversation record (including run summary).
+ * Normalizes sessionMode before persisting so the stored value is always a valid ChatSessionMode.
+ * @param db Open SQLite database handle.
+ * @param c Conversation fields to insert.
+ */
+export function insertConversation({ db, c }) {
+    db.prepare(`INSERT INTO conversations
+       (id, project_id, title, session_mode, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?)`).run(c.id, c.projectId, c.title ?? null, normalizeConversationSessionMode({ value: c.sessionMode }), c.createdAt, c.updatedAt);
+    return getConversation({ db: db, id: c.id });
+}
+/**
+ * Applies a partial patch to an existing conversation, merging with the current record.
+ * Returns null when the conversation does not exist; otherwise returns the updated record.
+ * @param db Open SQLite database handle.
+ * @param id Conversation id to update.
+ * @param patch Fields to overwrite; sessionMode and updatedAt are normalized before persisting.
+ */
+export function updateConversation({ db, id, patch }) {
+    const existing = getConversation({ db: db, id: id });
+    if (!existing)
+        return null;
+    const merged = {
+        ...existing,
+        ...patch,
+        sessionMode: Object.prototype.hasOwnProperty.call(patch, 'sessionMode')
+            ? normalizeConversationSessionMode({ value: patch.sessionMode })
+            : existing.sessionMode,
+        updatedAt: typeof patch.updatedAt === 'number' ? patch.updatedAt : Date.now(),
+    };
+    db.prepare(`UPDATE conversations
+        SET title = ?, session_mode = ?, updated_at = ? WHERE id = ?`).run(merged.title ?? null, merged.sessionMode, merged.updatedAt, id);
+    return getConversation({ db: db, id: id });
+}
+/**
+ * Removes a conversation row by id. Cascading deletes on messages are handled by the schema.
+ * @param db Open SQLite database handle.
+ * @param id Conversation id to delete.
+ */
+export function deleteConversation({ db, id }) {
+    db.prepare(`DELETE FROM conversations WHERE id = ?`).run(id);
+}
+//# sourceMappingURL=conversations.js.map

package/dist/store/legacy/sqlite/index.d.ts

@@ -0,0 +1,6 @@
+/** Sync legacy conversations/messages over a borrowed host handle. */
+export * from './conversations.js';
+export * from './messages.js';
+export { LEGACY_CHAT_DDL } from './schema.js';
+export type { ChatSessionMode } from '../index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/store/legacy/sqlite/index.js

@@ -0,0 +1,5 @@
+/** Sync legacy conversations/messages over a borrowed host handle. */
+export * from './conversations.js';
+export * from './messages.js';
+export { LEGACY_CHAT_DDL } from './schema.js';
+//# sourceMappingURL=index.js.map

package/dist/store/legacy/sqlite/messages.d.ts

@@ -0,0 +1,156 @@
+/**
+ * @module db/messages/messages
+ * Chat message CRUD, streamed-event append, and telemetry finalization. Imports only the
+ * core/ kernel (SqliteDb, DbRow, ChatSessionMode, parseJsonOrUndef).
+ *
+ * NOTE (neutral port): drops six OD-product JSON columns with no generic engine equivalent —
+ * `comment_attachments_json` (the preview-comments/canvas-annotation feature, explicitly out of
+ * scope for this port), `produced_files_json` and `trace_object_files_json` (design-canvas file
+ * output tracking), `feedback_json` (Critique Theater's scoring feedback), `pre_turn_file_names_json`
+ * (design-canvas per-turn file context), and `applied_plugin_snapshot_json` (OD's plugin host). The
+ * already-ported `schema/migrate.ts` messages table was pre-trimmed to match; see that file and
+ * `source-map.md`'s Design Decisions for the same drop list.
+ */
+import type { SqliteDb } from '@jini-ai/db/sqlite';
+import type { DbRow } from '@jini-ai/db/core';
+import type { ChatSessionMode } from '../index.js';
+/**
+ * Returns all messages for a conversation in ascending position order, with JSON columns parsed.
+ * @param db - Open SQLite connection.
+ * @param conversationId - Conversation whose messages to fetch.
+ * @returns Normalized message objects ready for API serialization.
+ */
+export declare function listMessages({ db, conversationId }: {
+    db: SqliteDb;
+    conversationId: string;
+}): {
+    id: any;
+    role: any;
+    content: any;
+    agentId: any;
+    agentName: any;
+    runId: any;
+    runStatus: any;
+    lastRunEventId: any;
+    events: any;
+    attachments: any;
+    sessionMode: ChatSessionMode | undefined;
+    runContext: any;
+    createdAt: any;
+    startedAt: any;
+    endedAt: any;
+}[];
+/**
+ * Thrown by `upsertMessage` when the caller presents a message `id` together with a
+ * `conversationId` that does not match the conversation the row already belongs to (`id` is a
+ * global primary key, not scoped per-conversation, so this is the only signal available). Rather
+ * than silently updating the wrong conversation's message — or silently doing nothing — while
+ * still bumping the caller-supplied `conversationId`'s `updated_at`, this is a hard failure: it is
+ * always a caller/transport bug (a confused id, or a multi-tenant mixup) and never a legitimate
+ * state to paper over.
+ */
+export declare class MessageConversationMismatchError extends Error {
+    readonly messageId: string;
+    readonly actualConversationId: string;
+    readonly requestedConversationId: string;
+    constructor({ messageId, actualConversationId, requestedConversationId }: {
+        messageId: string;
+        actualConversationId: string;
+        requestedConversationId: string;
+    });
+}
+/**
+ * Inserts or updates a message row and bumps the parent conversation's `updated_at` for recency sorting.
+ * On insert, appends to the end of the conversation's position sequence.
+ * On update, preserves `telemetry_finalized_at` once set (one-way latch).
+ *
+ * The existence check, position calculation, insert-or-update, and conversation `updated_at` bump
+ * all run inside one `better-sqlite3` transaction (opened with `BEGIN IMMEDIATE` via `.immediate()`,
+ * not the default deferred `BEGIN`) so the whole read-then-write sequence is atomic: a concurrent
+ * connection's own `upsertMessage` call for the same conversation cannot read the pre-write
+ * `MAX(position)` while this one is still in flight and thereby compute the same next position —
+ * `BEGIN IMMEDIATE` acquires the write lock before this transaction's first read, so a concurrent
+ * writer blocks (or fails with `SQLITE_BUSY`, per its own busy-timeout policy) until this one
+ * commits, rather than interleaving.
+ *
+ * `id` is the messages table's global primary key (not scoped per-conversation), so a row can only
+ * ever belong to one conversation. If the caller-supplied `m.id` already exists under a different
+ * `conversationId`, this throws {@link MessageConversationMismatchError} instead of silently
+ * updating the wrong conversation's row (or the wrong conversation's `updated_at`).
+ *
+ * @param db - Open SQLite connection.
+ * @param conversationId - Owning conversation id.
+ * @param m - Message fields; JSON sub-fields are stringified automatically.
+ * @returns The normalized, re-fetched message row, or null if the row vanished between write and read.
+ * @throws {MessageConversationMismatchError} if `m.id` already exists under a different conversation.
+ */
+export declare function upsertMessage({ db, conversationId, m }: {
+    db: SqliteDb;
+    conversationId: string;
+    m: DbRow;
+}): {
+    id: any;
+    role: any;
+    content: any;
+    agentId: any;
+    agentName: any;
+    runId: any;
+    runStatus: any;
+    lastRunEventId: any;
+    events: any;
+    attachments: any;
+    sessionMode: ChatSessionMode | undefined;
+    runContext: any;
+    createdAt: any;
+    startedAt: any;
+    endedAt: any;
+} | null;
+/**
+ * Reads whether telemetry has been finalized for a message without loading the full row.
+ * Used to decide whether to enqueue a finalization job.
+ * @returns `{ exists: false }` when the message is not found; otherwise `{ exists: true, finalizedAt }`.
+ */
+export declare function getMessageTelemetryFinalizationState({ db, messageId }: {
+    db: SqliteDb;
+    messageId: string;
+}): {
+    exists: boolean;
+    finalizedAt: number | null;
+};
+/**
+ * Appends a `{ kind: 'status', label, detail? }` event to the message's events array.
+ * Deduplicates consecutive identical status events so the UI does not stutter on repeated flushes.
+ * @param db - Open SQLite connection.
+ * @param messageId - Target message id.
+ * @param event - Must carry a non-empty `label`; `detail` is optional.
+ * @returns The updated events array, or null if the message does not exist or label is empty.
+ */
+export declare function appendMessageStatusEvent({ db, messageId, event }: {
+    db: SqliteDb;
+    messageId: string;
+    event: DbRow;
+}): any[] | null;
+/**
+ * Appends an arbitrary agent event to the message's events array, also streaming `text` deltas
+ * into the `content` column so the message text grows incrementally during a run.
+ * Deduplicates byte-identical consecutive events.
+ * @param db - Open SQLite connection.
+ * @param messageId - Target message id.
+ * @param event - Must carry a non-empty `kind`; `text` field is appended to content when kind is 'text'.
+ * @returns The updated events array, or null if the message does not exist or kind is empty.
+ */
+export declare function appendMessageAgentEvent({ db, messageId, event }: {
+    db: SqliteDb;
+    messageId: string;
+    event: DbRow;
+}): any[] | null;
+/**
+ * Hard-deletes a single message row by id.
+ * @param db - Open SQLite connection.
+ * @param id - Message id to remove.
+ */
+export declare function deleteMessage({ db, id }: {
+    db: SqliteDb;
+    id: string;
+}): void;
+//# sourceMappingURL=messages.d.ts.map