Add Dyad Update Management Guide and custom hooks for smart context

dyad-backup-20251205-195655/custom/hooks/useSmartContext.ts

@@ -0,0 +1,60 @@
+import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
+import { IpcClient } from "@/ipc/ipc_client";
+import type {
+  SmartContextMeta,
+  SmartContextSnippet,
+  SmartContextRetrieveResult,
+} from "@/ipc/ipc_types";
+
+export function useSmartContextMeta(chatId: number) {
+  return useQuery<SmartContextMeta, Error>({
+    queryKey: ["smart-context", chatId, "meta"],
+    queryFn: async () => {
+      const ipc = IpcClient.getInstance();
+      return ipc.getSmartContextMeta(chatId);
+    },
+    enabled: !!chatId,
+  });
+}
+
+export function useRetrieveSmartContext(
+  chatId: number,
+  query: string,
+  budgetTokens: number,
+) {
+  return useQuery<SmartContextRetrieveResult, Error>({
+    queryKey: ["smart-context", chatId, "retrieve", query, budgetTokens],
+    queryFn: async () => {
+      const ipc = IpcClient.getInstance();
+      return ipc.retrieveSmartContext({ chatId, query, budgetTokens });
+    },
+    enabled: !!chatId && !!query && budgetTokens > 0,
+    meta: { showErrorToast: true },
+  });
+}
+
+export function useUpsertSmartContextSnippets(chatId: number) {
+  const qc = useQueryClient();
+  return useMutation<number, Error, Array<Pick<SmartContextSnippet, "text" | "source">>>({
+    mutationFn: async (snippets) => {
+      const ipc = IpcClient.getInstance();
+      return ipc.upsertSmartContextSnippets(chatId, snippets);
+    },
+    onSuccess: () => {
+      qc.invalidateQueries({ queryKey: ["smart-context", chatId] });
+    },
+  });
+}
+
+export function useUpdateRollingSummary(chatId: number) {
+  const qc = useQueryClient();
+  return useMutation<SmartContextMeta, Error, { summary: string }>({
+    mutationFn: async ({ summary }) => {
+      const ipc = IpcClient.getInstance();
+      return ipc.updateSmartContextRollingSummary(chatId, summary);
+    },
+    onSuccess: () => {
+      qc.invalidateQueries({ queryKey: ["smart-context", chatId, "meta"] });
+    },
+  });
+}

dyad-backup-20251205-195655/custom/index.ts

@@ -0,0 +1,18 @@
+// Custom modules for moreminimore-vibe
+// This file exports all custom functionality to make imports easier
+
+// Custom hooks
+export { useSmartContextMeta, useRetrieveSmartContext, useUpsertSmartContextSnippets, useUpdateRollingSummary } from './hooks/useSmartContext';
+
+// Custom IPC handlers (these will need to be imported and registered in the main process)
+export { registerSmartContextHandlers } from './ipc/smart_context_handlers';
+
+// Custom utilities
+export * from './utils/smart_context_store';
+
+// Re-export types that might be needed
+export type {
+  SmartContextMeta,
+  SmartContextSnippet,
+  SmartContextRetrieveResult,
+} from '../ipc/ipc_types';

dyad-backup-20251205-195655/custom/ipc/smart_context_handlers.ts

