@datename/fastcode-termux 0.1.6 → 0.1.8-beta.0

package/dist/session/log.js

@@ -8,10 +8,12 @@
  *
  *   FASTCODE_SESSION_LOG=0        disable logging
  *   FASTCODE_SESSION_CACHE_MB=N   sessions cache cap in MB (default 256)
+ *   FASTCODE_FSYNC=0|1            force checkpoint fsync off/on
  */
-import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync } from "node:fs";
+import { appendFileSync, closeSync, existsSync, fsyncSync, mkdirSync, openSync, readdirSync, readFileSync, readSync, rmSync, statSync, writeSync } from "node:fs";
 import { join } from "node:path";
 import { getPaths } from "../config/paths.js";
+import { buildProjection, writeProjection } from "./projection.js";
 const NL = String.fromCharCode(10);
 export function sessionCacheLimitBytes() {
     const mb = Number(process.env["FASTCODE_SESSION_CACHE_MB"]);
@@ -20,19 +22,93 @@ export function sessionCacheLimitBytes() {
 export function loggingEnabled() {
     return process.env["FASTCODE_SESSION_LOG"] !== "0";
 }
+export function projectionPath(file) {
+    return file.replace(/[.]jsonl$/, ".projection.json");
+}
+export function fsyncMode() {
+    const raw = (process.env["FASTCODE_FSYNC"] ?? "").trim().toLowerCase();
+    if (["1", "true", "yes", "on"].includes(raw))
+        return "on";
+    if (["0", "false", "no", "off"].includes(raw))
+        return "off";
+    return "auto";
+}
+function onSharedStorage(root) {
+    const normalized = root.replace(/\\/g, "/");
+    return normalized === "/sdcard"
+        || normalized.startsWith("/sdcard/")
+        || normalized === "/storage/emulated"
+        || normalized.startsWith("/storage/emulated/");
+}
+export function fsyncEnabled(type = "checkpoint") {
+    if (type !== "checkpoint")
+        return false;
+    const mode = fsyncMode();
+    if (mode === "on")
+        return true;
+    if (mode === "off")
+        return false;
+    return onSharedStorage(getPaths().root);
+}
+function writeLine(file, line, type) {
+    if (!fsyncEnabled(type)) {
+        appendFileSync(file, line, "utf8");
+        return;
+    }
+    const fd = openSync(file, "a");
+    try {
+        writeSync(fd, line);
+        fsyncSync(fd);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+function fsyncPath(file) {
+    if (!existsSync(file))
+        return;
+    try {
+        const fd = openSync(file, "r");
+        try {
+            fsyncSync(fd);
+        }
+        finally {
+            closeSync(fd);
+        }
+    }
+    catch {
+        // FUSE / read-only filesystems may reject fsync; the append is still
+        // best effort and the caller already caught close-level failures.
+    }
+}
+function countLines(file) {
+    if (!existsSync(file))
+        return 0;
+    try {
+        return readFileSync(file, "utf8").split(NL).filter(Boolean).length;
+    }
+    catch {
+        return 0;
+    }
+}
 function newId() {
     return new Date().toISOString().replace(/[:.]/g, "-") + "-" + Math.random().toString(36).slice(2, 6);
 }
 function openLog(id, file, meta) {
     let closed = false;
+    let seq = countLines(file);
     const append = (entry) => {
         if (closed || !loggingEnabled())
-            return;
+            return 0;
+        const next = seq + 1;
+        const line = JSON.stringify({ ts: Date.now(), seq: next, ...entry }) + NL;
         try {
-            appendFileSync(file, JSON.stringify({ ts: Date.now(), ...entry }) + NL, "utf8");
+            writeLine(file, line, String(entry.type ?? ""));
+            seq = next;
+            return next;
         }
         catch {
-            // A read-only or full filesystem must not break the TUI.
+            return 0;
         }
     };
     append({ type: "session_start", id, cwd: process.cwd(), ...meta });
@@ -40,10 +116,28 @@ function openLog(id, file, meta) {
         id,
         file,
         append,
-        close() {
-            append({ type: "session_end" });
+        count() {
+            return seq;
+        },
+        close(info = {}) {
+            append({
+                type: "session_end",
+                reason: info.reason ?? "close",
+                // Reserved extension point: future compaction can fill this
+                // slot without changing the session_end event shape.
+                compaction: {
+                    source: info.compaction?.source ?? "none",
+                    summaryRef: info.compaction?.summaryRef ?? null,
+                    pending: info.compaction?.pending ?? false,
+                },
+            });
             closed = true;
             try {
+                // Snapshot + manifest are written while the facts still exist;
+                // pruning later keeps this verified copy.
+                ensureProjection(file);
+                fsyncPath(file);
+                fsyncPath(projectionPath(file));
                 pruneSessions();
             }
             catch {
@@ -52,6 +146,21 @@ function openLog(id, file, meta) {
         },
     };
 }
+/** Summary files referenced by older compacted facts in this session. */
+export function staleSummaryRefs(file) {
+    let facts;
+    try {
+        facts = readSession(file);
+    }
+    catch {
+        return [];
+    }
+    const compacted = facts.filter((fact) => fact?.type === "compacted");
+    const latest = compacted.at(-1)?.summaryRef;
+    return Array.from(new Set(compacted
+        .map((fact) => fact.summaryRef)
+        .filter((ref) => typeof ref === "string" && ref.length > 0 && ref !== latest)));
+}
 export function createSessionLog(meta = {}) {
     const { sessions } = getPaths();
     mkdirSync(sessions, { recursive: true });
@@ -59,10 +168,10 @@ export function createSessionLog(meta = {}) {
     const file = join(sessions, id + ".jsonl");
     return openLog(id, file, meta);
 }
-export function openSessionLog(file) {
+export function openSessionLog(file, meta = {}) {
     const { sessions } = getPaths();
     mkdirSync(sessions, { recursive: true });
-    return openLog(undefined, existsSync(file) ? file : join(sessions, file), {});
+    return openLog(undefined, existsSync(file) ? file : join(sessions, file), meta);
 }
 export function listSessions() {
     const { sessions } = getPaths();
@@ -79,7 +188,8 @@ export function listSessions() {
             const info = statSync(file);
             bytes = info.size;
             modified = info.mtime.toISOString();
-            messages = readFileSync(file, "utf8").split(NL).filter((line) => line.includes('"type":"message"')).length;
+            messages = readFileSync(file, "utf8").split(NL).filter((line) => line.includes('"type":"user"') ||
+                (line.includes('"type":"message"') && line.includes('"role":"user"'))).length;
         }
         catch {
             // unreadable: report what we have
@@ -112,18 +222,133 @@ export function readSession(idOrFile) {
 }
 export function loadSessionMessages(idOrFile) {
     return readSession(idOrFile)
-        .filter((entry) => entry.type === "message" && typeof entry.content === "string")
-        .map((entry) => ({ role: entry.role, content: entry.content }));
+        .filter((entry) => (entry.type === "message" || entry.type === "user" || entry.type === "assistant_raw") && typeof entry.content === "string")
+        .map((entry) => ({
+        role: entry.type === "assistant_raw" ? "assistant" : entry.role ?? "user",
+        content: entry.content,
+    }));
 }
 export function latestSessionFile() {
     const all = listSessions();
     return all.length > 0 ? all[0].file : undefined;
 }
+function summarize(id, file, entries) {
+    let cwd = "";
+    let providerId = "";
+    let model = "";
+    let turns = 0;
+    let activeFiles = [];
+    let messages = 0;
+    let lastTs = 0;
+    for (const entry of entries) {
+        if (typeof entry.ts === "number")
+            lastTs = entry.ts;
+        if (entry.type === "session_start") {
+            cwd = typeof entry.cwd === "string" ? entry.cwd : cwd;
+            providerId = typeof entry.providerId === "string" ? entry.providerId : providerId;
+            model = typeof entry.model === "string" ? entry.model : model;
+        }
+        else if (entry.type === "message") {
+            messages += 1;
+        }
+        else if (entry.type === "checkpoint") {
+            cwd = typeof entry.cwd === "string" ? entry.cwd : cwd;
+            providerId = typeof entry.providerId === "string" ? entry.providerId : providerId;
+            model = typeof entry.model === "string" ? entry.model : model;
+            if (typeof entry.turn === "number")
+                turns = entry.turn;
+            if (Array.isArray(entry.activeFiles))
+                activeFiles = entry.activeFiles;
+        }
+    }
+    return { id, file, cwd, providerId, model, turns, activeFiles, messages, lastTs };
+}
+function readLastEntry(file) {
+    let size = 0;
+    try {
+        size = statSync(file).size;
+    }
+    catch {
+        return undefined;
+    }
+    if (size === 0)
+        return undefined;
+    const length = Math.min(size, 64 * 1024);
+    const fd = openSync(file, "r");
+    try {
+        const buffer = Buffer.alloc(length);
+        readSync(fd, buffer, 0, length, size - length);
+        const lines = buffer.toString("utf8").trimEnd().split(NL);
+        for (let i = lines.length - 1; i >= 0; i -= 1) {
+            if (!lines[i])
+                continue;
+            try {
+                return JSON.parse(lines[i]);
+            }
+            catch {
+                return { type: "unparsable_tail" };
+            }
+        }
+        return undefined;
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+export function findUnclosedSessions() {
+    const { sessions } = getPaths();
+    if (!existsSync(sessions))
+        return [];
+    const files = readdirSync(sessions)
+        .filter((name) => name.endsWith(".jsonl"))
+        .map((name) => {
+        const file = join(sessions, name);
+        let modified = 0;
+        try {
+            modified = statSync(file).mtimeMs;
+        }
+        catch {
+            // unreadable
+        }
+        return { name, file, modified };
+    })
+        .sort((a, b) => b.modified - a.modified);
+    const out = [];
+    for (const entry of files) {
+        const last = readLastEntry(entry.file);
+        if (!last || last.type === "session_end")
+            continue;
+        let entries;
+        try {
+            entries = readSession(entry.file);
+        }
+        catch {
+            continue;
+        }
+        if (entries.length === 0 || !entries.some((item) => item.type === "session_start"))
+            continue;
+        out.push(summarize(entry.name.replace(/[.]jsonl$/, ""), entry.file, entries));
+    }
+    return out;
+}
+export function latestUnclosedSession() {
+    return findUnclosedSessions()[0];
+}
+function ensureProjection(file) {
+    // Always refresh from the facts that still exist: a projection written at
+    // an earlier checkpoint may be stale by the time we close or prune. If the
+    // JSONL is already gone, leave the verified projection untouched.
+    const entries = readSession(file);
+    if (entries.length === 0)
+        return;
+    writeProjection(file, buildProjection(entries), entries);
+}
 export function pruneSessions(limit = sessionCacheLimitBytes()) {
     const all = listSessions();
     let total = all.reduce((sum, entry) => sum + entry.bytes, 0);
     for (let i = all.length - 1; i >= 0 && total > limit; i -= 1) {
         try {
+            ensureProjection(all[i].file);
             rmSync(all[i].file, { force: true });
             total -= all[i].bytes;
         }

package/dist/session/projection.d.ts

@@ -0,0 +1,76 @@
+import type { ChatMessage } from "../types.js";
+import { type ActiveFile } from "./log.js";
+export interface SessionMeta {
+    cwd: string;
+    providerId: string;
+    model: string;
+}
+export interface ProjectionFingerprint {
+    toolCatalogHash: string;
+    modelId: string;
+    cwdDigest: string;
+    compactionSource: "local" | "server" | "none";
+}
+export interface ProjectionManifest {
+    version: 1;
+    algorithm: "sha256";
+    savedAt: string;
+    /** Hash of the projection content (messages/meta/files). */
+    contentHash: string;
+    /** Hash of the source JSONL facts at save time, when available. */
+    sessionHash?: string;
+    /** Highest fact sequence covered by this projection. */
+    lastFactSeq?: number;
+}
+export interface Projection {
+    version: 1;
+    kind: "projection";
+    cwd: string;
+    providerId: string;
+    model: string;
+    fingerprint: ProjectionFingerprint;
+    messages: ChatMessage[];
+    activeFiles: ActiveFile[];
+    lastFactSeq: number;
+    /** Integrity data written at save/prune time; never re-derived from facts. */
+    manifest?: ProjectionManifest;
+}
+export type ProjectionReadStatus = "ok" | "legacy" | "hash_mismatch" | "corrupt" | "missing";
+export interface ProjectionReadResult {
+    status: ProjectionReadStatus;
+    projection?: Projection;
+    expectedHash?: string;
+    actualHash?: string;
+}
+export interface ResumeState {
+    projection: Projection;
+    messages: ChatMessage[];
+    meta: SessionMeta;
+    warnings: string[];
+    rebuilt: boolean;
+}
+export declare function unpairedToolNotice(tool: string): string;
+export declare function cwdDigest(cwd: string): string;
+export declare function projectionFingerprint(meta: SessionMeta, compactionSource?: ProjectionFingerprint["compactionSource"]): ProjectionFingerprint;
+export declare function sameFingerprint(a: ProjectionFingerprint | undefined, b: ProjectionFingerprint): boolean;
+export declare function sessionMetaFromFacts(facts: any[]): SessionMeta;
+export declare function sessionMetaFromFile(file: string): SessionMeta;
+export declare function factsToMessages(facts: any[]): ChatMessage[];
+export declare function compactionSourceFromFacts(facts: any[]): ProjectionFingerprint["compactionSource"];
+export declare function projectionContentHash(projection: Projection): string;
+export declare function factsContentHash(facts: any[]): string;
+/**
+ * Keep native tool_call/tool_result pairs complete. Orphan tool messages left
+ * behind by projection truncation are dropped; missing results are synthesized
+ * with the existing "execution unknown" notice so a resumed model never waits
+ * for a result that cannot arrive.
+ */
+export declare function pairToolMessages(messages: ChatMessage[]): {
+    messages: ChatMessage[];
+    repaired: boolean;
+};
+export declare function buildProjection(facts: any[], metaOverride?: Partial<SessionMeta>): Projection;
+export declare function readProjectionResult(file: string): ProjectionReadResult;
+export declare function readProjection(file: string): Projection | undefined;
+export declare function writeProjection(file: string, projection: Projection, facts?: any[]): void;
+export declare function resumeSession(file: string, currentCwd?: string): ResumeState;