negotium 0.1.6 → 0.1.8

package/dist/runtime/src/storage/api-topic-brief.ts

@@ -0,0 +1,127 @@
+// Persistent per-topic wiki brief store, backed by shared SQLite.
+// Topic briefs are keyed by topicId and shared across participants.
+//
+// Briefs are injected into AI-invited topic turns at session start. The
+// wiki-archiver updates them post-session.
+import { db } from "#storage/forum-db";
+
+db.exec(`
+  CREATE TABLE IF NOT EXISTS api_topic_brief (
+    topic_id TEXT PRIMARY KEY,
+    brief_md TEXT NOT NULL DEFAULT '',
+    latest_summary_md TEXT,
+    summary_date TEXT,
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+  )
+`);
+
+export interface TopicBrief {
+  topicId: string;
+  /** Lightweight topic brief (300-600 tokens, injected at session start). */
+  briefMd: string;
+  /** Latest session summary markdown (full source-summary). */
+  latestSummaryMd?: string;
+  /** Date of the latest summary (YYYY-MM-DD). */
+  summaryDate?: string;
+  /** ISO-8601 timestamp of last update. */
+  updatedAt: string;
+}
+
+interface BriefRow {
+  topic_id: string;
+  brief_md: string;
+  latest_summary_md: string | null;
+  summary_date: string | null;
+  updated_at: string;
+}
+
+function rowToBrief(r: BriefRow): TopicBrief {
+  return {
+    topicId: r.topic_id,
+    briefMd: r.brief_md,
+    latestSummaryMd: r.latest_summary_md ?? undefined,
+    summaryDate: r.summary_date ?? undefined,
+    updatedAt: r.updated_at,
+  };
+}
+
+/**
+ * Get the topic brief for a given topicId. Returns null when no brief
+ * has been written yet (fresh topic, no archiver run).
+ */
+export function getTopicBrief(topicId: string): TopicBrief | null {
+  const row = db
+    .query(
+      "SELECT topic_id, brief_md, latest_summary_md, summary_date, updated_at FROM api_topic_brief WHERE topic_id = ?",
+    )
+    .get(topicId) as BriefRow | null;
+  if (!row) return null;
+  return rowToBrief(row);
+}
+
+/** Resolve current id-keyed briefs while retaining legacy title-keyed wiki memory. */
+export function resolveTopicBrief(
+  topicId: string,
+  legacyTitle: string,
+): { brief: TopicBrief; storageKey: string } | null {
+  const current = getTopicBrief(topicId);
+  if (current) return { brief: current, storageKey: topicId };
+  const legacy = getTopicBrief(legacyTitle);
+  return legacy ? { brief: legacy, storageKey: legacyTitle } : null;
+}
+
+/**
+ * Upsert the topic brief. `briefMd` and `latestSummaryMd` are
+ * independently optional — callers can update just one field without
+ * wiping the other. `summaryDate` should be the date of the summary
+ * (YYYY-MM-DD), set alongside `latestSummaryMd`.
+ */
+export function setTopicBrief(
+  topicId: string,
+  fields: {
+    briefMd?: string;
+    latestSummaryMd?: string;
+    summaryDate?: string;
+  },
+): TopicBrief {
+  const existing = getTopicBrief(topicId);
+
+  const briefMd = fields.briefMd !== undefined ? fields.briefMd : (existing?.briefMd ?? "");
+  const latestSummaryMd =
+    fields.latestSummaryMd !== undefined
+      ? fields.latestSummaryMd
+      : (existing?.latestSummaryMd ?? null);
+  const summaryDate =
+    fields.summaryDate !== undefined ? fields.summaryDate : (existing?.summaryDate ?? null);
+
+  db.query(
+    `INSERT INTO api_topic_brief
+       (topic_id, brief_md, latest_summary_md, summary_date, updated_at)
+       VALUES (?, ?, ?, ?, datetime('now'))
+     ON CONFLICT(topic_id) DO UPDATE SET
+       brief_md = excluded.brief_md,
+       latest_summary_md = excluded.latest_summary_md,
+       summary_date = excluded.summary_date,
+       updated_at = excluded.updated_at`,
+  ).run(topicId, briefMd, latestSummaryMd, summaryDate);
+
+  return getTopicBrief(topicId)!;
+}
+
+/** Remove a topic's brief row entirely (e.g. on topic hard-delete). */
+export function deleteTopicBrief(topicId: string): void {
+  db.query("DELETE FROM api_topic_brief WHERE topic_id = ?").run(topicId);
+}
+
+/**
+ * List all topic briefs for browsing (wiki UI). Returns briefMd
+ * only (no full summary body) to keep the payload light.
+ */
+export function listTopicBriefs(): TopicBrief[] {
+  const rows = db
+    .query(
+      "SELECT topic_id, brief_md, latest_summary_md, summary_date, updated_at FROM api_topic_brief ORDER BY updated_at DESC",
+    )
+    .all() as BriefRow[];
+  return rows.map(rowToBrief);
+}

