@kyleparrott/where-was-i 0.1.0

package/dist/src/core/codex.js

@@ -0,0 +1,303 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+const MAX_CHUNK_CHARS = 6000;
+const CHUNK_OVERLAP = 400;
+export function discoverCodexSessionFiles(codexHome, includeArchived = false) {
+    const roots = [path.join(codexHome, "sessions")];
+    if (includeArchived) {
+        roots.push(path.join(codexHome, "archived_sessions"));
+    }
+    const files = [];
+    for (const root of roots) {
+        if (!fs.existsSync(root)) {
+            continue;
+        }
+        walkJsonl(root, files);
+    }
+    return files.sort();
+}
+export function parseCodexSessionFile(filePath, options = {}) {
+    const raw = fs.readFileSync(filePath, "utf8");
+    const lines = raw.split(/\r?\n/);
+    const events = [];
+    const fileSessionId = sessionIdFromPath(filePath);
+    let sessionId = fileSessionId;
+    let cwd = null;
+    let startedAt = null;
+    let updatedAt = null;
+    let title = null;
+    const turns = [];
+    const messages = [];
+    const chunks = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        if (!line) {
+            continue;
+        }
+        try {
+            const event = JSON.parse(line);
+            events.push({ event, lineNumber: index + 1 });
+        }
+        catch {
+            continue;
+        }
+    }
+    for (const { event } of events) {
+        const payload = event.payload ?? {};
+        const timestamp = stringValue(event.timestamp) ?? stringValue(payload.timestamp);
+        startedAt ??= timestamp;
+        updatedAt = timestamp ?? updatedAt;
+        if (event.type === "session_meta") {
+            sessionId = stringValue(payload.id) ?? sessionId;
+            cwd = stringValue(payload.cwd) ?? cwd;
+        }
+        if (event.type === "turn_context") {
+            cwd = stringValue(payload.cwd) ?? cwd;
+        }
+    }
+    const conversationId = sessionId;
+    let currentTurn = null;
+    let messageOrdinal = 0;
+    let chunkOrdinal = 0;
+    const seenMessages = new Set();
+    for (const { event, lineNumber } of events) {
+        const payload = event.payload ?? {};
+        const timestamp = stringValue(event.timestamp) ?? stringValue(payload.timestamp);
+        const role = inferMessageRole(event, options);
+        if (!role) {
+            continue;
+        }
+        const text = extractText(event, role).trim();
+        if (!text || isSyntheticTranscriptMessage(text)) {
+            continue;
+        }
+        if (!title && role === "user") {
+            title = compactTitle(text);
+        }
+        const fingerprint = messageFingerprint(role, timestamp, text);
+        if (seenMessages.has(fingerprint)) {
+            continue;
+        }
+        seenMessages.add(fingerprint);
+        if (role === "user" || !currentTurn) {
+            currentTurn = {
+                id: turnId(sessionId, turns.length),
+                sessionId,
+                source: "codex",
+                sourcePath: filePath,
+                ordinal: turns.length,
+                startedAt: timestamp,
+                updatedAt: timestamp,
+                messageCount: 0
+            };
+            turns.push(currentTurn);
+        }
+        else {
+            currentTurn.updatedAt = timestamp ?? currentTurn.updatedAt;
+        }
+        currentTurn.messageCount += 1;
+        const kind = `${event.type ?? "event"}:${stringValue(payload.type) ?? "unknown"}`;
+        const messageIdValue = messageId(sessionId, lineNumber, role, kind, text);
+        const message = {
+            id: messageIdValue,
+            sessionId,
+            conversationId,
+            turnId: currentTurn.id,
+            source: "codex",
+            sourcePath: filePath,
+            ordinal: messageOrdinal,
+            role,
+            kind,
+            timestamp,
+            text,
+            lineStart: lineNumber,
+            lineEnd: lineNumber,
+            metadata: {
+                eventType: event.type ?? null,
+                payloadType: stringValue(payload.type) ?? null,
+                callId: stringValue(payload.call_id) ?? stringValue(payload.callId) ?? null
+            }
+        };
+        messages.push(message);
+        let chunkIndex = 0;
+        for (const part of splitChunkText(text)) {
+            chunks.push({
+                id: chunkId(filePath, messageIdValue, chunkIndex),
+                messageId: messageIdValue,
+                sessionId,
+                conversationId,
+                turnId: currentTurn.id,
+                source: "codex",
+                sourcePath: filePath,
+                ordinal: chunkOrdinal,
+                chunkIndex,
+                role,
+                kind,
+                timestamp,
+                text: part,
+                lineStart: lineNumber,
+                lineEnd: lineNumber,
+                metadata: {
+                    eventType: event.type ?? null,
+                    payloadType: stringValue(payload.type) ?? null,
+                    callId: stringValue(payload.call_id) ?? stringValue(payload.callId) ?? null
+                }
+            });
+            chunkOrdinal += 1;
+            chunkIndex += 1;
+        }
+        messageOrdinal += 1;
+    }
+    const stat = fs.statSync(filePath);
+    const session = {
+        id: sessionId,
+        conversationId,
+        source: "codex",
+        sourcePath: filePath,
+        title,
+        cwd,
+        startedAt,
+        updatedAt: updatedAt ?? stat.mtime.toISOString(),
+        messageCount: messages.length,
+        turnCount: turns.length
+    };
+    return { session, turns, messages, chunks };
+}
+function walkJsonl(root, files) {
+    for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+        const fullPath = path.join(root, entry.name);
+        if (entry.isDirectory()) {
+            walkJsonl(fullPath, files);
+        }
+        else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+            files.push(fullPath);
+        }
+    }
+}
+function inferMessageRole(event, options) {
+    const payload = event.payload ?? {};
+    const payloadType = stringValue(payload.type);
+    const payloadRole = stringValue(payload.role);
+    if (payloadRole === "user")
+        return "user";
+    if (payloadRole === "assistant")
+        return "assistant";
+    if (event.type === "event_msg" && payloadType === "user_message")
+        return "user";
+    if (event.type === "event_msg" && payloadType === "agent_message")
+        return "assistant";
+    if (options.includeTools && isToolEvent(event))
+        return "tool";
+    return null;
+}
+function extractText(event, role) {
+    const payload = event.payload ?? {};
+    const parts = [];
+    const content = payload.content;
+    if (Array.isArray(content)) {
+        for (const item of content) {
+            if (isRecord(item)) {
+                const itemType = stringValue(item.type);
+                if (itemType === "input_text" || itemType === "output_text" || itemType === "text") {
+                    const text = stringValue(item.text);
+                    if (text)
+                        parts.push(text);
+                }
+            }
+        }
+    }
+    else {
+        const contentText = stringValue(content);
+        if (contentText)
+            parts.push(contentText);
+    }
+    const message = stringValue(payload.message);
+    if (message)
+        parts.push(message);
+    if (role === "tool") {
+        const output = stringValue(payload.output) ?? stringValue(payload.formatted_output) ?? stringValue(payload.aggregated_output);
+        if (output)
+            parts.push(output);
+        const stdout = stringValue(payload.stdout);
+        const stderr = stringValue(payload.stderr);
+        if (stdout)
+            parts.push(stdout);
+        if (stderr)
+            parts.push(stderr);
+        const toolName = stringValue(payload.name) ?? stringValue(payload.tool) ?? stringValue(payload.namespace);
+        const args = stringValue(payload.arguments);
+        const command = stringValue(payload.command);
+        const query = stringValue(payload.query);
+        if (toolName || args || command || query) {
+            parts.push([toolName, args, command, query].filter(Boolean).join(" "));
+        }
+    }
+    return parts.join("\n\n");
+}
+function isToolEvent(event) {
+    const payload = event.payload ?? {};
+    const payloadType = stringValue(payload.type);
+    if (payloadType === "function_call" ||
+        payloadType === "function_call_output" ||
+        payloadType === "web_search_call" ||
+        payloadType === "custom_tool_call" ||
+        payloadType === "custom_tool_call_output" ||
+        payloadType === "tool_search_call" ||
+        payloadType === "tool_search_output") {
+        return true;
+    }
+    if (event.type === "event_msg" &&
+        (payloadType === "exec_command_end" ||
+            payloadType === "mcp_tool_call_end" ||
+            payloadType === "patch_apply_end" ||
+            payloadType === "web_search_end")) {
+        return true;
+    }
+    return false;
+}
+function splitChunkText(text) {
+    if (text.length <= MAX_CHUNK_CHARS) {
+        return [text];
+    }
+    const chunks = [];
+    let start = 0;
+    while (start < text.length) {
+        const end = Math.min(text.length, start + MAX_CHUNK_CHARS);
+        chunks.push(text.slice(start, end));
+        if (end === text.length) {
+            break;
+        }
+        start = Math.max(0, end - CHUNK_OVERLAP);
+    }
+    return chunks;
+}
+function sessionIdFromPath(filePath) {
+    const match = path.basename(filePath).match(/rollout-[^-]+-[^-]+-(.+)\.jsonl$/);
+    return match?.[1] ?? crypto.createHash("sha1").update(filePath).digest("hex");
+}
+function turnId(sessionId, ordinal) {
+    return `${sessionId}:turn:${ordinal}`;
+}
+function messageId(sessionId, lineNumber, role, kind, text) {
+    const hash = crypto.createHash("sha1").update(`${role}:${kind}:${text}`).digest("hex").slice(0, 12);
+    return `${sessionId}:message:${lineNumber}:${hash}`;
+}
+function chunkId(filePath, messageIdValue, chunkIndex) {
+    return crypto.createHash("sha1").update(`${filePath}:${messageIdValue}:${chunkIndex}`).digest("hex");
+}
+function compactTitle(text) {
+    return text.replace(/\s+/g, " ").trim().slice(0, 120);
+}
+function messageFingerprint(role, timestamp, text) {
+    return `${role}:${timestamp ?? ""}:${text.replace(/\s+/g, " ").trim()}`;
+}
+function isSyntheticTranscriptMessage(text) {
+    return text.startsWith("<turn_aborted>") || text.startsWith("# In app browser:");
+}
+function stringValue(value) {
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/src/core/config.js

@@ -0,0 +1,168 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { z } from "zod";
+import { DEFAULT_EMBEDDING_TIMEOUT_MS } from "./embeddings.js";
+import { expandHome } from "./paths.js";
+const startupIndexModeSchema = z.enum(["off", "background", "blocking"]);
+const optionalStringSchema = z.string().optional();
+const embeddingProviderSchema = z
+    .object({
+    baseUrl: optionalStringSchema,
+    model: optionalStringSchema,
+    apiKey: optionalStringSchema,
+    apiKeyEnv: optionalStringSchema,
+    timeoutMs: z.number().int().positive().optional()
+})
+    .passthrough();
+const rawWhereWasIConfigSchema = z
+    .object({
+    dbPath: optionalStringSchema,
+    codexHome: optionalStringSchema,
+    startup: z
+        .object({
+        lexical: startupIndexModeSchema.optional(),
+        semantic: startupIndexModeSchema.optional()
+    })
+        .passthrough()
+        .optional(),
+    semantic: z
+        .object({
+        enabled: z.boolean().optional(),
+        startupMaxChunks: z.union([z.number().int().positive(), z.null()]).optional(),
+        baseUrl: optionalStringSchema,
+        model: optionalStringSchema,
+        apiKey: optionalStringSchema,
+        apiKeyEnv: optionalStringSchema,
+        timeoutMs: z.number().int().positive().optional(),
+        provider: embeddingProviderSchema.optional()
+    })
+        .passthrough()
+        .optional()
+})
+    .passthrough();
+export function defaultConfigPath() {
+    return path.join(os.homedir(), ".where-was-i", "config.json");
+}
+export function loadWhereWasIConfig(configPath) {
+    const resolvedConfigPath = path.resolve(expandHome(configPath ?? process.env.WHERE_WAS_I_CONFIG ?? defaultConfigPath()));
+    const raw = readConfigFile(resolvedConfigPath, Boolean(configPath || process.env.WHERE_WAS_I_CONFIG));
+    const rawSemantic = raw.semantic ?? {};
+    const rawProvider = rawSemantic.provider ?? rawSemantic;
+    const apiKeyEnv = process.env.WHERE_WAS_I_EMBEDDING_API_KEY_ENV ?? rawProvider.apiKeyEnv;
+    const apiKeyFromNamedEnv = apiKeyEnv ? process.env[apiKeyEnv] : undefined;
+    const startupMaxChunksEnv = envOptionalPositiveInteger(process.env.WHERE_WAS_I_SEMANTIC_STARTUP_MAX_CHUNKS);
+    return {
+        configPath: resolvedConfigPath,
+        dbPath: expandHome(process.env.WHERE_WAS_I_INDEX_PATH ?? raw.dbPath ?? path.join(os.homedir(), ".where-was-i", "index.sqlite")),
+        codexHome: expandHome(process.env.CODEX_HOME ?? raw.codexHome ?? path.join(os.homedir(), ".codex")),
+        startup: {
+            lexical: envStartupMode(process.env.WHERE_WAS_I_STARTUP_LEXICAL) ?? raw.startup?.lexical ?? "off",
+            semantic: envStartupMode(process.env.WHERE_WAS_I_STARTUP_SEMANTIC) ?? raw.startup?.semantic ?? "off"
+        },
+        semantic: {
+            startupMaxChunks: startupMaxChunksEnv !== undefined
+                ? startupMaxChunksEnv
+                : rawSemantic.startupMaxChunks !== undefined
+                    ? rawSemantic.startupMaxChunks
+                    : 100,
+            embedding: definedEmbeddingConfig({
+                baseUrl: process.env.WHERE_WAS_I_EMBEDDING_BASE_URL ?? rawProvider.baseUrl,
+                model: process.env.WHERE_WAS_I_EMBEDDING_MODEL ?? rawProvider.model,
+                apiKey: process.env.WHERE_WAS_I_EMBEDDING_API_KEY ?? apiKeyFromNamedEnv ?? rawProvider.apiKey,
+                timeoutMs: envPositiveInteger(process.env.WHERE_WAS_I_EMBEDDING_TIMEOUT_MS) ?? rawProvider.timeoutMs
+            })
+        }
+    };
+}
+export function mergeEmbeddingConfig(config, overrides = {}) {
+    return definedEmbeddingConfig({
+        ...config.semantic.embedding,
+        ...definedEmbeddingConfig(overrides)
+    });
+}
+export function defaultConfigTemplate() {
+    return {
+        dbPath: "~/.where-was-i/index.sqlite",
+        codexHome: "~/.codex",
+        startup: {
+            lexical: "off",
+            semantic: "off"
+        },
+        semantic: {
+            startupMaxChunks: 100,
+            provider: {
+                baseUrl: "",
+                model: "",
+                apiKeyEnv: "WHERE_WAS_I_EMBEDDING_API_KEY",
+                timeoutMs: DEFAULT_EMBEDDING_TIMEOUT_MS
+            }
+        }
+    };
+}
+export function validateWhereWasIConfigObject(value, configPath = "<config>") {
+    if (!isObject(value)) {
+        throw new Error(`Config file must contain a JSON object: ${configPath}`);
+    }
+    const result = rawWhereWasIConfigSchema.safeParse(value);
+    if (!result.success) {
+        throw new Error(`Invalid config file ${configPath}: ${formatZodIssues(result.error.issues)}`);
+    }
+}
+function readConfigFile(configPath, required) {
+    if (!fs.existsSync(configPath)) {
+        if (required) {
+            throw new Error(`Config file does not exist: ${configPath}`);
+        }
+        return {};
+    }
+    const parsed = JSON.parse(fs.readFileSync(configPath, "utf8"));
+    validateWhereWasIConfigObject(parsed, configPath);
+    return parsed;
+}
+function definedEmbeddingConfig(config) {
+    return Object.fromEntries(Object.entries(config).filter(([, value]) => value !== undefined && value !== ""));
+}
+function envStartupMode(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === "off" || value === "background" || value === "blocking") {
+        return value;
+    }
+    throw new Error(`Invalid startup index mode: ${value}`);
+}
+function envOptionalPositiveInteger(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === "" || value === "0" || value.toLowerCase() === "off") {
+        return null;
+    }
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 1) {
+        throw new Error(`Invalid positive integer environment value: ${value}`);
+    }
+    return parsed;
+}
+function envPositiveInteger(value) {
+    if (value === undefined || value === "") {
+        return undefined;
+    }
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 1) {
+        throw new Error(`Invalid positive integer environment value: ${value}`);
+    }
+    return parsed;
+}
+function formatZodIssues(issues) {
+    return issues
+        .map((issue) => {
+        const issuePath = issue.path.length > 0 ? issue.path.join(".") : "<root>";
+        return `${issuePath}: ${issue.message}`;
+    })
+        .join("; ");
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}