@prestyj/cli 5.10.0 → 5.12.0

package/dist/core/project-discovery.js

@@ -1,5 +1,5 @@
 import fs from "node:fs/promises";
-import { createReadStream } from "node:fs";
+import { createReadStream, realpathSync } from "node:fs";
 import readline from "node:readline";
 import os from "node:os";
 import path from "node:path";
@@ -7,34 +7,45 @@ import { getAppPaths } from "../config.js";
 import { encodeCwd, stripExtendedLengthPrefix } from "./encode-cwd.js";
 import { getUserSessionPrompt } from "./session-preview.js";
 import { isSessionPath, openSessionReadStream, resolveSessionPath } from "./session-storage.js";
+import { parseForeignTranscript } from "./foreign-session-import.js";
 /**
- * Scan ezcoder + Claude Code + Codex session stores and return one row per
- * project, sorted most-recent first. Duplicates (same cwd) are collapsed; the
- * `sources` field lists every store the project appeared in so the picker can
- * show a combined badge.
+ * Scan EZ Coder + Claude Code + Codex session stores and the user's project
+ * folders, returning one deduplicated row per project, most-recent first.
  */
-export async function discoverProjects() {
+export async function discoverProjects(options = {}) {
     const [ez, cc, cx] = await Promise.all([
         discoverEzcoderProjects(),
         discoverClaudeProjects(),
         discoverCodexProjects(),
     ]);
+    const fromSessions = [...ez, ...cc, ...cx];
+    const folders = await discoverFolderProjects(resolveProjectRoots(options.projectsRoot, options.extraRoots, fromSessions));
     const byPath = new Map();
-    for (const p of [...ez, ...cc, ...cx]) {
+    for (const p of [...fromSessions, ...folders]) {
         const existing = byPath.get(p.path);
         if (!existing) {
             byPath.set(p.path, p);
             continue;
         }
+        // A folder's mtime is not activity: a checkout or a build touching the
+        // directory must not reorder a project above one you actually worked in.
+        // Session recency wins whenever any session store knows this project.
+        const merged = mergeSources(existing.sources, p.sources);
+        const sessionOnly = [existing, p].filter((row) => !isFolderOnly(row.sources));
         byPath.set(p.path, {
             name: existing.name,
             path: existing.path,
-            lastActiveMs: Math.max(existing.lastActiveMs, p.lastActiveMs),
+            lastActiveMs: Math.max(...(sessionOnly.length > 0 ? sessionOnly : [existing, p]).map((r) => r.lastActiveMs)),
             lastActiveDisplay: "", // recomputed below
-            sources: mergeSources(existing.sources, p.sources),
+            sources: merged,
         });
     }
-    const merged = Array.from(byPath.values()).map((p) => ({
+    // Hiding is by resolved path so a row dismissed once stays gone regardless of
+    // which store re-surfaces it later.
+    const hidden = new Set((options.hiddenPaths ?? []).map((p) => path.resolve(p)));
+    const merged = Array.from(byPath.values())
+        .filter((p) => !hidden.has(p.path))
+        .map((p) => ({
         ...p,
         lastActiveDisplay: formatRelativeTime(p.lastActiveMs),
     }));
@@ -45,7 +56,11 @@ const SOURCE_ORDER = {
     ezcoder: 0,
     "claude-code": 1,
     codex: 2,
+    folder: 3,
 };
+function isFolderOnly(sources) {
+    return sources.length === 1 && sources[0] === "folder";
+}
 function mergeSources(a, b) {
     const set = new Set([...a, ...b]);
     return Array.from(set).sort((x, y) => SOURCE_ORDER[x] - SOURCE_ORDER[y]);
@@ -68,15 +83,17 @@ async function discoverEzcoderProjects() {
     catch {
         return [];
     }
-    const results = [];
-    for (const entry of entries) {
+    // Per-entry work is independent I/O (readdir + stat + a header read), so it
+    // runs concurrently; sequentially this dominated picker load time once a user
+    // had dozens of session stores.
+    const results = await mapConcurrent(entries, async (entry) => {
         const dir = path.join(sessionsDir, entry);
-        const mtime = await maxGgcoderSessionMtime(dir);
+        const mtime = await maxEzcoderSessionMtime(dir);
         if (mtime === null)
-            continue;
-        const rawCwd = (await readFirstFromGgcoderDir(dir, ezcoderCwdExtractor)) ?? fallbackUnderscoreDecode(entry);
+            return null;
+        const rawCwd = (await readFirstFromEzcoderDir(dir, ezcoderCwdExtractor)) ?? fallbackUnderscoreDecode(entry);
         if (!rawCwd)
-            continue;
+            return null;
         // Normalize traversal segments (e.g. an agent launched with cwd
         // `.../src-tauri/../..`) so the basename isn't a stray "..", and drop any
         // Windows extended-length prefix so a session recorded as `\\?\C:\proj`
@@ -84,16 +101,29 @@ async function discoverEzcoderProjects() {
         // project as a plain `C:\proj` instead of listing a prefixed duplicate.
         const cwd = path.resolve(stripExtendedLengthPrefix(rawCwd));
         if (!(await isDirectory(cwd)))
-            continue;
-        results.push({
+            return null;
+        return {
             name: path.basename(cwd),
             path: cwd,
             lastActiveMs: mtime,
             lastActiveDisplay: formatRelativeTime(mtime),
             sources: ["ezcoder"],
-        });
-    }
-    return results;
+        };
+    });
+    return results.filter((p) => p !== null);
+}
+/** Bounded-concurrency Promise.all for large session stores. */
+const IO_CONCURRENCY = 32;
+async function mapConcurrent(items, fn) {
+    const out = new Array(items.length);
+    let next = 0;
+    const workers = Array.from({ length: Math.min(IO_CONCURRENCY, items.length) }, async () => {
+        for (let i = next++; i < items.length; i = next++) {
+            out[i] = await fn(items[i]);
+        }
+    });
+    await Promise.all(workers);
+    return out;
 }
 /**
  * Is `value` an absolute path on any platform?
@@ -140,7 +170,7 @@ async function discoverClaudeProjects() {
     catch {
         return [];
     }
-    const results = await Promise.all(entries.map(async (entry) => {
+    const results = await mapConcurrent(entries, async (entry) => {
         const dir = path.join(projectsDir, entry);
         const mtime = await maxJsonlMtime(dir);
         if (mtime === null)
@@ -157,7 +187,7 @@ async function discoverClaudeProjects() {
             lastActiveDisplay: formatRelativeTime(mtime),
             sources: ["claude-code"],
         };
-    }));
+    });
     return results.filter((p) => p !== null);
 }
 /**
@@ -176,28 +206,155 @@ async function discoverCodexProjects() {
         return [];
     // Process newest first so per-cwd we always start with the latest mtime.
     files.sort((a, b) => b.mtime - a.mtime);
+    const cwds = await mapConcurrent(files, (f) => readFirstFromFile(f.path, codexCwdExtractor));
     const byCwd = new Map();
-    for (const f of files) {
-        const cwd = await readFirstFromFile(f.path, codexCwdExtractor);
+    files.forEach((f, i) => {
+        const cwd = cwds[i];
         if (!cwd)
-            continue;
+            return;
         const prev = byCwd.get(cwd);
         if (prev === undefined || f.mtime > prev)
             byCwd.set(cwd, f.mtime);
-    }
-    const results = [];
-    for (const [cwd, mtime] of byCwd) {
+    });
+    const results = await mapConcurrent(Array.from(byCwd), async ([cwd, mtime]) => {
         if (!(await isDirectory(cwd)))
-            continue;
-        results.push({
+            return null;
+        return {
             name: path.basename(cwd),
             path: cwd,
             lastActiveMs: mtime,
             lastActiveDisplay: formatRelativeTime(mtime),
             sources: ["codex"],
-        });
+        };
+    });
+    return results.filter((p) => p !== null);
+}
+/**
+ * How many already-known projects must share a parent directory before that
+ * parent is treated as a project root in its own right. Users keep more than
+ * one "projects folder" (the configured root plus wherever the rest actually
+ * live), but only one is configurable — so a directory that has repeatedly
+ * acted like a root is inferred from evidence rather than guessed.
+ */
+const INFERRED_ROOT_MIN_PROJECTS = 3;
+/** Directory names that are never a project of their own. */
+const FOLDER_SCAN_IGNORED = new Set([
+    "node_modules",
+    "dist",
+    "build",
+    "out",
+    "target",
+    "vendor",
+    "coverage",
+    "tmp",
+    "temp",
+    "Library",
+    "Applications",
+]);
+/**
+ * Which directories should be scanned for project folders: the configured root,
+ * plus any parent that already holds several known projects.
+ *
+ * Scanning the home directory or a filesystem/temp root would list mail, music
+ * and scratch dirs as "projects", so those are never roots no matter how many
+ * sessions point inside them.
+ */
+function resolveProjectRoots(projectsRoot, extraRoots, discovered) {
+    const roots = new Set();
+    const configured = projectsRoot?.trim();
+    if (configured)
+        roots.add(path.resolve(configured));
+    for (const extra of extraRoots ?? []) {
+        const trimmed = extra.trim();
+        if (trimmed)
+            roots.add(path.resolve(trimmed));
     }
-    return results;
+    const counts = new Map();
+    const seen = new Set();
+    for (const project of discovered) {
+        if (seen.has(project.path))
+            continue;
+        seen.add(project.path);
+        const parent = path.dirname(project.path);
+        if (parent === project.path)
+            continue;
+        counts.set(parent, (counts.get(parent) ?? 0) + 1);
+    }
+    for (const [parent, count] of counts) {
+        if (count >= INFERRED_ROOT_MIN_PROJECTS && !isUnscannableRoot(parent))
+            roots.add(parent);
+    }
+    return Array.from(roots);
+}
+function isUnscannableRoot(dir) {
+    const resolved = resolveExistingPath(dir);
+    if (resolved === resolveExistingPath(path.parse(resolved).root))
+        return true;
+    if (resolved === resolveExistingPath(os.homedir()))
+        return true;
+    // Scratch checkouts and test fixtures cluster as direct children of the temp
+    // dir, which would otherwise infer it as a root and list every stale
+    // `tmp.XXXX` as a project. Resolve symlinks before comparing because macOS
+    // reports the same temp directory through both `/var` and `/private/var`.
+    // Only the temp dir itself is barred — a real projects folder below it is
+    // still scannable.
+    return resolved === resolveExistingPath(os.tmpdir());
+}
+function resolveExistingPath(dir) {
+    const resolved = path.resolve(dir);
+    try {
+        return realpathSync(resolved);
+    }
+    catch {
+        return resolved;
+    }
+}
+/**
+ * List the direct children of each project root as projects. Directory mtime
+ * stands in for "last active" — imprecise, but these rows are session-less by
+ * definition and merging keeps real session recency where it exists.
+ */
+async function discoverFolderProjects(roots) {
+    const candidates = [];
+    for (const root of roots) {
+        let entries;
+        try {
+            entries = await fs.readdir(root, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory() && !entry.isSymbolicLink())
+                continue;
+            if (entry.name.startsWith("."))
+                continue;
+            if (FOLDER_SCAN_IGNORED.has(entry.name))
+                continue;
+            candidates.push({ name: entry.name, path: path.join(root, entry.name) });
+        }
+    }
+    // `stat` (not `lstat`) so a symlinked project folder resolves to its target:
+    // `readdir` reports a symlink as neither file nor directory, so checking the
+    // dirent alone would silently drop linked-in projects.
+    const rows = await mapConcurrent(candidates, async (c) => {
+        try {
+            const stats = await fs.stat(c.path);
+            if (!stats.isDirectory())
+                return null;
+            return {
+                name: c.name,
+                path: c.path,
+                lastActiveMs: stats.mtimeMs,
+                lastActiveDisplay: formatRelativeTime(stats.mtimeMs),
+                sources: ["folder"],
+            };
+        }
+        catch {
+            return null;
+        }
+    });
+    return rows.filter((r) => r !== null);
 }
 async function isDirectory(p) {
     try {
@@ -220,10 +377,10 @@ async function maxJsonlMtime(dir) {
             max = f.mtime;
     return max > 0 ? max : null;
 }
-async function maxGgcoderSessionMtime(dir) {
+async function maxEzcoderSessionMtime(dir) {
     if (!(await isDirectory(dir)))
         return null;
-    const files = await collectGgcoderSessionFiles(dir, 2);
+    const files = await collectEzcoderSessionFiles(dir, 2);
     if (files.length === 0)
         return null;
     return Math.max(...files.map((file) => file.mtime));
@@ -262,7 +419,7 @@ async function collectJsonlFiles(dir, maxDepth) {
         }
     }
 }
-async function collectGgcoderSessionFiles(dir, maxDepth) {
+async function collectEzcoderSessionFiles(dir, maxDepth) {
     const byResolvedPath = new Map();
     await walk(dir, 0);
     return [...byResolvedPath.values()];
@@ -356,20 +513,27 @@ async function readFirstFromJsonlDir(dir, extractor) {
     }
     return null;
 }
-async function readFirstFromGgcoderDir(dir, extractor) {
-    const files = await collectGgcoderSessionFiles(dir, 2);
+async function readFirstFromEzcoderDir(dir, extractor) {
+    const files = await collectEzcoderSessionFiles(dir, 2);
     files.sort((a, b) => b.mtime - a.mtime);
     for (const file of files) {
         try {
-            const { stream } = await openSessionReadStream(file.path);
+            const { stream, close } = await openSessionReadStream(file.path);
             const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
-            let lines = 0;
-            for await (const line of rl) {
-                if (++lines > 200)
-                    break;
-                const value = extractor(line);
-                if (value)
-                    return value;
+            try {
+                let lines = 0;
+                for await (const line of rl) {
+                    if (++lines > 200)
+                        break;
+                    const value = extractor(line);
+                    if (value)
+                        return value;
+                }
+            }
+            finally {
+                // Always via close(): destroying the gunzip alone strands the source fd.
+                rl.close();
+                close();
             }
         }
         catch {
@@ -464,7 +628,7 @@ function formatRelativeTime(ms) {
  */
 export async function listRecentSessions(cwd, limit = 5, sessionsDir = getAppPaths().sessionsDir) {
     const dir = path.join(sessionsDir, encodeCwd(cwd));
-    const files = await collectGgcoderSessionFiles(dir, 1);
+    const files = await collectEzcoderSessionFiles(dir, 1);
     if (files.length === 0)
         return [];
     files.sort((a, b) => b.mtime - a.mtime);
@@ -484,10 +648,109 @@ export async function listRecentSessions(cwd, limit = 5, sessionsDir = getAppPat
     }
     return out;
 }
+/**
+ * List the most recent Claude Code and Codex conversations for a project cwd.
+ *
+ * The project picker has always surfaced these stores (`discoverProjects`), so a
+ * project can appear *because* it has Claude Code history — and then show an
+ * empty session list, because that only read EZ Coder's own directory. These
+ * rows close that gap: each one points at the foreign transcript, tagged with
+ * its `source`, and the host imports it on click.
+ *
+ * Cheap by construction: a transcript is only opened if its cwd matches, and
+ * both the per-store file walk and the preview read are line-capped.
+ */
+export async function listForeignSessions(cwd, limit = 5, homeDir = os.homedir()) {
+    const [claude, codex] = await Promise.all([
+        listClaudeSessions(cwd, limit, homeDir),
+        listCodexSessions(cwd, limit, homeDir),
+    ]);
+    return [...claude, ...codex]
+        .sort((left, right) => right.lastActiveMs - left.lastActiveMs)
+        .slice(0, limit)
+        .map(({ lastActiveMs: _lastActiveMs, ...session }) => session);
+}
+async function listClaudeSessions(cwd, limit, homeDir) {
+    const projectsDir = path.join(homeDir, ".claude", "projects");
+    if (!(await isDirectory(projectsDir)))
+        return [];
+    // Claude's directory encoding is ambiguous (every "/" becomes "-", colliding
+    // with real dashes), so we cannot map cwd → directory. Instead walk the files
+    // newest-first and keep the ones whose recorded cwd matches.
+    const files = await collectJsonlFiles(projectsDir, 3);
+    return collectMatchingForeignSessions(files, cwd, limit, "claude-code", claudeCwdExtractor);
+}
+async function listCodexSessions(cwd, limit, homeDir) {
+    const sessionsDir = path.join(homeDir, ".codex", "sessions");
+    if (!(await isDirectory(sessionsDir)))
+        return [];
+    // Layout is YYYY/MM/DD/*.jsonl — depth 4 covers it.
+    const files = await collectJsonlFiles(sessionsDir, 4);
+    return collectMatchingForeignSessions(files, cwd, limit, "codex", codexCwdExtractor);
+}
+/**
+ * Newest-first scan for transcripts belonging to `cwd`. Stops as soon as
+ * `limit` matches are found so a large history costs only the files it reads.
+ */
+async function collectMatchingForeignSessions(files, cwd, limit, source, extractor) {
+    if (files.length === 0)
+        return [];
+    files.sort((left, right) => right.mtime - left.mtime);
+    const target = path.resolve(stripExtendedLengthPrefix(cwd));
+    const out = [];
+    for (const file of files) {
+        if (out.length >= limit)
+            break;
+        const recorded = await readFirstFromFile(file.path, extractor);
+        if (!recorded)
+            continue;
+        if (path.resolve(stripExtendedLengthPrefix(recorded)) !== target)
+            continue;
+        const summary = await readForeignSessionSummary(file.path, source);
+        if (!summary)
+            continue;
+        out.push({
+            ...summary,
+            lastActiveDisplay: formatRelativeTime(file.mtime),
+            lastActiveMs: file.mtime,
+        });
+    }
+    return out;
+}
+/**
+ * Preview + message count for a foreign transcript, using the same parsers the
+ * importer uses — so the row's title is exactly the title the imported session
+ * ends up with (notably Cursor's `<user_query>` unwrapping).
+ */
+async function readForeignSessionSummary(file, source) {
+    let text;
+    try {
+        text = await fs.readFile(file, "utf-8");
+    }
+    catch {
+        return null;
+    }
+    try {
+        const parsed = parseForeignTranscript(text, source === "codex" ? "codex" : "claude");
+        if (parsed.messages.length === 0)
+            return null;
+        return {
+            id: path.basename(file).replace(/\.jsonl$/, ""),
+            path: file,
+            preview: parsed.preview ?? "(no prompt)",
+            messageCount: parsed.messages.length,
+            source,
+        };
+    }
+    catch {
+        // An unreadable transcript is skipped, never surfaced as a broken row.
+        return null;
+    }
+}
 /** Single-pass parse of one session file: identity + count + activity + preview. */
 async function readSessionSummary(file) {
     try {
-        const { path: resolvedPath, stream } = await openSessionReadStream(file);
+        const { path: resolvedPath, stream, close } = await openSessionReadStream(file);
         const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
         let id = "";
         let conversationId = "";
@@ -497,41 +760,48 @@ async function readSessionSummary(file) {
         let preview = "";
         let label = "";
         let valid = false;
-        for await (const line of rl) {
-            if (!line)
-                continue;
-            try {
-                const entry = JSON.parse(line);
-                if (!valid) {
-                    if (entry.type !== "session")
-                        return null;
-                    valid = true;
-                    id = entry.id ?? "";
-                    conversationId = entry.conversationId ?? id;
-                    if (typeof entry.preview === "string") {
-                        headerPreview = entry.preview.replace(/\s+/g, " ").trim().slice(0, 80);
-                    }
-                    if (entry.timestamp)
-                        lastActivity = entry.timestamp;
+        try {
+            for await (const line of rl) {
+                if (!line)
                     continue;
-                }
-                if (entry.type === "label" && typeof entry.label === "string" && entry.label.trim()) {
-                    label = entry.label.replace(/\s+/g, " ").trim().slice(0, 80);
-                }
-                else if (entry.type === "message") {
-                    messageCount += 1;
-                    if (entry.timestamp)
-                        lastActivity = entry.timestamp;
-                    if (!preview && entry.message?.role === "user") {
-                        const text = getUserSessionPrompt(entry.message.content);
-                        if (text)
-                            preview = text.replace(/\s+/g, " ").trim().slice(0, 80);
+                try {
+                    const entry = JSON.parse(line);
+                    if (!valid) {
+                        if (entry.type !== "session")
+                            return null;
+                        valid = true;
+                        id = entry.id ?? "";
+                        conversationId = entry.conversationId ?? id;
+                        if (typeof entry.preview === "string") {
+                            headerPreview = entry.preview.replace(/\s+/g, " ").trim().slice(0, 80);
+                        }
+                        if (entry.timestamp)
+                            lastActivity = entry.timestamp;
+                        continue;
+                    }
+                    if (entry.type === "label" && typeof entry.label === "string" && entry.label.trim()) {
+                        label = entry.label.replace(/\s+/g, " ").trim().slice(0, 80);
+                    }
+                    else if (entry.type === "message") {
+                        messageCount += 1;
+                        if (entry.timestamp)
+                            lastActivity = entry.timestamp;
+                        if (!preview && entry.message?.role === "user") {
+                            const text = getUserSessionPrompt(entry.message.content);
+                            if (text)
+                                preview = text.replace(/\s+/g, " ").trim().slice(0, 80);
+                        }
                     }
                 }
+                catch {
+                    // Skip malformed lines; archive migration preserves them byte-for-byte.
+                }
             }
-            catch {
-                // Skip malformed lines; archive migration preserves them byte-for-byte.
-            }
+        }
+        finally {
+            // `return null` above exits mid-stream; close() destroys gunzip + source.
+            rl.close();
+            close();
         }
         return valid
             ? {