minecodex 0.1.0

package/features/images/src/prompt-index.mjs

@@ -0,0 +1,182 @@
+import { createReadStream } from "node:fs";
+import { readdir, stat } from "node:fs/promises";
+import path from "node:path";
+import { createInterface } from "node:readline";
+
+const DEFAULT_NEGATIVE_CACHE_TTL_MS = 5_000;
+
+async function findThreadLogs(directory, threadId, output = []) {
+  let entries;
+  try {
+    entries = await readdir(directory, { withFileTypes: true });
+  } catch (error) {
+    if (error.code === "ENOENT") return output;
+    throw error;
+  }
+
+  for (const entry of entries) {
+    const entryPath = path.join(directory, entry.name);
+    if (entry.isDirectory()) await findThreadLogs(entryPath, threadId, output);
+    else if (entry.isFile() && entry.name.endsWith(`${threadId}.jsonl`)) output.push(entryPath);
+  }
+  return output;
+}
+
+function promptFromEventLine(line) {
+  if (!line.includes('"image_generation_end"')) return null;
+  try {
+    const event = JSON.parse(line);
+    const payload = event?.payload ?? event;
+    if (payload?.type !== "image_generation_end") return null;
+    if (typeof payload.call_id !== "string" || typeof payload.revised_prompt !== "string") return null;
+    return { imageGenerationItemId: payload.call_id, prompt: payload.revised_prompt };
+  } catch {
+    return null;
+  }
+}
+
+async function readPrompts(logPath, prompts) {
+  const input = createReadStream(logPath, { encoding: "utf8" });
+  const lines = createInterface({ input, crlfDelay: Infinity });
+  for await (const line of lines) {
+    const entry = promptFromEventLine(line);
+    if (entry && !prompts.has(entry.imageGenerationItemId)) {
+      prompts.set(entry.imageGenerationItemId, entry.prompt);
+    }
+  }
+}
+
+function cacheKey(threadId, imageGenerationItemId) {
+  return `${threadId}\u0000${imageGenerationItemId}`;
+}
+
+async function fileSignature(logPath) {
+  try {
+    const info = await stat(logPath);
+    return { mtimeMs: info.mtimeMs, size: info.size };
+  } catch (error) {
+    if (error.code === "ENOENT" || error.code === "ENOTDIR") return null;
+    throw error;
+  }
+}
+
+function sameSignature(left, right) {
+  return left?.mtimeMs === right?.mtimeMs && left?.size === right?.size;
+}
+
+export class ThreadPromptIndex {
+  constructor({ sessionRoots = [], negativeTtlMs = DEFAULT_NEGATIVE_CACHE_TTL_MS, now = Date.now } = {}) {
+    if (!Number.isFinite(negativeTtlMs) || negativeTtlMs < 0) {
+      throw new Error("negativeTtlMs must be a non-negative number");
+    }
+    if (typeof now !== "function") throw new Error("now must be a function");
+    this.sessionRoots = sessionRoots.map((sessionRoot) => path.resolve(sessionRoot));
+    this.negativeTtlMs = negativeTtlMs;
+    this.now = now;
+    this.threadPrompts = new Map();
+    this.threadLogPaths = new Map();
+    this.threadLogSignatures = new Map();
+    this.scanPromises = new Map();
+    this.negativeCache = new Map();
+    this.scanCount = 0;
+  }
+
+  async scanThread(threadId, { refreshPaths = false } = {}) {
+    this.scanCount += 1;
+    if (refreshPaths || !this.threadLogPaths.has(threadId)) {
+      const logPaths = [];
+      for (const sessionRoot of this.sessionRoots) {
+        await findThreadLogs(sessionRoot, threadId, logPaths);
+      }
+      this.threadLogPaths.set(threadId, logPaths);
+    }
+    const logPaths = this.threadLogPaths.get(threadId) ?? [];
+    const prompts = new Map();
+    const signatures = new Map();
+    for (const logPath of logPaths) {
+      await readPrompts(logPath, prompts);
+      const signature = await fileSignature(logPath);
+      if (signature) signatures.set(logPath, signature);
+    }
+    this.threadPrompts.set(threadId, prompts);
+    this.threadLogSignatures.set(threadId, signatures);
+    return prompts;
+  }
+
+  async threadLogsChanged(threadId) {
+    const logPaths = this.threadLogPaths.get(threadId) ?? [];
+    const signatures = this.threadLogSignatures.get(threadId) ?? new Map();
+    for (const logPath of logPaths) {
+      const current = await fileSignature(logPath);
+      if (!current || !sameSignature(current, signatures.get(logPath))) return true;
+    }
+    return false;
+  }
+
+  clearNegative(threadId) {
+    for (const key of this.negativeCache.keys()) {
+      if (key.startsWith(`${threadId}\u0000`)) this.negativeCache.delete(key);
+    }
+  }
+
+  async find(threadId, imageGenerationItemId) {
+    const key = cacheKey(threadId, imageGenerationItemId);
+    const cached = this.threadPrompts.get(threadId);
+    if (cached?.has(imageGenerationItemId)) return cached.get(imageGenerationItemId);
+
+    const negative = this.negativeCache.get(key);
+    if (negative) {
+      const expired = this.now() >= negative.expiresAt;
+      const changed = expired || await this.threadLogsChanged(threadId);
+      if (!changed) return null;
+      this.negativeCache.delete(key);
+      this.threadPrompts.delete(threadId);
+      this.threadLogSignatures.delete(threadId);
+      this.clearNegative(threadId);
+      if (expired) this.threadLogPaths.delete(threadId);
+    }
+
+    let scan = this.scanPromises.get(threadId);
+    if (!scan) {
+      scan = this.scanThread(threadId, { refreshPaths: !this.threadLogPaths.has(threadId) });
+      this.scanPromises.set(threadId, scan);
+      const clearScan = () => {
+        if (this.scanPromises.get(threadId) === scan) this.scanPromises.delete(threadId);
+      };
+      scan.then(clearScan, clearScan);
+    }
+    const prompts = await scan;
+    const prompt = prompts.get(imageGenerationItemId) ?? null;
+    if (!prompt) {
+      this.negativeCache.set(key, { expiresAt: this.now() + this.negativeTtlMs });
+    }
+    return prompt;
+  }
+
+  invalidate(threadId = null) {
+    if (threadId == null) {
+      this.threadPrompts.clear();
+      this.threadLogPaths.clear();
+      this.threadLogSignatures.clear();
+      this.negativeCache.clear();
+      return;
+    }
+    this.threadPrompts.delete(threadId);
+    this.threadLogPaths.delete(threadId);
+    this.threadLogSignatures.delete(threadId);
+    this.clearNegative(threadId);
+  }
+
+  close() {
+    this.threadPrompts.clear();
+    this.threadLogPaths.clear();
+    this.threadLogSignatures.clear();
+    this.scanPromises.clear();
+    this.negativeCache.clear();
+  }
+}
+
+export async function findImagePrompt({ sessionRoots, threadId, imageGenerationItemId }) {
+  const index = new ThreadPromptIndex({ sessionRoots });
+  return index.find(threadId, imageGenerationItemId);
+}