@@ -0,0 +1,65 @@
+import log from "electron-log";
+import { createLoggedHandler } from "./safe_handle";
+import {
+  appendSnippets,
+  readMeta,
+  retrieveContext,
+  updateRollingSummary,
+  rebuildIndex,
+  type SmartContextSnippet,
+  type SmartContextMeta,
+} from "../utils/smart_context_store";
+
+const logger = log.scope("smart_context_handlers");
+const handle = createLoggedHandler(logger);
+
+export interface UpsertSnippetsParams {
+  chatId: number;
+  snippets: Array<{
+    text: string;
+    source:
+      | { type: "message"; messageIndex?: number }
+      | { type: "code"; filePath: string }
+      | { type: "attachment"; name: string; mime?: string }
+      | { type: "other"; label?: string };
+  }>;
+}
+
+export interface RetrieveContextParams {
+  chatId: number;
+  query: string;
+  budgetTokens: number;
+}
+
+export function registerSmartContextHandlers() {
+  handle("sc:get-meta", async (_event, chatId: number): Promise<SmartContextMeta> => {
+    return readMeta(chatId);
+  });
+
+  handle(
+    "sc:upsert-snippets",
+    async (_event, params: UpsertSnippetsParams): Promise<number> => {
+      const count = await appendSnippets(params.chatId, params.snippets);
+      return count;
+    },
+  );
+
+  handle(
+    "sc:update-rolling-summary",
+    async (_event, params: { chatId: number; summary: string }): Promise<SmartContextMeta> => {
+      return updateRollingSummary(params.chatId, params.summary);
+    },
+  );
+
+  handle(
+    "sc:retrieve-context",
+    async (_event, params: RetrieveContextParams) => {
+      return retrieveContext(params.chatId, params.query, params.budgetTokens);
+    },
+  );
+
+  handle("sc:rebuild-index", async (_event, chatId: number) => {
+    await rebuildIndex(chatId);
+    return { ok: true } as const;
+  });
+}

dyad-backup-20251205-195655/custom/utils/smart_context_store.ts

