@yugenlab/vaayu 0.1.0

package/chunks/chunk-L7JICQBW.js

@@ -0,0 +1,1006 @@
+import {
+  DatabaseManager,
+  initAgentSchema
+} from "./chunk-U6OLJ36B.js";
+import {
+  SessionError,
+  getChitraguptaHome
+} from "./chunk-KC6NRZ7U.js";
+
+// ../chitragupta/packages/smriti/src/session-store.ts
+import fs from "fs";
+import { renameSync as nodeRenameSync } from "node:fs";
+import path from "path";
+import crypto from "crypto";
+
+// ../chitragupta/packages/smriti/src/markdown-parser.ts
+function parseFrontmatter(yaml) {
+  const result = {};
+  const lines = yaml.split("\n");
+  let currentKey = null;
+  let currentArray = null;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    if (trimmed.startsWith("- ") && currentKey && currentArray !== null) {
+      currentArray.push(trimmed.slice(2).trim());
+      continue;
+    }
+    if (currentKey && currentArray !== null) {
+      result[currentKey] = currentArray;
+      currentArray = null;
+      currentKey = null;
+    }
+    const colonIdx = trimmed.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = trimmed.slice(0, colonIdx).trim();
+    const rawValue = trimmed.slice(colonIdx + 1).trim();
+    if (rawValue === "" || rawValue === void 0) {
+      currentKey = key;
+      currentArray = [];
+      continue;
+    }
+    if (rawValue.startsWith("[") && rawValue.endsWith("]")) {
+      const inner = rawValue.slice(1, -1);
+      if (inner.trim() === "") {
+        result[key] = [];
+      } else {
+        result[key] = inner.split(",").map((s) => parseScalar(s.trim()));
+      }
+      continue;
+    }
+    result[key] = parseScalar(rawValue);
+  }
+  if (currentKey && currentArray !== null) {
+    result[currentKey] = currentArray;
+  }
+  return result;
+}
+function parseScalar(value) {
+  if (value === "null" || value === "~") return null;
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (value.startsWith('"') && value.endsWith('"')) {
+    return value.slice(1, -1).replace(/\\"/g, '"');
+  }
+  if (value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  const num = Number(value);
+  if (!Number.isNaN(num) && value !== "") return num;
+  return value;
+}
+function parseSessionMarkdown(content) {
+  if (!content || typeof content !== "string") {
+    throw new SessionError("Cannot parse empty or non-string session content");
+  }
+  const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!fmMatch) {
+    throw new SessionError("Session file missing YAML frontmatter (--- delimiters)");
+  }
+  const rawMeta = parseFrontmatter(fmMatch[1]);
+  const meta = buildSessionMeta(rawMeta);
+  const body = content.slice(fmMatch[0].length).trim();
+  const turns = parseTurns(body);
+  return { meta, turns };
+}
+function buildSessionMeta(raw) {
+  return {
+    id: String(raw.id ?? ""),
+    title: String(raw.title ?? "Untitled Session"),
+    created: String(raw.created ?? (/* @__PURE__ */ new Date()).toISOString()),
+    updated: String(raw.updated ?? (/* @__PURE__ */ new Date()).toISOString()),
+    agent: String(raw.agent ?? "chitragupta"),
+    model: String(raw.model ?? "unknown"),
+    project: String(raw.project ?? ""),
+    parent: raw.parent != null ? String(raw.parent) : null,
+    branch: raw.branch != null ? String(raw.branch) : null,
+    tags: Array.isArray(raw.tags) ? raw.tags.map(String) : [],
+    totalCost: Number(raw.totalCost ?? 0),
+    totalTokens: Number(raw.totalTokens ?? 0)
+  };
+}
+function parseTurns(body) {
+  if (!body) return [];
+  body = stripFooter(body);
+  const turnPattern = /^## Turn (\d+) — (user|assistant)(?:\s+\(([^)]*)\))?/gm;
+  const turns = [];
+  const matches = [];
+  let match;
+  while ((match = turnPattern.exec(body)) !== null) {
+    matches.push({
+      index: match.index,
+      turnNumber: parseInt(match[1], 10),
+      role: match[2],
+      meta: match[3]
+    });
+  }
+  for (let i = 0; i < matches.length; i++) {
+    const m = matches[i];
+    const headerEnd = body.indexOf("\n", m.index);
+    const contentStart = headerEnd + 1;
+    const contentEnd = i + 1 < matches.length ? matches[i + 1].index : body.length;
+    const rawContent = body.slice(contentStart, contentEnd).trim();
+    let agent;
+    let model;
+    if (m.meta) {
+      const parts = m.meta.split(",").map((s) => s.trim());
+      for (const part of parts) {
+        const [k, v] = part.split(":").map((s) => s.trim());
+        if (k === "agent") agent = v;
+        if (k === "model") model = v;
+      }
+    }
+    const { content, toolCalls } = parseContentAndToolCalls(rawContent);
+    const unescapedContent = content.replace(/^\\(## Turn \d+)/gm, "$1").replace(/^\\---$/gm, "---").replace(/\\<\/(details|summary)>/gi, "</$1>");
+    const turn = {
+      turnNumber: m.turnNumber,
+      role: m.role,
+      content: unescapedContent
+    };
+    if (agent) turn.agent = agent;
+    if (model) turn.model = model;
+    if (toolCalls.length > 0) turn.toolCalls = toolCalls;
+    turns.push(turn);
+  }
+  return turns;
+}
+function stripFooter(body) {
+  const footerPattern = /\n---\n\n\*Session [^*]+\*\s*$/;
+  return body.replace(footerPattern, "");
+}
+function parseContentAndToolCalls(raw) {
+  const toolPattern = /^### Tool: (.+)$/gm;
+  const toolMatches = [];
+  let match;
+  while ((match = toolPattern.exec(raw)) !== null) {
+    toolMatches.push({ index: match.index, name: match[1].trim() });
+  }
+  if (toolMatches.length === 0) {
+    return { content: raw, toolCalls: [] };
+  }
+  const content = raw.slice(0, toolMatches[0].index).trim();
+  const toolCalls = [];
+  for (let i = 0; i < toolMatches.length; i++) {
+    const tm = toolMatches[i];
+    const headerEnd = raw.indexOf("\n", tm.index);
+    const sectionStart = headerEnd + 1;
+    const sectionEnd = i + 1 < toolMatches.length ? toolMatches[i + 1].index : raw.length;
+    const section = raw.slice(sectionStart, sectionEnd).trim();
+    toolCalls.push(parseToolCallSection(tm.name, section));
+  }
+  return { content, toolCalls };
+}
+function parseToolCallSection(name, section) {
+  let input = "";
+  let result = "";
+  let isError = false;
+  const inputMatch = section.match(/\*\*Input:\*\*\s*\n```(?:json)?\n([\s\S]*?)```/);
+  if (inputMatch) {
+    input = inputMatch[1].trim();
+  }
+  const detailsMatch = section.match(/<details>\s*\n<summary>(.*?)<\/summary>\s*\n([\s\S]*?)<\/details>/);
+  if (detailsMatch) {
+    const summaryText = detailsMatch[1].trim();
+    isError = summaryText.toLowerCase().includes("error");
+    const codeMatch = detailsMatch[2].match(/```(?:\w*)\n([\s\S]*?)```/);
+    if (codeMatch) {
+      result = codeMatch[1].trim();
+    } else {
+      result = detailsMatch[2].trim();
+    }
+  }
+  const toolCall = { name, input, result };
+  if (isError) toolCall.isError = true;
+  return toolCall;
+}
+
+// ../chitragupta/packages/smriti/src/markdown-writer.ts
+function writeFrontmatter(meta) {
+  const lines = [];
+  lines.push("---");
+  lines.push(`id: ${meta.id}`);
+  lines.push(`title: "${meta.title.replace(/"/g, '\\"')}"`);
+  lines.push(`created: ${meta.created}`);
+  lines.push(`updated: ${meta.updated}`);
+  lines.push(`agent: ${meta.agent}`);
+  lines.push(`model: ${meta.model}`);
+  lines.push(`project: ${meta.project}`);
+  lines.push(`parent: ${meta.parent ?? "null"}`);
+  lines.push(`branch: ${meta.branch ?? "null"}`);
+  if (meta.tags.length === 0) {
+    lines.push("tags: []");
+  } else {
+    lines.push("tags:");
+    for (const tag of meta.tags) {
+      lines.push(`  - ${tag}`);
+    }
+  }
+  lines.push(`totalCost: ${meta.totalCost}`);
+  lines.push(`totalTokens: ${meta.totalTokens}`);
+  lines.push("---");
+  return lines.join("\n");
+}
+function writeToolCall(toolCall) {
+  const lines = [];
+  lines.push(`### Tool: ${toolCall.name}`);
+  lines.push("");
+  lines.push("**Input:**");
+  lines.push("```json");
+  lines.push(toolCall.input);
+  lines.push("```");
+  lines.push("");
+  const summaryLabel = toolCall.isError ? "Error" : "Result";
+  lines.push("<details>");
+  lines.push(`<summary>${summaryLabel}</summary>`);
+  lines.push("");
+  lines.push("```");
+  lines.push(toolCall.result);
+  lines.push("```");
+  lines.push("");
+  lines.push("</details>");
+  return lines.join("\n");
+}
+function writeTurn(turn) {
+  const lines = [];
+  let heading = `## Turn ${turn.turnNumber} \u2014 ${turn.role}`;
+  const metaParts = [];
+  if (turn.agent) metaParts.push(`agent: ${turn.agent}`);
+  if (turn.model) metaParts.push(`model: ${turn.model}`);
+  if (metaParts.length > 0) {
+    heading += ` (${metaParts.join(", ")})`;
+  }
+  lines.push(heading);
+  lines.push("");
+  const escaped = turn.content.replace(/^(## Turn \d+)/gm, "\\$1").replace(/^---$/gm, "\\---").replace(/<\/(details|summary)>/gi, "\\</$1>");
+  lines.push(escaped);
+  if (turn.toolCalls && turn.toolCalls.length > 0) {
+    lines.push("");
+    for (const toolCall of turn.toolCalls) {
+      lines.push(writeToolCall(toolCall));
+      lines.push("");
+    }
+  }
+  return lines.join("\n");
+}
+function writeFooter(meta) {
+  const lines = [];
+  lines.push("---");
+  lines.push("");
+  lines.push(`*Session ${meta.id} | ${meta.agent} | ${meta.model} | Cost: $${meta.totalCost.toFixed(4)} | Tokens: ${meta.totalTokens}*`);
+  return lines.join("\n");
+}
+function writeSessionMarkdown(session) {
+  const parts = [];
+  parts.push(writeFrontmatter(session.meta));
+  parts.push("");
+  for (const turn of session.turns) {
+    parts.push(writeTurn(turn));
+    parts.push("");
+  }
+  parts.push(writeFooter(session.meta));
+  parts.push("");
+  return parts.join("\n");
+}
+function writeTurnMarkdown(turn) {
+  return writeTurn(turn);
+}
+
+// ../chitragupta/packages/smriti/src/session-store.ts
+function atomicRename(tmpPath, targetPath) {
+  try {
+    nodeRenameSync(tmpPath, targetPath);
+  } catch {
+    fs.writeFileSync(targetPath, fs.readFileSync(tmpPath, "utf-8"), "utf-8");
+    try {
+      fs.unlinkSync(tmpPath);
+    } catch {
+    }
+  }
+}
+var SESSION_CACHE_MAX = 500;
+var SESSION_CACHE_MAX_BYTES = 25 * 1024 * 1024;
+var sessionCache = /* @__PURE__ */ new Map();
+var sessionCacheSizes = /* @__PURE__ */ new Map();
+var sessionCacheBytes = 0;
+function estimateSessionBytes(session) {
+  let bytes = 200;
+  for (const turn of session.turns) {
+    bytes += Buffer.byteLength(turn.content, "utf-8") + 50;
+  }
+  return bytes;
+}
+function cacheKey(id, project) {
+  return `${id}:${project}`;
+}
+function cacheGet(id, project) {
+  const key = cacheKey(id, project);
+  const entry = sessionCache.get(key);
+  if (!entry) return void 0;
+  const size = sessionCacheSizes.get(key) ?? 0;
+  sessionCache.delete(key);
+  sessionCacheSizes.delete(key);
+  sessionCache.set(key, entry);
+  sessionCacheSizes.set(key, size);
+  return entry;
+}
+function cachePut(id, project, session) {
+  const key = cacheKey(id, project);
+  const existingSize = sessionCacheSizes.get(key) ?? 0;
+  sessionCache.delete(key);
+  sessionCacheSizes.delete(key);
+  sessionCacheBytes -= existingSize;
+  const newSize = estimateSessionBytes(session);
+  while ((sessionCache.size >= SESSION_CACHE_MAX || sessionCacheBytes + newSize > SESSION_CACHE_MAX_BYTES) && sessionCache.size > 0) {
+    const oldest = sessionCache.keys().next().value;
+    if (oldest === void 0) break;
+    const evictedSize = sessionCacheSizes.get(oldest) ?? 0;
+    sessionCache.delete(oldest);
+    sessionCacheSizes.delete(oldest);
+    sessionCacheBytes -= evictedSize;
+  }
+  sessionCache.set(key, session);
+  sessionCacheSizes.set(key, newSize);
+  sessionCacheBytes += newSize;
+}
+function cacheInvalidate(id, project) {
+  const key = cacheKey(id, project);
+  const size = sessionCacheSizes.get(key) ?? 0;
+  sessionCache.delete(key);
+  sessionCacheSizes.delete(key);
+  sessionCacheBytes -= size;
+}
+function _resetSessionCache() {
+  sessionCache.clear();
+  sessionCacheSizes.clear();
+  sessionCacheBytes = 0;
+}
+function hashProject(project) {
+  return crypto.createHash("sha256").update(project).digest("hex").slice(0, 12);
+}
+function generateSessionId(project) {
+  const now = /* @__PURE__ */ new Date();
+  const yyyy = now.getFullYear().toString();
+  const mm = (now.getMonth() + 1).toString().padStart(2, "0");
+  const dd = now.getDate().toString().padStart(2, "0");
+  const dateStr = `${yyyy}-${mm}-${dd}`;
+  const projHash = hashProject(project).slice(0, 8);
+  const baseId = `session-${dateStr}-${projHash}`;
+  const projectDir = getProjectSessionDir(project);
+  const yearMonthDir = path.join(projectDir, yyyy, mm);
+  fs.mkdirSync(yearMonthDir, { recursive: true });
+  const basePath = path.join(yearMonthDir, `${baseId}.md`);
+  if (!fs.existsSync(basePath)) {
+    return {
+      id: baseId,
+      filePath: path.join("sessions", hashProject(project), yyyy, mm, `${baseId}.md`)
+    };
+  }
+  let counter = 2;
+  while (fs.existsSync(path.join(yearMonthDir, `${baseId}-${counter}.md`))) {
+    counter++;
+  }
+  const id = `${baseId}-${counter}`;
+  return {
+    id,
+    filePath: path.join("sessions", hashProject(project), yyyy, mm, `${id}.md`)
+  };
+}
+function getSessionsRoot() {
+  return path.join(getChitraguptaHome(), "sessions");
+}
+function getProjectSessionDir(project) {
+  return path.join(getSessionsRoot(), hashProject(project));
+}
+function resolveSessionPath(id, project) {
+  const projectDir = getProjectSessionDir(project);
+  const dateMatch = id.match(/^session-(\d{4})-(\d{2})-\d{2}/);
+  if (dateMatch) {
+    const newPath = path.join(projectDir, dateMatch[1], dateMatch[2], `${id}.md`);
+    if (fs.existsSync(newPath)) return newPath;
+  }
+  const oldPath = path.join(projectDir, `${id}.md`);
+  if (fs.existsSync(oldPath)) return oldPath;
+  if (dateMatch) {
+    return path.join(projectDir, dateMatch[1], dateMatch[2], `${id}.md`);
+  }
+  return oldPath;
+}
+function patchFrontmatterUpdated(content, updatedIso) {
+  const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!fmMatch) return content;
+  const frontmatter = fmMatch[1];
+  if (!/^updated:\s/m.test(frontmatter)) return content;
+  const patchedFrontmatter = frontmatter.replace(
+    /^updated:\s.*$/m,
+    `updated: ${updatedIso}`
+  );
+  if (patchedFrontmatter === frontmatter) return content;
+  return `---
+${patchedFrontmatter}
+---${content.slice(fmMatch[0].length)}`;
+}
+var _dbInitialized = false;
+var _dbInitError = null;
+function getAgentDb() {
+  const dbm = DatabaseManager.instance();
+  if (!_dbInitialized) {
+    try {
+      initAgentSchema(dbm);
+      _dbInitialized = true;
+      _dbInitError = null;
+    } catch (err) {
+      _dbInitError = err instanceof Error ? err : new Error(String(err));
+      process.stderr.write(`[chitragupta] agent DB schema init failed: ${_dbInitError.message}
+`);
+      throw _dbInitError;
+    }
+  }
+  return dbm.get("agent");
+}
+function _resetDbInit() {
+  _dbInitialized = false;
+  _dbInitError = null;
+}
+function _getDbStatus() {
+  return {
+    initialized: _dbInitialized,
+    error: _dbInitError?.message ?? null
+  };
+}
+function sessionMetaToRow(meta, filePath) {
+  return {
+    id: meta.id,
+    project: meta.project,
+    title: meta.title,
+    created_at: new Date(meta.created).getTime(),
+    updated_at: new Date(meta.updated).getTime(),
+    turn_count: 0,
+    model: meta.model,
+    agent: meta.agent,
+    cost: meta.totalCost,
+    tokens: meta.totalTokens,
+    tags: JSON.stringify(meta.tags),
+    file_path: filePath,
+    parent_id: meta.parent,
+    branch: meta.branch,
+    metadata: meta.metadata ? JSON.stringify(meta.metadata) : null
+  };
+}
+function rowToSessionMeta(row) {
+  let tags = [];
+  try {
+    tags = JSON.parse(row.tags ?? "[]");
+  } catch {
+  }
+  let metadata;
+  try {
+    metadata = row.metadata ? JSON.parse(row.metadata) : void 0;
+  } catch {
+  }
+  const provider = metadata?.provider;
+  const createdAt = row.created_at;
+  const updatedAt = row.updated_at;
+  return {
+    id: row.id,
+    title: row.title,
+    created: createdAt ? new Date(createdAt).toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
+    updated: updatedAt ? new Date(updatedAt).toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
+    agent: row.agent ?? "chitragupta",
+    model: row.model ?? "unknown",
+    provider,
+    project: row.project,
+    parent: row.parent_id ?? null,
+    branch: row.branch ?? null,
+    tags,
+    totalCost: row.cost ?? 0,
+    totalTokens: row.tokens ?? 0,
+    metadata
+  };
+}
+function upsertSessionToDb(meta, filePath) {
+  try {
+    const db = getAgentDb();
+    const row = sessionMetaToRow(meta, filePath);
+    db.prepare(`
+			INSERT INTO sessions (id, project, title, created_at, updated_at, turn_count, model, agent, cost, tokens, tags, file_path, parent_id, branch, metadata)
+			VALUES (@id, @project, @title, @created_at, @updated_at, @turn_count, @model, @agent, @cost, @tokens, @tags, @file_path, @parent_id, @branch, @metadata)
+			ON CONFLICT(id) DO UPDATE SET
+				title = @title, updated_at = @updated_at, turn_count = @turn_count,
+				model = @model, cost = @cost, tokens = @tokens, tags = @tags, metadata = @metadata
+		`).run(row);
+  } catch (err) {
+    process.stderr.write(`[chitragupta] session upsert failed for ${meta.id}: ${err instanceof Error ? err.message : err}
+`);
+  }
+}
+function insertTurnToDb(sessionId, turn) {
+  try {
+    const db = getAgentDb();
+    const now = Date.now();
+    const insertTurn = db.transaction(() => {
+      const result = db.prepare(`
+				INSERT OR IGNORE INTO turns (session_id, turn_number, role, content, agent, model, tool_calls, created_at)
+				VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+			`).run(
+        sessionId,
+        turn.turnNumber,
+        turn.role,
+        turn.content,
+        turn.agent ?? null,
+        turn.model ?? null,
+        turn.toolCalls ? JSON.stringify(turn.toolCalls) : null,
+        now
+      );
+      if (result.changes > 0) {
+        db.prepare("INSERT INTO turns_fts (rowid, content) VALUES (?, ?)").run(
+          result.lastInsertRowid,
+          turn.content
+        );
+      }
+      db.prepare(
+        "UPDATE sessions SET turn_count = turn_count + 1, updated_at = ? WHERE id = ?"
+      ).run(now, sessionId);
+    });
+    insertTurn();
+  } catch (err) {
+    process.stderr.write(`[chitragupta] turn insert failed for session ${sessionId}: ${err instanceof Error ? err.message : err}
+`);
+  }
+}
+function createSession(opts) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const { id, filePath } = generateSessionId(opts.project);
+  const meta = {
+    id,
+    title: opts.title ?? "New Session",
+    created: now,
+    updated: now,
+    agent: opts.agent ?? "chitragupta",
+    model: opts.model ?? "unknown",
+    provider: opts.provider,
+    project: opts.project,
+    parent: opts.parentSessionId ?? null,
+    branch: opts.branch ?? null,
+    tags: opts.tags ?? [],
+    totalCost: 0,
+    totalTokens: 0,
+    metadata: opts.metadata
+  };
+  if (opts.provider) {
+    meta.metadata = { ...meta.metadata, provider: opts.provider };
+  }
+  const session = { meta, turns: [] };
+  saveSession(session);
+  upsertSessionToDb(meta, filePath);
+  return session;
+}
+function saveSession(session) {
+  const filePath = resolveSessionPath(session.meta.id, session.meta.project);
+  const dir = path.dirname(filePath);
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+    session.meta.updated = (/* @__PURE__ */ new Date()).toISOString();
+    const markdown = writeSessionMarkdown(session);
+    const tmpPath = `${filePath}.tmp.${process.pid}`;
+    fs.writeFileSync(tmpPath, markdown, "utf-8");
+    atomicRename(tmpPath, filePath);
+    cachePut(session.meta.id, session.meta.project, session);
+  } catch (err) {
+    throw new SessionError(
+      `Failed to save session ${session.meta.id} at ${filePath}: ${err.message}`
+    );
+  }
+}
+function loadSession(id, project) {
+  const cached = cacheGet(id, project);
+  if (cached) return cached;
+  const filePath = resolveSessionPath(id, project);
+  if (!fs.existsSync(filePath)) {
+    throw new SessionError(`Session not found: ${id} (project: ${project})`);
+  }
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    const session = parseSessionMarkdown(content);
+    cachePut(id, project, session);
+    return session;
+  } catch (err) {
+    if (err instanceof SessionError) throw err;
+    throw new SessionError(
+      `Failed to load session ${id}: ${err.message}`
+    );
+  }
+}
+function listSessions(project) {
+  try {
+    const db = getAgentDb();
+    let rows;
+    if (project) {
+      rows = db.prepare(
+        "SELECT * FROM sessions WHERE project = ? ORDER BY updated_at DESC"
+      ).all(project);
+    } else {
+      rows = db.prepare(
+        "SELECT * FROM sessions ORDER BY updated_at DESC"
+      ).all();
+    }
+    if (rows.length > 0) {
+      return rows.map(rowToSessionMeta);
+    }
+  } catch (err) {
+    process.stderr.write(`[chitragupta] listSessions SQLite failed, falling back to filesystem: ${err instanceof Error ? err.message : err}
+`);
+  }
+  return listSessionsFromFilesystem(project);
+}
+function listSessionsByDate(date, project) {
+  const dateMatch = date.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+  if (!dateMatch) {
+    throw new SessionError(`Invalid date format: ${date}. Expected YYYY-MM-DD.`);
+  }
+  const startOfDay = (/* @__PURE__ */ new Date(`${date}T00:00:00.000Z`)).getTime();
+  const endOfDay = startOfDay + 864e5;
+  return listSessionsByDateRange(startOfDay, endOfDay, project);
+}
+function listSessionsByDateRange(startMs, endMs, project) {
+  try {
+    const db = getAgentDb();
+    let rows;
+    if (project) {
+      rows = db.prepare(
+        "SELECT * FROM sessions WHERE project = ? AND created_at >= ? AND created_at < ? ORDER BY created_at ASC"
+      ).all(project, startMs, endMs);
+    } else {
+      rows = db.prepare(
+        "SELECT * FROM sessions WHERE created_at >= ? AND created_at < ? ORDER BY created_at ASC"
+      ).all(startMs, endMs);
+    }
+    if (rows.length > 0) {
+      return rows.map(rowToSessionMeta);
+    }
+  } catch {
+  }
+  const allSessions = listSessionsFromFilesystem(project);
+  return allSessions.filter((s) => {
+    const created = new Date(s.created).getTime();
+    return created >= startMs && created < endMs;
+  });
+}
+function listSessionDates(project) {
+  try {
+    const db = getAgentDb();
+    let rows;
+    if (project) {
+      rows = db.prepare(
+        `SELECT DISTINCT date(created_at / 1000, 'unixepoch') as session_date
+				 FROM sessions WHERE project = ?
+				 ORDER BY session_date DESC`
+      ).all(project);
+    } else {
+      rows = db.prepare(
+        `SELECT DISTINCT date(created_at / 1000, 'unixepoch') as session_date
+				 FROM sessions
+				 ORDER BY session_date DESC`
+      ).all();
+    }
+    return rows.map((r) => r.session_date).filter(Boolean);
+  } catch {
+    const allSessions = listSessionsFromFilesystem(project);
+    const dates = /* @__PURE__ */ new Set();
+    for (const s of allSessions) {
+      dates.add(s.created.slice(0, 10));
+    }
+    return [...dates].sort().reverse();
+  }
+}
+function listSessionProjects() {
+  try {
+    const db = getAgentDb();
+    const rows = db.prepare(
+      `SELECT project, COUNT(*) as count, MAX(updated_at) as last_active
+			 FROM sessions
+			 GROUP BY project
+			 ORDER BY last_active DESC`
+    ).all();
+    return rows.map((r) => ({
+      project: r.project,
+      sessionCount: r.count,
+      lastActive: new Date(r.last_active).toISOString()
+    }));
+  } catch {
+    return [];
+  }
+}
+function listSessionsFromFilesystem(project) {
+  const sessionsRoot = getSessionsRoot();
+  if (!fs.existsSync(sessionsRoot)) return [];
+  const results = [];
+  if (project) {
+    const projectDir = getProjectSessionDir(project);
+    if (!fs.existsSync(projectDir)) return [];
+    results.push(...scanDirRecursive(projectDir));
+  } else {
+    const projectDirs = fs.readdirSync(sessionsRoot, { withFileTypes: true });
+    for (const entry of projectDirs) {
+      if (entry.isDirectory()) {
+        results.push(...scanDirRecursive(path.join(sessionsRoot, entry.name)));
+      }
+    }
+  }
+  results.sort((a, b) => new Date(b.updated).getTime() - new Date(a.updated).getTime());
+  return results;
+}
+function scanDirRecursive(dir) {
+  const metas = [];
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        metas.push(...scanDirRecursive(fullPath));
+      } else if (entry.name.endsWith(".md")) {
+        try {
+          const content = fs.readFileSync(fullPath, "utf-8");
+          const session = parseSessionMarkdown(content);
+          metas.push(session.meta);
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  return metas;
+}
+function deleteSession(id, project) {
+  const filePath = resolveSessionPath(id, project);
+  if (!fs.existsSync(filePath)) {
+    throw new SessionError(`Session not found: ${id} (project: ${project})`);
+  }
+  fs.unlinkSync(filePath);
+  cacheInvalidate(id, project);
+  let dir = path.dirname(filePath);
+  const sessionsRoot = getSessionsRoot();
+  while (dir !== sessionsRoot && dir.length > sessionsRoot.length) {
+    try {
+      const remaining = fs.readdirSync(dir);
+      if (remaining.length === 0) {
+        fs.rmdirSync(dir);
+        dir = path.dirname(dir);
+      } else {
+        break;
+      }
+    } catch {
+      break;
+    }
+  }
+  try {
+    const db = getAgentDb();
+    const turns = db.prepare("SELECT id FROM turns WHERE session_id = ?").all(id);
+    for (const t of turns) {
+      db.prepare("DELETE FROM turns_fts WHERE rowid = ?").run(t.id);
+    }
+    db.prepare("DELETE FROM turns WHERE session_id = ?").run(id);
+    db.prepare("DELETE FROM sessions WHERE id = ?").run(id);
+  } catch {
+  }
+}
+var sessionWriteQueues = /* @__PURE__ */ new Map();
+function addTurn(sessionId, project, turn) {
+  const key = `${sessionId}:${project}`;
+  const prev = sessionWriteQueues.get(key) ?? Promise.resolve();
+  const next = prev.then(() => {
+    const filePath = resolveSessionPath(sessionId, project);
+    if (!fs.existsSync(filePath)) {
+      throw new SessionError(`Session not found: ${sessionId} (project: ${project})`);
+    }
+    const fileContent = fs.readFileSync(filePath, "utf-8");
+    if (!turn.turnNumber) {
+      try {
+        const session = parseSessionMarkdown(fileContent);
+        turn.turnNumber = session.turns.length + 1;
+      } catch {
+        turn.turnNumber = getMaxTurnNumber(sessionId) + 1;
+      }
+    }
+    const updatedIso = (/* @__PURE__ */ new Date()).toISOString();
+    const patchedContent = patchFrontmatterUpdated(fileContent, updatedIso);
+    if (patchedContent !== fileContent) {
+      fs.writeFileSync(filePath, patchedContent, "utf-8");
+    }
+    const turnMd = writeTurnMarkdown(turn);
+    fs.appendFileSync(filePath, `
+${turnMd}
+`, "utf-8");
+    cacheInvalidate(sessionId, project);
+    insertTurnToDb(sessionId, turn);
+  }).catch((err) => {
+    throw err;
+  }).finally(() => {
+    if (sessionWriteQueues.get(key) === next) {
+      sessionWriteQueues.delete(key);
+    }
+  });
+  sessionWriteQueues.set(key, next);
+  return next;
+}
+function listTurnsWithTimestamps(sessionId, project) {
+  try {
+    const db = getAgentDb();
+    const rows = db.prepare(
+      "SELECT turn_number, role, content, agent, model, tool_calls, created_at FROM turns WHERE session_id = ? ORDER BY turn_number ASC"
+    ).all(sessionId);
+    if (rows.length > 0) {
+      return rows.map((row) => ({
+        turnNumber: row.turn_number,
+        role: row.role,
+        content: row.content,
+        agent: row.agent ?? void 0,
+        model: row.model ?? void 0,
+        toolCalls: row.tool_calls ? JSON.parse(row.tool_calls) : void 0,
+        createdAt: row.created_at
+      }));
+    }
+  } catch {
+  }
+  try {
+    const session = loadSession(sessionId, project);
+    const baseTime = new Date(session.meta.created).getTime();
+    return session.turns.map((turn, i) => ({
+      ...turn,
+      createdAt: baseTime + i * 1e3
+      // 1-second spacing
+    }));
+  } catch {
+    return [];
+  }
+}
+function updateSessionMeta(sessionId, updates) {
+  try {
+    const db = getAgentDb();
+    const sets = [];
+    const params = { id: sessionId };
+    if (updates.title !== void 0) {
+      sets.push("title = @title");
+      params.title = updates.title;
+    }
+    if (updates.model !== void 0) {
+      sets.push("model = @model");
+      params.model = updates.model;
+    }
+    if (updates.metadata !== void 0) {
+      sets.push("metadata = @metadata");
+      params.metadata = JSON.stringify(updates.metadata);
+    }
+    if (updates.tags !== void 0) {
+      sets.push("tags = @tags");
+      params.tags = JSON.stringify(updates.tags);
+    }
+    if (sets.length === 0) return;
+    sets.push("updated_at = @updated_at");
+    params.updated_at = Date.now();
+    db.prepare(`UPDATE sessions SET ${sets.join(", ")} WHERE id = @id`).run(params);
+  } catch {
+  }
+}
+function getMaxTurnNumber(sessionId) {
+  try {
+    const db = getAgentDb();
+    const row = db.prepare("SELECT MAX(turn_number) as max_turn FROM turns WHERE session_id = ?").get(sessionId);
+    return row?.max_turn ?? 0;
+  } catch {
+    return 0;
+  }
+}
+function findSessionByMetadata(key, value, project) {
+  if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(key)) {
+    return void 0;
+  }
+  try {
+    const db = getAgentDb();
+    const sql = project ? "SELECT * FROM sessions WHERE project = ? AND json_extract(metadata, ?) = ? LIMIT 1" : "SELECT * FROM sessions WHERE json_extract(metadata, ?) = ? LIMIT 1";
+    const params = project ? [project, `$.${key}`, value] : [`$.${key}`, value];
+    const row = db.prepare(sql).get(...params);
+    return row ? rowToSessionMeta(row) : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function migrateExistingSessions(project) {
+  const db = getAgentDb();
+  const sessionsRoot = getSessionsRoot();
+  if (!fs.existsSync(sessionsRoot)) return { migrated: 0, skipped: 0 };
+  let migrated = 0;
+  let skipped = 0;
+  const dirs = project ? [getProjectSessionDir(project)] : fs.readdirSync(sessionsRoot, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => path.join(sessionsRoot, e.name));
+  const insertSession = db.prepare(`
+		INSERT OR IGNORE INTO sessions (id, project, title, created_at, updated_at, turn_count, model, agent, cost, tokens, tags, file_path, parent_id, branch, metadata)
+		VALUES (@id, @project, @title, @created_at, @updated_at, @turn_count, @model, @agent, @cost, @tokens, @tags, @file_path, @parent_id, @branch, @metadata)
+	`);
+  const insertTurn = db.prepare(`
+		INSERT OR IGNORE INTO turns (session_id, turn_number, role, content, agent, model, tool_calls, created_at)
+		VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+	`);
+  const insertFts = db.prepare(
+    "INSERT INTO turns_fts (rowid, content) VALUES (?, ?)"
+  );
+  const migrateFile = (mdPath, relativePath) => {
+    try {
+      const content = fs.readFileSync(mdPath, "utf-8");
+      const session = parseSessionMarkdown(content);
+      const existing = db.prepare("SELECT id FROM sessions WHERE id = ?").get(session.meta.id);
+      if (existing) {
+        skipped++;
+        return;
+      }
+      const row = sessionMetaToRow(session.meta, relativePath);
+      row.turn_count = session.turns.length;
+      insertSession.run(row);
+      for (const turn of session.turns) {
+        const result = insertTurn.run(
+          session.meta.id,
+          turn.turnNumber,
+          turn.role,
+          turn.content,
+          turn.agent ?? null,
+          turn.model ?? null,
+          turn.toolCalls ? JSON.stringify(turn.toolCalls) : null,
+          new Date(session.meta.created).getTime()
+        );
+        if (result.changes > 0) {
+          insertFts.run(result.lastInsertRowid, turn.content);
+        }
+      }
+      migrated++;
+    } catch {
+      skipped++;
+    }
+  };
+  const runMigration = db.transaction(() => {
+    for (const dir of dirs) {
+      if (!fs.existsSync(dir)) continue;
+      walkMdFiles(dir, sessionsRoot, migrateFile);
+    }
+  });
+  runMigration();
+  return { migrated, skipped };
+}
+function walkMdFiles(dir, sessionsRoot, callback) {
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walkMdFiles(fullPath, sessionsRoot, callback);
+      } else if (entry.name.endsWith(".md")) {
+        const relativePath = path.relative(path.dirname(sessionsRoot), fullPath);
+        callback(fullPath, relativePath);
+      }
+    }
+  } catch {
+  }
+}
+
+export {
+  parseSessionMarkdown,
+  writeSessionMarkdown,
+  writeTurnMarkdown,
+  _resetSessionCache,
+  _resetDbInit,
+  _getDbStatus,
+  createSession,
+  saveSession,
+  loadSession,
+  listSessions,
+  listSessionsByDate,
+  listSessionsByDateRange,
+  listSessionDates,
+  listSessionProjects,
+  deleteSession,
+  addTurn,
+  listTurnsWithTimestamps,
+  updateSessionMeta,
+  getMaxTurnNumber,
+  findSessionByMetadata,
+  migrateExistingSessions
+};
+//# sourceMappingURL=chunk-L7JICQBW.js.map