@longshot/cli 0.0.1

package/dist/store.js

@@ -0,0 +1,612 @@
+import { readFile, writeFile, appendFile, mkdir, readdir, unlink, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { existsSync, renameSync } from "node:fs";
+import { getPrefix, formatIdForFile, getSeqNumber, isLegacyId, getIdPrefix, setProfileDataDir } from "./profile.js";
+let DATA_DIR = join(import.meta.dirname, "..", ".longshot");
+let TASKS_DIR = join(DATA_DIR, "tasks");
+/** Override data directory (for testing) */
+export function setDataDir(dir) {
+    DATA_DIR = dir;
+    TASKS_DIR = join(dir, "tasks");
+    RUNS_DIR = join(dir, "runs");
+    QUEUE_PATH = join(dir, "queue.json");
+    setProfileDataDir(dir);
+}
+async function ensureDataDir() {
+    if (!existsSync(DATA_DIR)) {
+        // Auto-migrate from old data/ directory if it exists
+        const oldDir = join(DATA_DIR, "..", "data");
+        if (existsSync(oldDir) && (existsSync(join(oldDir, "tasks.json")) || existsSync(join(oldDir, "spec.md")))) {
+            renameSync(oldDir, DATA_DIR);
+            console.log("Migrated data/ → .longshot/");
+        }
+        else {
+            await mkdir(DATA_DIR, { recursive: true });
+        }
+    }
+}
+async function ensureTasksDir() {
+    await ensureDataDir();
+    if (!existsSync(TASKS_DIR)) {
+        await mkdir(TASKS_DIR, { recursive: true });
+    }
+}
+async function ensureArchivesDir() {
+    const dir = join(DATA_DIR, "archives");
+    if (!existsSync(dir)) {
+        await mkdir(dir, { recursive: true });
+    }
+    return dir;
+}
+// --- Spec ---
+export async function readSpec() {
+    await ensureDataDir();
+    const path = join(DATA_DIR, "spec.md");
+    if (!existsSync(path))
+        return "";
+    return readFile(path, "utf-8");
+}
+export async function writeSpec(content) {
+    await ensureDataDir();
+    await writeFile(join(DATA_DIR, "spec.md"), content, "utf-8");
+}
+// --- History ---
+export async function appendHistory(entry) {
+    await ensureDataDir();
+    const line = JSON.stringify(entry) + "\n";
+    await appendFile(join(DATA_DIR, "history.jsonl"), line, "utf-8");
+}
+export async function readHistory() {
+    await ensureDataDir();
+    const path = join(DATA_DIR, "history.jsonl");
+    if (!existsSync(path))
+        return [];
+    const content = await readFile(path, "utf-8");
+    return content
+        .trim()
+        .split("\n")
+        .filter(Boolean)
+        .map((line) => JSON.parse(line));
+}
+const HISTORY_MAX = 500;
+const HISTORY_KEEP = 300;
+export async function truncateHistoryIfNeeded() {
+    const entries = await readHistory();
+    if (entries.length <= HISTORY_MAX)
+        return;
+    const archiveDir = await ensureArchivesDir();
+    const toArchive = entries.slice(0, entries.length - HISTORY_KEEP);
+    const toKeep = entries.slice(entries.length - HISTORY_KEEP);
+    const ts = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+    await writeFile(join(archiveDir, `history-${ts}.jsonl`), toArchive.map((e) => JSON.stringify(e)).join("\n") + "\n", "utf-8");
+    await writeFile(join(DATA_DIR, "history.jsonl"), toKeep.map((e) => JSON.stringify(e)).join("\n") + "\n", "utf-8");
+}
+// --- Conversation (per-prefix) ---
+function conversationPath() {
+    const prefix = getPrefix();
+    return join(DATA_DIR, `conversation-${prefix}.json`);
+}
+export async function readConversation() {
+    await ensureDataDir();
+    const path = conversationPath();
+    if (!existsSync(path))
+        return [];
+    const content = await readFile(path, "utf-8");
+    return JSON.parse(content);
+}
+export async function saveConversation(messages) {
+    await ensureDataDir();
+    await writeFile(conversationPath(), JSON.stringify(messages, null, 2), "utf-8");
+}
+export async function clearConversation() {
+    await ensureDataDir();
+    await writeFile(conversationPath(), "[]", "utf-8");
+}
+const CONVERSATION_MAX = 100;
+const CONVERSATION_KEEP = 50;
+export async function archiveConversationIfNeeded(messages) {
+    if (messages.length <= CONVERSATION_MAX)
+        return messages;
+    const archiveDir = await ensureArchivesDir();
+    const toArchive = messages.slice(0, messages.length - CONVERSATION_KEEP);
+    const toKeep = messages.slice(messages.length - CONVERSATION_KEEP);
+    const prefix = getPrefix();
+    const ts = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+    await writeFile(join(archiveDir, `conversation-${prefix}-${ts}.json`), JSON.stringify(toArchive, null, 2), "utf-8");
+    await saveConversation(toKeep);
+    return toKeep;
+}
+// --- Tasks ---
+async function readTaskIndex() {
+    await ensureTasksDir();
+    const path = join(DATA_DIR, "tasks.json");
+    if (!existsSync(path))
+        return [];
+    const content = await readFile(path, "utf-8");
+    return JSON.parse(content);
+}
+async function writeTaskIndex(tasks) {
+    await ensureTasksDir();
+    await writeFile(join(DATA_DIR, "tasks.json"), JSON.stringify(tasks, null, 2), "utf-8");
+}
+export async function listTasks() {
+    return readTaskIndex();
+}
+export async function getTask(id) {
+    const tasks = await readTaskIndex();
+    // Support both prefixed IDs and legacy numeric IDs
+    const meta = tasks.find((t) => t.id === id || (isLegacyId(id) && String(t.id) === id));
+    if (!meta)
+        return null;
+    const specPath = join(TASKS_DIR, `${formatIdForFile(meta.id)}-${meta.slug}.md`);
+    const spec = existsSync(specPath) ? await readFile(specPath, "utf-8") : "";
+    return { meta, spec };
+}
+export async function createTask(title, slug) {
+    const tasks = await readTaskIndex();
+    const prefix = getPrefix();
+    // Find next sequence number for this prefix
+    const prefixTasks = tasks.filter((t) => {
+        const idPrefix = getIdPrefix(t.id);
+        return idPrefix === prefix;
+    });
+    const maxSeq = prefixTasks.length > 0
+        ? Math.max(...prefixTasks.map((t) => getSeqNumber(t.id)))
+        : 0;
+    const seq = maxSeq + 1;
+    const id = `${prefix}-${seq}`;
+    const now = new Date().toISOString();
+    const meta = {
+        id,
+        slug,
+        title,
+        status: "drafting",
+        created: now,
+        updated: now,
+    };
+    tasks.push(meta);
+    await writeTaskIndex(tasks);
+    // Create empty task spec file
+    const specPath = join(TASKS_DIR, `${formatIdForFile(id)}-${slug}.md`);
+    await writeFile(specPath, `# ${title}\n\nStatus: drafting\n\n`, "utf-8");
+    return meta;
+}
+export async function updateTaskStatus(id, status, checkpoint) {
+    const tasks = await readTaskIndex();
+    const task = tasks.find((t) => t.id === id || (isLegacyId(id) && String(t.id) === id));
+    if (!task)
+        return;
+    task.status = status;
+    task.updated = new Date().toISOString();
+    if (status === "complete") {
+        task.completed = new Date().toISOString();
+    }
+    if (checkpoint) {
+        task.checkpoint = checkpoint;
+    }
+    await writeTaskIndex(tasks);
+}
+export function hasRealSpec(spec) {
+    const lines = spec.split('\n').filter(line => {
+        const trimmed = line.trim();
+        return trimmed && !trimmed.startsWith('# ') && !trimmed.startsWith('Status:');
+    });
+    return lines.length > 0;
+}
+export async function readTaskSpec(id) {
+    const task = await getTask(id);
+    return task?.spec || "";
+}
+export async function writeTaskSpec(id, content) {
+    const tasks = await readTaskIndex();
+    const meta = tasks.find((t) => t.id === id || (isLegacyId(id) && String(t.id) === id));
+    if (!meta)
+        return;
+    const specPath = join(TASKS_DIR, `${formatIdForFile(meta.id)}-${meta.slug}.md`);
+    await writeFile(specPath, content, "utf-8");
+}
+export function getActiveTask(tasks) {
+    return tasks.find((t) => t.status === "in_progress" || t.status === "ready" || t.status === "queued" || t.status === "approved" || t.status === "refining" || t.status === "fixing" || t.status === "conflict");
+}
+// --- Runs ---
+let RUNS_DIR = join(DATA_DIR, "runs");
+async function ensureRunsDir() {
+    await ensureDataDir();
+    if (!existsSync(RUNS_DIR)) {
+        await mkdir(RUNS_DIR, { recursive: true });
+    }
+}
+export function generateRunId() {
+    const now = new Date();
+    const ts = now.toISOString().replace(/[:.]/g, "-").slice(0, 19);
+    const suffix = crypto.randomUUID().slice(0, 8);
+    return `${ts}-${suffix}`;
+}
+export async function appendRunEvent(runId, event) {
+    await ensureRunsDir();
+    const path = join(RUNS_DIR, `${runId}.jsonl`);
+    const line = JSON.stringify(event) + "\n";
+    await appendFile(path, line, "utf-8");
+}
+export async function readRunLog(runId) {
+    await ensureRunsDir();
+    const path = join(RUNS_DIR, `${runId}.jsonl`);
+    if (!existsSync(path))
+        return [];
+    const content = await readFile(path, "utf-8");
+    return content
+        .trim()
+        .split("\n")
+        .filter(Boolean)
+        .map((line) => JSON.parse(line));
+}
+export async function listRuns() {
+    await ensureRunsDir();
+    const files = await readdir(RUNS_DIR);
+    return files
+        .filter((f) => f.endsWith(".jsonl"))
+        .map((f) => f.replace(".jsonl", ""))
+        .sort()
+        .reverse();
+}
+const RUN_MAX_AGE_DAYS = 7;
+export async function cleanOldRuns() {
+    await ensureRunsDir();
+    const files = await readdir(RUNS_DIR);
+    const cutoff = Date.now() - RUN_MAX_AGE_DAYS * 24 * 60 * 60 * 1000;
+    let deleted = 0;
+    for (const f of files) {
+        if (!f.endsWith(".jsonl"))
+            continue;
+        const filePath = join(RUNS_DIR, f);
+        try {
+            const s = await stat(filePath);
+            if (s.mtimeMs < cutoff) {
+                await unlink(filePath);
+                deleted++;
+            }
+        }
+        catch { }
+    }
+    return deleted;
+}
+// --- Task Conversations ---
+async function taskSubDir(taskId) {
+    const tasksPath = join(DATA_DIR, "tasks.json");
+    let slug = "unknown";
+    if (existsSync(tasksPath)) {
+        const content = await readFile(tasksPath, "utf-8");
+        const tasks = JSON.parse(content);
+        const meta = tasks.find((t) => t.id === taskId || (isLegacyId(taskId) && String(t.id) === taskId));
+        if (meta) {
+            slug = meta.slug;
+            taskId = meta.id; // Normalize to actual stored ID
+        }
+    }
+    return join(TASKS_DIR, `${formatIdForFile(taskId)}-${slug}`);
+}
+async function ensureTaskSubDir(taskId) {
+    const dir = await taskSubDir(taskId);
+    if (!existsSync(dir)) {
+        await mkdir(dir, { recursive: true });
+    }
+    return dir;
+}
+export async function readTaskConversation(taskId) {
+    const dir = await taskSubDir(taskId);
+    const path = join(dir, "conversation.json");
+    if (!existsSync(path))
+        return [];
+    try {
+        const content = await readFile(path, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return [];
+    }
+}
+export async function saveTaskConversation(taskId, messages) {
+    const dir = await ensureTaskSubDir(taskId);
+    await writeFile(join(dir, "conversation.json"), JSON.stringify(messages, null, 2), "utf-8");
+}
+export async function archiveTaskConversationIfNeeded(taskId, messages) {
+    if (messages.length <= CONVERSATION_MAX)
+        return messages;
+    const archiveDir = await ensureArchivesDir();
+    const toArchive = messages.slice(0, messages.length - CONVERSATION_KEEP);
+    const toKeep = messages.slice(messages.length - CONVERSATION_KEEP);
+    const ts = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+    await writeFile(join(archiveDir, `task-${taskId}-conversation-${ts}.json`), JSON.stringify(toArchive, null, 2), "utf-8");
+    await saveTaskConversation(taskId, toKeep);
+    return toKeep;
+}
+export function getTaskConversationPath(taskId, slug) {
+    return join(TASKS_DIR, `${formatIdForFile(taskId)}-${slug}`, "conversation.json");
+}
+export function getTaskSpecPath(taskId, slug) {
+    return join(TASKS_DIR, `${formatIdForFile(taskId)}-${slug}.md`);
+}
+// --- Task Reports ---
+export async function getTaskReport(taskId) {
+    const dir = await taskSubDir(taskId);
+    const path = join(dir, "report.md");
+    if (!existsSync(path))
+        return null;
+    try {
+        return await readFile(path, "utf-8");
+    }
+    catch {
+        return null;
+    }
+}
+export async function saveTaskReport(taskId, content) {
+    const dir = await ensureTaskSubDir(taskId);
+    await writeFile(join(dir, "report.md"), content, "utf-8");
+}
+async function verifyDir(taskId) {
+    const tasksPath = join(DATA_DIR, "tasks.json");
+    let slug = "unknown";
+    let resolvedId = taskId;
+    if (existsSync(tasksPath)) {
+        const content = await readFile(tasksPath, "utf-8");
+        const tasks = JSON.parse(content);
+        const meta = tasks.find((t) => t.id === taskId || (isLegacyId(taskId) && String(t.id) === taskId));
+        if (meta) {
+            slug = meta.slug;
+            resolvedId = meta.id;
+        }
+    }
+    return join(TASKS_DIR, `${formatIdForFile(resolvedId)}-${slug}`, "verify");
+}
+export async function ensureVerifyDir(taskId) {
+    const dir = await verifyDir(taskId);
+    if (!existsSync(dir)) {
+        await mkdir(dir, { recursive: true });
+    }
+    return dir;
+}
+export async function nextVerifyRunNumber(taskId) {
+    const dir = await verifyDir(taskId);
+    if (!existsSync(dir))
+        return 1;
+    const files = await readdir(dir);
+    const nums = files
+        .filter((f) => f.match(/^run-\d+-result\.json$/))
+        .map((f) => parseInt(f.match(/^run-(\d+)/)?.[1] || "0", 10));
+    // Also count running ones (jsonl without result)
+    const runningNums = files
+        .filter((f) => f.match(/^run-\d+\.jsonl$/))
+        .map((f) => parseInt(f.match(/^run-(\d+)/)?.[1] || "0", 10));
+    const allNums = [...nums, ...runningNums];
+    return allNums.length > 0 ? Math.max(...allNums) + 1 : 1;
+}
+export async function appendVerifyEvent(taskId, runNumber, event) {
+    const dir = await ensureVerifyDir(taskId);
+    const path = join(dir, `run-${String(runNumber).padStart(3, "0")}.jsonl`);
+    const line = JSON.stringify(event) + "\n";
+    await appendFile(path, line, "utf-8");
+}
+export async function readVerifyLog(taskId, runNumber) {
+    const dir = await verifyDir(taskId);
+    const path = join(dir, `run-${String(runNumber).padStart(3, "0")}.jsonl`);
+    if (!existsSync(path))
+        return [];
+    const content = await readFile(path, "utf-8");
+    return content
+        .trim()
+        .split("\n")
+        .filter(Boolean)
+        .map((line) => JSON.parse(line));
+}
+export async function saveVerifyResult(taskId, result) {
+    const dir = await ensureVerifyDir(taskId);
+    const path = join(dir, `run-${String(result.runNumber).padStart(3, "0")}-result.json`);
+    await writeFile(path, JSON.stringify(result, null, 2), "utf-8");
+}
+export async function readVerifyResult(taskId, runNumber) {
+    const dir = await verifyDir(taskId);
+    const path = join(dir, `run-${String(runNumber).padStart(3, "0")}-result.json`);
+    if (!existsSync(path))
+        return null;
+    const content = await readFile(path, "utf-8");
+    return JSON.parse(content);
+}
+export async function listVerifyResults(taskId) {
+    const dir = await verifyDir(taskId);
+    if (!existsSync(dir))
+        return [];
+    const files = await readdir(dir);
+    const results = [];
+    for (const f of files.filter((f) => f.match(/^run-\d+-result\.json$/)).sort()) {
+        const content = await readFile(join(dir, f), "utf-8");
+        results.push(JSON.parse(content));
+    }
+    return results;
+}
+let QUEUE_PATH = join(DATA_DIR, "queue.json");
+export async function readQueue() {
+    await ensureDataDir();
+    if (!existsSync(QUEUE_PATH))
+        return [];
+    try {
+        const content = await readFile(QUEUE_PATH, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return [];
+    }
+}
+export async function saveQueue(items) {
+    await ensureDataDir();
+    await writeFile(QUEUE_PATH, JSON.stringify(items, null, 2), "utf-8");
+}
+export async function addQueueItem(item) {
+    const queue = await readQueue();
+    const newItem = {
+        ...item,
+        id: crypto.randomUUID(),
+        status: "pending",
+        createdAt: new Date().toISOString(),
+    };
+    queue.push(newItem);
+    await saveQueue(queue);
+    return newItem;
+}
+export async function updateQueueItem(id, update) {
+    const queue = await readQueue();
+    const item = queue.find((q) => q.id === id);
+    if (!item)
+        return;
+    Object.assign(item, update);
+    await saveQueue(queue);
+}
+export async function removeQueueItem(id) {
+    const queue = await readQueue();
+    const idx = queue.findIndex((q) => q.id === id);
+    if (idx === -1)
+        return false;
+    if (queue[idx].status !== "pending")
+        return false;
+    queue.splice(idx, 1);
+    await saveQueue(queue);
+    return true;
+}
+export async function cleanOldQueueItems() {
+    const queue = await readQueue();
+    const cutoff = Date.now() - 24 * 60 * 60 * 1000;
+    const filtered = queue.filter((item) => {
+        if (item.status === "pending" || item.status === "running")
+            return true;
+        const completed = item.completedAt
+            ? new Date(item.completedAt).getTime()
+            : 0;
+        return completed > cutoff;
+    });
+    if (filtered.length !== queue.length) {
+        await saveQueue(filtered);
+    }
+}
+export function getQueueCounts(queue) {
+    let pending = 0;
+    let running = 0;
+    for (const item of queue) {
+        if (item.status === "pending")
+            pending++;
+        if (item.status === "running")
+            running++;
+    }
+    return { pending, running };
+}
+export async function readServices() {
+    await ensureDataDir();
+    const path = join(DATA_DIR, "services.json");
+    if (!existsSync(path))
+        return [];
+    try {
+        const content = await readFile(path, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return [];
+    }
+}
+export async function saveServices(services) {
+    await ensureDataDir();
+    await writeFile(join(DATA_DIR, "services.json"), JSON.stringify(services, null, 2), "utf-8");
+}
+export async function createService(name, command, cwd) {
+    const services = await readServices();
+    const service = {
+        id: crypto.randomUUID().slice(0, 8),
+        name,
+        command,
+        cwd,
+        createdAt: new Date().toISOString(),
+    };
+    services.push(service);
+    await saveServices(services);
+    return service;
+}
+export async function updateService(id, update) {
+    const services = await readServices();
+    const service = services.find((s) => s.id === id);
+    if (!service)
+        return false;
+    if (update.name !== undefined)
+        service.name = update.name;
+    if (update.command !== undefined)
+        service.command = update.command;
+    if (update.cwd !== undefined)
+        service.cwd = update.cwd;
+    await saveServices(services);
+    return true;
+}
+export async function deleteService(id) {
+    const services = await readServices();
+    const idx = services.findIndex((s) => s.id === id);
+    if (idx === -1)
+        return false;
+    services.splice(idx, 1);
+    await saveServices(services);
+    return true;
+}
+export async function getService(id) {
+    const services = await readServices();
+    return services.find((s) => s.id === id) || null;
+}
+export function getServicesLogDir() {
+    return join(DATA_DIR, "services");
+}
+export async function ensureServicesLogDir() {
+    const dir = getServicesLogDir();
+    if (!existsSync(dir)) {
+        await mkdir(dir, { recursive: true });
+    }
+    return dir;
+}
+export async function readBranches() {
+    await ensureDataDir();
+    const path = join(DATA_DIR, "branches.json");
+    if (!existsSync(path))
+        return { active: null, branches: [] };
+    try {
+        const content = await readFile(path, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return { active: null, branches: [] };
+    }
+}
+export async function saveBranches(state) {
+    await ensureDataDir();
+    await writeFile(join(DATA_DIR, "branches.json"), JSON.stringify(state, null, 2), "utf-8");
+}
+// --- MCP Config ---
+export async function readMcpConfig() {
+    const path = join(DATA_DIR, "mcp-config.json");
+    if (!existsSync(path))
+        return null;
+    try {
+        const content = await readFile(path, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+export async function listVerifyArtifacts(taskId, runNumber) {
+    const dir = await verifyDir(taskId);
+    if (!existsSync(dir))
+        return [];
+    const pfx = `run-${String(runNumber).padStart(3, "0")}-`;
+    const files = await readdir(dir);
+    return files.filter((f) => f.startsWith(pfx) && !f.endsWith(".jsonl") && !f.endsWith("-result.json"));
+}
+// --- Re-export profile helpers ---
+export { getPrefix, getSeqNumber, isLegacyId, getIdPrefix, formatIdForFile } from "./profile.js";
+/** Get display-friendly ID (sequence number only) for UI */
+export function getDisplayId(id) {
+    if (isLegacyId(id))
+        return id;
+    return String(getSeqNumber(id));
+}