@@ -0,0 +1,212 @@
+import path from "node:path";
+import { promises as fs } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { getUserDataPath } from "../../paths/paths";
+import { estimateTokens } from "./token_utils";
+
+export type SmartContextSource =
+  | { type: "message"; messageIndex?: number }
+  | { type: "code"; filePath: string }
+  | { type: "attachment"; name: string; mime?: string }
+  | { type: "other"; label?: string };
+
+export interface SmartContextSnippet {
+  id: string;
+  text: string;
+  score?: number;
+  source: SmartContextSource;
+  ts: number; // epoch ms
+  tokens?: number;
+}
+
+export interface SmartContextMetaConfig {
+  maxSnippets?: number;
+}
+
+export interface SmartContextMeta {
+  entityId: string; // e.g., chatId as string
+  updatedAt: number;
+  rollingSummary?: string;
+  summaryTokens?: number;
+  config?: SmartContextMetaConfig;
+}
+
+function getThreadDir(chatId: number): string {
+  const base = path.join(getUserDataPath(), "smart-context", "threads");
+  return path.join(base, String(chatId));
+}
+
+function getMetaPath(chatId: number): string {
+  return path.join(getThreadDir(chatId), "meta.json");
+}
+
+function getSnippetsPath(chatId: number): string {
+  return path.join(getThreadDir(chatId), "snippets.jsonl");
+}
+
+async function ensureDir(dir: string): Promise<void> {
+  await fs.mkdir(dir, { recursive: true });
+}
+
+export async function readMeta(chatId: number): Promise<SmartContextMeta> {
+  const dir = getThreadDir(chatId);
+  await ensureDir(dir);
+  const metaPath = getMetaPath(chatId);
+  try {
+    const raw = await fs.readFile(metaPath, "utf8");
+    const meta = JSON.parse(raw) as SmartContextMeta;
+    return meta;
+  } catch {
+    const fresh: SmartContextMeta = {
+      entityId: String(chatId),
+      updatedAt: Date.now(),
+      rollingSummary: "",
+      summaryTokens: 0,
+      config: { maxSnippets: 400 },
+    };
+    await fs.writeFile(metaPath, JSON.stringify(fresh, null, 2), "utf8");
+    return fresh;
+  }
+}
+
+export async function writeMeta(
+  chatId: number,
+  meta: SmartContextMeta,
+): Promise<void> {
+  const dir = getThreadDir(chatId);
+  await ensureDir(dir);
+  const metaPath = getMetaPath(chatId);
+  const updated: SmartContextMeta = {
+    ...meta,
+    entityId: String(chatId),
+    updatedAt: Date.now(),
+  };
+  await fs.writeFile(metaPath, JSON.stringify(updated, null, 2), "utf8");
+}
+
+export async function updateRollingSummary(
+  chatId: number,
+  summary: string,
+): Promise<SmartContextMeta> {
+  const meta = await readMeta(chatId);
+  const summaryTokens = estimateTokens(summary || "");
+  const next: SmartContextMeta = {
+    ...meta,
+    rollingSummary: summary,
+    summaryTokens,
+  };
+  await writeMeta(chatId, next);
+  return next;
+}
+
+export async function appendSnippets(
+  chatId: number,
+  snippets: Omit<SmartContextSnippet, "id" | "ts" | "tokens">[],
+): Promise<number> {
+  const dir = getThreadDir(chatId);
+  await ensureDir(dir);
+  const snippetsPath = getSnippetsPath(chatId);
+  const withDefaults: SmartContextSnippet[] = snippets.map((s) => ({
+    id: randomUUID(),
+    ts: Date.now(),
+    tokens: estimateTokens(s.text),
+    ...s,
+  }));
+  const lines = withDefaults.map((obj) => JSON.stringify(obj)).join("\n");
+  await fs.appendFile(snippetsPath, (lines ? lines + "\n" : ""), "utf8");
+
+  // prune if exceeded max
+  const meta = await readMeta(chatId);
+  const maxSnippets = meta.config?.maxSnippets ?? 400;
+  try {
+    const file = await fs.readFile(snippetsPath, "utf8");
+    const allLines = file.split("\n").filter(Boolean);
+    if (allLines.length > maxSnippets) {
+      const toKeep = allLines.slice(allLines.length - maxSnippets);
+      await fs.writeFile(snippetsPath, toKeep.join("\n") + "\n", "utf8");
+      return toKeep.length;
+    }
+    return allLines.length;
+  } catch {
+    return withDefaults.length;
+  }
+}
+
+export async function readAllSnippets(chatId: number): Promise<SmartContextSnippet[]> {
+  try {
+    const raw = await fs.readFile(getSnippetsPath(chatId), "utf8");
+    return raw
+      .split("\n")
+      .filter(Boolean)
+      .map((line) => JSON.parse(line) as SmartContextSnippet);
+  } catch {
+    return [];
+  }
+}
+
+function normalize(value: number, min: number, max: number): number {
+  if (max === min) return 0;
+  return (value - min) / (max - min);
+}
+
+function keywordScore(text: string, query: string): number {
+  const toTokens = (s: string) =>
+    s
+      .toLowerCase()
+      .replace(/[^a-z0-9_\- ]+/g, " ")
+      .split(/\s+/)
+      .filter(Boolean);
+  const qTokens = new Set(toTokens(query));
+  const tTokens = toTokens(text);
+  if (qTokens.size === 0 || tTokens.length === 0) return 0;
+  let hits = 0;
+  for (const tok of tTokens) if (qTokens.has(tok)) hits++;
+  return hits / tTokens.length; // simple overlap ratio
+}
+
+export interface RetrieveContextResult {
+  rollingSummary?: string;
+  usedTokens: number;
+  snippets: SmartContextSnippet[];
+}
+
+export async function retrieveContext(
+  chatId: number,
+  query: string,
+  budgetTokens: number,
+): Promise<RetrieveContextResult> {
+  const meta = await readMeta(chatId);
+  const snippets = await readAllSnippets(chatId);
+  const now = Date.now();
+  let minTs = now;
+  let maxTs = 0;
+  for (const s of snippets) {
+    if (s.ts < minTs) minTs = s.ts;
+    if (s.ts > maxTs) maxTs = s.ts;
+  }
+  const scored = snippets.map((s) => {
+    const recency = normalize(s.ts, minTs, maxTs);
+    const kw = keywordScore(s.text, query);
+    const base = 0.6 * kw + 0.4 * recency;
+    const score = base;
+    return { ...s, score } as SmartContextSnippet;
+  });
+  scored.sort((a, b) => (b.score ?? 0) - (a.score ?? 0));
+
+  const picked: SmartContextSnippet[] = [];
+  let usedTokens = 0;
+  for (const s of scored) {
+    const t = s.tokens ?? estimateTokens(s.text);
+    if (usedTokens + t > budgetTokens) break;
+    picked.push(s);
+    usedTokens += t;
+  }
+
+  const rollingSummary = meta.rollingSummary || "";
+  return { rollingSummary, usedTokens, snippets: picked };
+}
+
+export async function rebuildIndex(_chatId: number): Promise<void> {
+  // Placeholder for future embedding/vector index rebuild.
+  return;
+}