package/features/images/src/save-as.mjs

@@ -0,0 +1,40 @@
+import { execFile } from "node:child_process";
+import { copyFile } from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+
+const run = promisify(execFile);
+const SAVE_DIALOG_SCRIPT = `
+on run argv
+  try
+    set destinationFile to choose file name with prompt "Save image as" default name (item 1 of argv)
+    return POSIX path of destinationFile
+  on error number -128
+    return ""
+  end try
+end run
+`;
+
+export function defaultImageFilename(threadTitle) {
+  const rawTitle = String(threadTitle || "Generated image").replace(/\.png$/i, "");
+  const safeTitle = rawTitle
+    .replace(/[\\/:*?"<>|\u0000-\u001f]/g, "-")
+    .replace(/\s+/g, " ")
+    .replace(/^\.+|\.+$/g, "")
+    .trim()
+    .slice(0, 96);
+  return `${safeTitle || "Generated image"}.png`;
+}
+
+export async function saveImageAs(image) {
+  const { stdout } = await run(
+    "/usr/bin/osascript",
+    ["-e", SAVE_DIALOG_SCRIPT, defaultImageFilename(image.threadTitle)],
+    { encoding: "utf8" },
+  );
+  const destinationPath = stdout.trim();
+  if (!destinationPath) return { saved: false, canceled: true };
+
+  await copyFile(image.sourcePath, destinationPath);
+  return { saved: true, fileName: path.basename(destinationPath) };
+}

package/features/images/src/thread-metadata.mjs

@@ -0,0 +1,93 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { DatabaseSync } from "node:sqlite";
+
+function parseSessionIndex(text) {
+  const names = new Map();
+  for (const line of text.split("\n")) {
+    if (!line.trim()) continue;
+    const entry = JSON.parse(line);
+    if (entry.id && entry.thread_name) names.set(entry.id, entry.thread_name);
+  }
+  return names;
+}
+
+function projectContaining(projects, cwd) {
+  if (!cwd) return null;
+  return projects
+    .flatMap((project) => (project.rootPaths ?? []).map((rootPath) => ({ project, rootPath })))
+    .filter(({ rootPath }) => cwd === rootPath || cwd.startsWith(`${rootPath}${path.sep}`))
+    .sort((left, right) => right.rootPath.length - left.rootPath.length)[0]?.project ?? null;
+}
+
+export class ThreadMetadataIndex {
+  constructor({ stateDatabasePath, globalStatePath, sessionIndexPath }) {
+    this.stateDatabasePath = stateDatabasePath;
+    this.globalStatePath = globalStatePath;
+    this.sessionIndexPath = sessionIndexPath;
+    this.database = null;
+    this.threadNames = new Map();
+    this.projectlessThreadIds = new Set();
+    this.projects = new Map();
+    this.projectAssignments = {};
+    this.refreshPromise = null;
+  }
+
+  async refresh() {
+    if (this.refreshPromise) return this.refreshPromise;
+    this.refreshPromise = (async () => {
+      const [globalStateText, sessionIndexText] = await Promise.all([
+        readFile(this.globalStatePath, "utf8"),
+        readFile(this.sessionIndexPath, "utf8"),
+      ]);
+      const globalState = JSON.parse(globalStateText);
+      this.threadNames = parseSessionIndex(sessionIndexText);
+      this.projectlessThreadIds = new Set(globalState["projectless-thread-ids"] ?? []);
+      this.projects = new Map(
+        Object.entries(globalState["local-projects"] ?? {})
+          .map(([projectId, project]) => [projectId, { ...project, id: project.id ?? projectId }]),
+      );
+      this.projectAssignments = globalState["thread-project-assignments"] ?? {};
+      this.database ??= new DatabaseSync(this.stateDatabasePath, { readOnly: true });
+    })();
+    try {
+      await this.refreshPromise;
+    } finally {
+      this.refreshPromise = null;
+    }
+  }
+
+  get(threadId) {
+    const thread = this.database
+      ?.prepare("SELECT title, name, cwd, archived FROM threads WHERE id = ?")
+      .get(threadId);
+    if (!thread) return null;
+
+    const threadTitle = this.threadNames.get(threadId) ?? thread.name ?? thread.title ?? "Untitled task";
+    if (this.projectlessThreadIds.has(threadId)) {
+      return {
+        sourceKind: "chat",
+        projectId: null,
+        projectName: null,
+        threadTitle,
+        archived: Boolean(thread.archived),
+      };
+    }
+
+    const assignment = this.projectAssignments[threadId];
+    const assignedProject = assignment?.projectId ? this.projects.get(assignment.projectId) : null;
+    const inferredProject = assignedProject ?? projectContaining([...this.projects.values()], thread.cwd);
+    return {
+      sourceKind: "project",
+      projectId: inferredProject?.id ?? assignment?.projectId ?? null,
+      projectName: inferredProject?.name ?? path.basename(thread.cwd),
+      threadTitle,
+      archived: Boolean(thread.archived),
+    };
+  }
+
+  close() {
+    this.database?.close();
+    this.database = null;
+  }
+}