@wenathlan/devthink 2.0.13 → 2.0.15

package/workbenchmemory.ts

@@ -0,0 +1,104 @@
+/**
+ * workbenchmemory.ts — the devthink workbench memory store (the 1.1.16
+ * surface of the grand merge; split from the extension memory domain on the
+ * platform boundary: the extension memory stays browser-pure, this node
+ * surface keeps the filesystem-backed layered store of the workbench CLI).
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import type { DevThinkPaths } from "./config.ts";
+
+export type MemoryLayer = "session" | "project" | "global";
+
+export type MemoryEntry = {
+  id: string;
+  layer: MemoryLayer;
+  key: string;
+  content: string;
+  createdAt: string;
+  updatedAt: string;
+};
+
+export type MemoryQuery = {
+  key?: string;
+  text?: string;
+  sessionId?: string;
+};
+
+function memoryFile(paths: DevThinkPaths, layer: MemoryLayer, sessionId?: string): string {
+  if (layer === "session") return join(paths.sessions, `${sessionId || "active"}.memory.json`);
+  if (layer === "project") return join(process.cwd(), ".devthink", "project-memory.json");
+  return join(paths.memory, "global-memory.json");
+}
+
+function readEntries(path: string, layer: MemoryLayer): MemoryEntry[] {
+  try {
+    if (!existsSync(path)) return [];
+    const parsed: unknown = JSON.parse(readFileSync(path, "utf8"));
+    return Array.isArray(parsed) ? (parsed as MemoryEntry[]).filter((entry) => entry.layer === layer) : [];
+  } catch {
+    return [];
+  }
+}
+
+function writeEntries(path: string, entries: MemoryEntry[]): void {
+  mkdirSync(join(path, ".."), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(entries, null, 2)}\n`, "utf8");
+}
+
+function normalize(value: string): string {
+  return value.trim().toLowerCase();
+}
+
+function scoreEntry(entry: MemoryEntry, query: MemoryQuery): number {
+  const key = normalize(query.key || "");
+  const text = normalize(query.text || "");
+  let score = 0;
+  if (key && normalize(entry.key) === key) score += 10;
+  if (text && normalize(entry.content).includes(text)) score += 5;
+  if (!key && !text) score = 1;
+  return score;
+}
+
+export function createMemoryStore(paths: DevThinkPaths) {
+  return {
+    remember(entry: Omit<MemoryEntry, "id" | "createdAt" | "updatedAt">): MemoryEntry {
+      const now = new Date().toISOString();
+      const path = memoryFile(paths, entry.layer, entry.layer === "session" ? entry.key : undefined);
+      const entries = readEntries(path, entry.layer);
+      const current = entries.find((item) => item.key === entry.key);
+      const next: MemoryEntry = {
+        id: current?.id || crypto.randomUUID(),
+        ...entry,
+        createdAt: current?.createdAt || now,
+        updatedAt: now,
+      };
+      writeEntries(path, [...entries.filter((item) => item.id !== next.id), next]);
+      return next;
+    },
+    resolve(query: MemoryQuery): MemoryEntry | undefined {
+      const layers: MemoryLayer[] = ["session", "project", "global"];
+      for (const layer of layers) {
+        const entries = readEntries(memoryFile(paths, layer, query.sessionId), layer);
+        const match = entries
+          .map((entry) => ({ entry, score: scoreEntry(entry, query) }))
+          .filter((item) => item.score > 0)
+          .sort((a, b) => b.score - a.score)[0];
+        if (match) return match.entry;
+      }
+      return undefined;
+    },
+    list(layer?: MemoryLayer, sessionId?: string): MemoryEntry[] {
+      const layers: MemoryLayer[] = layer ? [layer] : ["session", "project", "global"];
+      return layers.flatMap((item) => readEntries(memoryFile(paths, item, sessionId), item));
+    },
+  };
+}
+
+export type MemoryStore = ReturnType<typeof createMemoryStore>;
+
+export function memorySummary(store: MemoryStore): string {
+  const entries = store.list();
+  if (!entries.length) return "No local memory entries.";
+  return entries.map((entry) => `${entry.layer}:${entry.key} — ${entry.content}`).join("\n");
+}

package/workbenchsession.ts

@@ -0,0 +1,304 @@
+/**
+ * workbenchsession.ts — the devthink workbench chat sessions (the 1.1.16
+ * surface of the grand merge; split from the extension session domain on
+ * the platform boundary: the extension sessions stay browser-pure, this
+ * node surface keeps the workbench chat session files).
+ */
+/** DevThink session model: one stable identity contract for CLI, gateway, local database, and URL-addressable web state. */
+import { existsSync, readFileSync, readdirSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { ensurePaths, type DevThinkPaths } from "./config.js";
+import type { ChatMessage } from "./providers.ts";
+import { createCompactId } from "./ids.js";
+import { mirrorSession, type StoredSession, type StoredWorkspace } from "./storage.js";
+
+export type SessionSection =
+  | "chat"
+  | "inspector"
+  | "settings"
+  | "memory"
+  | "providers"
+  | "projects"
+  | "routes"
+  | "usage";
+export type SessionTab = {
+  id: string;
+  sessionId: string;
+  workspaceId: string;
+  label: string;
+  provider?: string | undefined;
+  sectionId: SessionSection;
+  createdAt: string;
+  updatedAt: string;
+};
+export type SessionMessage = ChatMessage & {
+  id: string;
+  sessionId: string;
+  workspaceId: string;
+  tabId: string;
+  sectionId: SessionSection;
+  createdAt: string;
+};
+export type Workspace = { id: string; title: string; createdAt: string; updatedAt: string };
+
+export type Session = {
+  id: string;
+  workspaceId: string;
+  title: string;
+  mode: string;
+  model?: string | undefined;
+  provider?: string | undefined;
+  createdAt: string;
+  updatedAt: string;
+  activeTabId: string;
+  tabs: SessionTab[];
+  messages: SessionMessage[];
+};
+
+function sessionPath(paths: DevThinkPaths, id: string): string {
+  return join(paths.sessions, `${id}.json`);
+}
+
+function safeTitle(messages: SessionMessage[]): string {
+  const first = messages.find((message) => message.role === "user");
+  return first?.content.slice(0, 80) || "Untitled session";
+}
+
+function workspacePath(paths: DevThinkPaths, id: string): string {
+  return join(paths.workspaces, `${id}.json`);
+}
+
+function atomicWrite(path: string, value: unknown): void {
+  const temporary = `${path}.${process.pid}.${Date.now()}.tmp`;
+  writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+  renameSync(temporary, path);
+}
+
+function newWorkspace(
+  id = createCompactId("w"),
+  title = "Untitled workspace",
+  now = new Date().toISOString(),
+): Workspace {
+  return { id, title, createdAt: now, updatedAt: now };
+}
+
+function newTab(
+  sessionId: string,
+  workspaceId: string,
+  provider: string | undefined,
+  label: string,
+  sectionId: SessionSection,
+  now: string,
+  id = createCompactId("t"),
+): SessionTab {
+  return { id, sessionId, workspaceId, provider, label, sectionId, createdAt: now, updatedAt: now };
+}
+
+function normalizeSession(raw: Session): Session {
+  const now = raw.updatedAt || new Date().toISOString();
+  const workspaceId = raw.workspaceId || createCompactId("w");
+  const tabs = raw.tabs?.length
+    ? raw.tabs.map((tab) => ({
+        ...tab,
+        sessionId: raw.id,
+        workspaceId,
+        sectionId: tab.sectionId || ("chat" as SessionSection),
+      }))
+    : [newTab(raw.id, workspaceId, raw.provider, raw.title || "Untitled session", "chat", now)];
+  const activeTabId = tabs.some((tab) => tab.id === raw.activeTabId) ? raw.activeTabId : tabs[0].id;
+  const messages = (raw.messages || []).map((message) => ({
+    ...message,
+    id: message.id || createCompactId("m"),
+    sessionId: raw.id,
+    workspaceId,
+    tabId: message.tabId || activeTabId,
+    sectionId: message.sectionId || ("chat" as SessionSection),
+    createdAt: message.createdAt || now,
+  }));
+  return { ...raw, workspaceId, activeTabId, tabs, messages };
+}
+
+function readSession(path: string): Session | undefined {
+  try {
+    if (!existsSync(path)) return undefined;
+    return normalizeSession(JSON.parse(readFileSync(path, "utf8")) as Session);
+  } catch {
+    return undefined;
+  }
+}
+
+function workspaceFor(session: Session): Workspace {
+  const title = session.title === "Untitled session" ? "Untitled workspace" : session.title;
+  return newWorkspace(session.workspaceId, title, session.createdAt);
+}
+
+function saveSession(paths: DevThinkPaths, session: Session): Session {
+  ensurePaths(paths);
+  const normalized = normalizeSession(session);
+  const existing = loadWorkspace(paths, normalized.workspaceId);
+  const workspace = {
+    ...(existing || workspaceFor(normalized)),
+    title: normalized.title === "Untitled session" ? existing?.title || "Untitled workspace" : normalized.title,
+    updatedAt: normalized.updatedAt,
+  };
+  atomicWrite(sessionPath(paths, normalized.id), normalized);
+  atomicWrite(workspacePath(paths, workspace.id), workspace);
+  mirrorSession(paths, workspace as StoredWorkspace, normalized as StoredSession);
+  return normalized;
+}
+
+export function createWorkspace(
+  paths: DevThinkPaths,
+  title = "Untitled workspace",
+  id = createCompactId("w"),
+): Workspace {
+  ensurePaths(paths);
+  const workspace = newWorkspace(id, title);
+  atomicWrite(workspacePath(paths, id), workspace);
+  return workspace;
+}
+
+export function loadWorkspace(paths: DevThinkPaths, id: string): Workspace | undefined {
+  try {
+    if (!existsSync(workspacePath(paths, id))) return undefined;
+    return JSON.parse(readFileSync(workspacePath(paths, id), "utf8")) as Workspace;
+  } catch {
+    return undefined;
+  }
+}
+
+export function createSession(
+  paths: DevThinkPaths,
+  metadata: Pick<Session, "mode" | "model" | "provider"> & {
+    workspaceId?: string | undefined;
+    tabId?: string | undefined;
+    sectionId?: SessionSection;
+    title?: string | undefined;
+  },
+): Session {
+  const now = new Date().toISOString();
+  const id = createCompactId("s");
+  const workspace = metadata.workspaceId
+    ? loadWorkspace(paths, metadata.workspaceId) || createWorkspace(paths, "Untitled workspace", metadata.workspaceId)
+    : createWorkspace(paths);
+  const tab = newTab(
+    id,
+    workspace.id,
+    metadata.provider,
+    metadata.title || "Untitled session",
+    metadata.sectionId || "chat",
+    now,
+    metadata.tabId,
+  );
+  const session: Session = {
+    id,
+    workspaceId: workspace.id,
+    title: metadata.title || "Untitled session",
+    mode: metadata.mode,
+    model: metadata.model,
+    provider: metadata.provider,
+    createdAt: now,
+    updatedAt: now,
+    activeTabId: tab.id,
+    tabs: [tab],
+    messages: [],
+  };
+  return saveSession(paths, session);
+}
+
+export function loadSession(paths: DevThinkPaths, id: string): Session | undefined {
+  const session = readSession(sessionPath(paths, id));
+  return session ? saveSession(paths, session) : undefined;
+}
+
+export function createTab(
+  paths: DevThinkPaths,
+  session: Session,
+  input: {
+    id?: string | undefined;
+    label?: string | undefined;
+    provider?: string | undefined;
+    sectionId?: SessionSection;
+  },
+): Session {
+  const now = new Date().toISOString();
+  const tab = newTab(
+    session.id,
+    session.workspaceId,
+    input.provider || session.provider,
+    input.label || "New session",
+    input.sectionId || "chat",
+    now,
+    input.id,
+  );
+  return saveSession(paths, { ...session, activeTabId: tab.id, updatedAt: now, tabs: [...session.tabs, tab] });
+}
+
+export function updateTab(
+  paths: DevThinkPaths,
+  session: Session,
+  tabId: string,
+  input: { label?: string | undefined; provider?: string | undefined; sectionId?: SessionSection | undefined },
+): Session {
+  const now = new Date().toISOString();
+  const tabs = session.tabs.map((tab) =>
+    tab.id === tabId ? ({ ...tab, ...input, updatedAt: now } as SessionTab) : tab,
+  );
+  if (!tabs.some((tab) => tab.id === tabId)) throw new Error(`Tab not found: ${tabId}`);
+  return saveSession(paths, { ...session, activeTabId: tabId, updatedAt: now, tabs });
+}
+
+export function appendMessage(
+  paths: DevThinkPaths,
+  session: Session,
+  message: ChatMessage,
+  context?: { tabId?: string; sectionId?: SessionSection; id?: string },
+): Session {
+  const now = new Date().toISOString();
+  const tabId = context?.tabId || session.activeTabId;
+  if (!session.tabs.some((tab) => tab.id === tabId)) throw new Error(`Tab not found: ${tabId}`);
+  const nextMessages = [
+    ...session.messages,
+    {
+      ...message,
+      id: context?.id || createCompactId("m"),
+      sessionId: session.id,
+      workspaceId: session.workspaceId,
+      tabId,
+      sectionId: context?.sectionId || "chat",
+      createdAt: now,
+    },
+  ];
+  return saveSession(paths, { ...session, title: safeTitle(nextMessages), updatedAt: now, messages: nextMessages });
+}
+
+export function listSessions(paths: DevThinkPaths): Session[] {
+  if (!existsSync(paths.sessions)) return [];
+  return readdirSync(paths.sessions)
+    .filter((file) => file.endsWith(".json") && !file.endsWith(".memory.json"))
+    .map((file) => readSession(join(paths.sessions, file)))
+    .filter((session): session is Session => Boolean(session))
+    .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+}
+
+export function renderSessionMarkdown(session: Session): string {
+  const lines = [
+    `# ${session.title}`,
+    "",
+    `- Workspace: ${session.workspaceId}`,
+    `- Session: ${session.id}`,
+    `- Active tab: ${session.activeTabId}`,
+    `- Mode: ${session.mode}`,
+    `- Provider: ${session.provider || "not configured"}`,
+    `- Model: ${session.model || "not configured"}`,
+    "",
+  ];
+  for (const message of session.messages) lines.push(`## ${message.role}`, "", message.content, "");
+  return `${lines.join("\n")}\n`;
+}
+
+export function exportSession(paths: DevThinkPaths, id: string, format: "json" | "markdown"): string {
+  const session = loadSession(paths, id);
+  if (!session) throw new Error(`Session not found: ${id}`);
+  return format === "json" ? `${JSON.stringify(session, null, 2)}\n` : renderSessionMarkdown(session);
+}