package/dist/runtime/src/storage/api-topic-config.ts

@@ -0,0 +1,192 @@
+// Persistent per-topic model/effort/MCP overrides and user locks.
+// SQLite. Mirrors api-topics.ts. This replaces the previous in-memory Map in
+// routes/topic-config.ts, which lost every override on server restart — a
+// regression now that topic config is the canonical path for model/effort
+// switching (the MCP-based direction), not just a transient convenience.
+import { db } from "#storage/forum-db";
+import type { EffortLevel } from "#types";
+
+function tableColumns(table: string): Set<string> {
+  const rows = db.query(`PRAGMA table_info(${table})`).all() as Array<{ name: string }>;
+  return new Set(rows.map((row) => row.name));
+}
+
+function createCanonicalConfigTable(name = "api_topic_config"): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS ${name} (
+      topic_id TEXT PRIMARY KEY REFERENCES api_topics(id) ON DELETE CASCADE,
+      model TEXT,
+      effort TEXT CHECK (effort IS NULL OR effort IN ('low','medium','high','xhigh','max')),
+      mcp TEXT,
+      agent_locked INTEGER NOT NULL DEFAULT 0 CHECK (agent_locked IN (0,1)),
+      model_locked INTEGER NOT NULL DEFAULT 0 CHECK (model_locked IN (0,1)),
+      effort_locked INTEGER NOT NULL DEFAULT 0 CHECK (effort_locked IN (0,1))
+    )
+  `);
+}
+
+const existingConfigColumns = tableColumns("api_topic_config");
+if (existingConfigColumns.size === 0) {
+  createCanonicalConfigTable();
+} else if (
+  existingConfigColumns.has("agent") ||
+  existingConfigColumns.has("agent_pinned") ||
+  existingConfigColumns.has("runtime_locked") ||
+  existingConfigColumns.has("model_pinned") ||
+  existingConfigColumns.has("effort_pinned") ||
+  existingConfigColumns.has("last_shown_agent")
+) {
+  // Complete the old agent-override migration before dropping the column. The
+  // selected agent itself belongs to api_topics; only its user lock belongs here.
+  const topicColumns = tableColumns("api_topics");
+  const agentColumn = topicColumns.has("agent")
+    ? "agent"
+    : topicColumns.has("runtime_agent")
+      ? "runtime_agent"
+      : null;
+  if (agentColumn && existingConfigColumns.has("agent")) {
+    db.exec(
+      `UPDATE api_topics
+       SET ${agentColumn} = (
+         SELECT c.agent FROM api_topic_config c WHERE c.topic_id = api_topics.id
+       )
+       WHERE ${agentColumn} IS NULL
+         AND EXISTS (
+           SELECT 1 FROM api_topic_config c
+           WHERE c.topic_id = api_topics.id AND c.agent IS NOT NULL
+         )`,
+    );
+  }
+
+  const previousForeignKeys = db
+    .query<{ foreign_keys: number }, []>("PRAGMA foreign_keys")
+    .get()?.foreign_keys;
+  db.exec("PRAGMA foreign_keys = OFF");
+  try {
+    const agentLockSource = existingConfigColumns.has("runtime_locked")
+      ? "runtime_locked"
+      : existingConfigColumns.has("agent_pinned")
+        ? "agent_pinned"
+        : "0";
+    const modelLockSource = existingConfigColumns.has("model_locked")
+      ? "model_locked"
+      : existingConfigColumns.has("model_pinned")
+        ? "model_pinned"
+        : "0";
+    const effortLockSource = existingConfigColumns.has("effort_locked")
+      ? "effort_locked"
+      : existingConfigColumns.has("effort_pinned")
+        ? "effort_pinned"
+        : "0";
+    db.transaction(() => {
+      createCanonicalConfigTable("api_topic_config_next");
+      db.exec(`
+        INSERT INTO api_topic_config_next
+          (topic_id, model, effort, mcp, agent_locked, model_locked, effort_locked)
+        SELECT
+          topic_id,
+          model,
+          effort,
+          mcp,
+          COALESCE(${agentLockSource}, 0),
+          COALESCE(${modelLockSource}, 0),
+          COALESCE(${effortLockSource}, 0)
+        FROM api_topic_config
+        WHERE EXISTS (SELECT 1 FROM api_topics t WHERE t.id = api_topic_config.topic_id)
+      `);
+      db.exec("DROP TABLE api_topic_config");
+      db.exec("ALTER TABLE api_topic_config_next RENAME TO api_topic_config");
+    })();
+  } finally {
+    db.exec(`PRAGMA foreign_keys = ${previousForeignKeys ? "ON" : "OFF"}`);
+  }
+} else {
+  createCanonicalConfigTable();
+}
+
+export interface TopicConfig {
+  model?: string;
+  effort?: EffortLevel;
+  mcp?: string[]; // enabled optional MCP server names
+  // Per-field user locks: when true, AI self-config cannot override the field.
+  agentLocked?: boolean;
+  modelLocked?: boolean;
+  effortLocked?: boolean;
+}
+
+interface ConfigRow {
+  topic_id: string;
+  model: string | null;
+  effort: string | null;
+  mcp: string | null;
+  agent_locked: number;
+  model_locked: number;
+  effort_locked: number;
+}
+
+function rowToConfig(r: ConfigRow): TopicConfig {
+  const cfg: TopicConfig = {};
+  if (r.model) cfg.model = r.model;
+  if (r.effort) cfg.effort = r.effort as EffortLevel;
+  if (r.mcp) {
+    try {
+      const parsed = JSON.parse(r.mcp);
+      if (Array.isArray(parsed)) cfg.mcp = parsed as string[];
+    } catch {
+      // corrupt JSON — treat as no mcp override
+    }
+  }
+  if (r.agent_locked) cfg.agentLocked = true;
+  if (r.model_locked) cfg.modelLocked = true;
+  if (r.effort_locked) cfg.effortLocked = true;
+  return cfg;
+}
+
+/**
+ * Per-topic override set via `PATCH /config` (and, going forward, the MCP
+ * self-config tools). Returns `undefined` when the topic has no stored row,
+ * so callers can distinguish "no override" from "override with empty fields".
+ */
+export function getApiTopicConfig(topicId: string): TopicConfig | undefined {
+  const row = db
+    .query(
+      "SELECT topic_id, model, effort, mcp, agent_locked, model_locked, effort_locked FROM api_topic_config WHERE topic_id = ?",
+    )
+    .get(topicId) as ConfigRow | null;
+  if (!row) return undefined;
+  const config = rowToConfig(row);
+  return Object.keys(config).length > 0 ? config : undefined;
+}
+
+/**
+ * Upsert the full override for a topic. Fields set to `undefined` are cleared
+ * (stored as SQL NULL), matching the previous Map semantics where the route
+ * built a complete `updated` object before persisting.
+ */
+export function setApiTopicConfig(topicId: string, config: TopicConfig): void {
+  db.query(
+    `INSERT INTO api_topic_config
+       (topic_id, model, effort, mcp, agent_locked, model_locked, effort_locked)
+       VALUES (?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(topic_id) DO UPDATE SET
+       model = excluded.model,
+       effort = excluded.effort,
+       mcp = excluded.mcp,
+       agent_locked = excluded.agent_locked,
+       model_locked = excluded.model_locked,
+       effort_locked = excluded.effort_locked`,
+  ).run(
+    topicId,
+    config.model ?? null,
+    config.effort ?? null,
+    config.mcp ? JSON.stringify(config.mcp) : null,
+    config.agentLocked ? 1 : 0,
+    config.modelLocked ? 1 : 0,
+    config.effortLocked ? 1 : 0,
+  );
+}
+
+/** Remove a topic's override row entirely (e.g. on topic hard-delete). */
+export function deleteApiTopicConfig(topicId: string): void {
+  db.query("DELETE FROM api_topic_config WHERE topic_id = ?").run(topicId);
+}