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

package/src/providers/spec.ts

@@ -0,0 +1,42 @@
+export interface RequestSpec {
+    baseUrl: string;
+    chatPath?: string;
+    modelsPath?: string | null;
+    query?: Record<string, string>;
+    pathParams?: Record<string, string>;
+    authHeaderName?: string;
+    authPrefix?: string;
+}
+
+const ENV_MAP: Record<string, string> = {
+    region: "AWS_REGION",
+    account_id: "CLOUDFLARE_ACCOUNT_ID",
+    project_id: "GOOGLE_CLOUD_PROJECT",
+    deployment: "AZURE_OPENAI_DEPLOYMENT",
+};
+
+export function resolveBaseUrl(spec: RequestSpec): string {
+    return spec.baseUrl.replace(/\{(\w+)\}/g, (_, key) => {
+        const envName = ENV_MAP[key];
+        const value = envName ? process.env[envName] : undefined;
+        if (!value)
+            throw new Error(`Missing ${envName ?? key} for placeholder {${key}}`);
+        return value;
+    });
+}
+
+export function buildRequestUrl(spec: RequestSpec, path: string, params?: Record<string, string>): string {
+    const base = resolveBaseUrl(spec);
+    const merged = { ...spec.pathParams, ...params };
+    const resolvedPath = path.replace(/\{(\w+)\}/g, (_, key) => merged[key] ?? `{${key}}`);
+    const query = spec.query ? "?" + new URLSearchParams(spec.query).toString() : "";
+    return base + resolvedPath + query;
+}
+
+export function buildHeaders(spec: RequestSpec, apiKey: string, extra?: Record<string, string>): Record<string, string> {
+    const headers: Record<string, string> = {
+        [spec.authHeaderName ?? "authorization"]: (spec.authPrefix ?? "Bearer ") + apiKey,
+        ...extra,
+    };
+    return headers;
+}

package/src/providers/xai.ts

@@ -14,5 +14,6 @@ export const xaiProvider = {
     baseUrl: BASE,
     defaultModel: "grok-4.7",
     listModels: (apiKey) => listModelsHttp({ baseUrl: BASE, apiKey, staticModels: STATIC }),
-    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: BASE, apiKey, staticModels: STATIC }),
+    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: BASE, apiKey, staticModels: STATIC, reasoning: "openai" }),
+    supportsReasoning: () => true,
 };

package/src/providers/zhipu.ts

@@ -19,5 +19,6 @@ export const zhipuProvider = {
     },
     defaultModel: "glm-5.3",
     listModels: (apiKey) => listModelsHttp({ baseUrl: baseUrl(), apiKey, staticModels: STATIC }),
-    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: baseUrl(), apiKey, staticModels: STATIC }),
+    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: baseUrl(), apiKey, staticModels: STATIC, reasoning: "openai" }),
+    supportsReasoning: () => true,
 };

package/src/session/log.ts

@@ -8,31 +8,149 @@
  *
  *   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() {
+
+export interface ActiveFile {
+    path: string;
+    sha1_8: string;
+    mtime: string;
+}
+
+export interface SessionSummary {
+    id: string;
+    file: string;
+    cwd: string;
+    providerId: string;
+    model: string;
+    turns: number;
+    activeFiles: ActiveFile[];
+    messages: number;
+    lastTs: number;
+}
+
+/** Reserved slot for conversation compaction at the exit save point. */
+export interface SessionCompactionSlot {
+    source?: "local" | "server" | "none";
+    summaryRef?: string | null;
+    pending?: boolean;
+}
+
+export interface SessionCloseInfo {
+    reason?: "exit" | "signal" | "fatal" | "close";
+    compaction?: SessionCompactionSlot;
+}
+
+export function sessionCacheLimitBytes(): number {
     const mb = Number(process.env["FASTCODE_SESSION_CACHE_MB"]);
     return (Number.isFinite(mb) && mb > 0 ? mb : 256) * 1024 * 1024;
 }
-export function loggingEnabled() {
+
+export function loggingEnabled(): boolean {
     return process.env["FASTCODE_SESSION_LOG"] !== "0";
 }
-function newId() {
+
+export function projectionPath(file: string): string {
+    return file.replace(/[.]jsonl$/, ".projection.json");
+}
+
+export function fsyncMode(): "on" | "off" | "auto" {
+    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: string): boolean {
+    const normalized = root.replace(/\\/g, "/");
+    return normalized === "/sdcard"
+        || normalized.startsWith("/sdcard/")
+        || normalized === "/storage/emulated"
+        || normalized.startsWith("/storage/emulated/");
+}
+
+export function fsyncEnabled(type = "checkpoint"): boolean {
+    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: string, line: string, type: string): void {
+    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: string): void {
+    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: string): number {
+    if (!existsSync(file))
+        return 0;
+    try {
+        return readFileSync(file, "utf8").split(NL).filter(Boolean).length;
+    }
+    catch {
+        return 0;
+    }
+}
+
+function newId(): string {
     return new Date().toISOString().replace(/[:.]/g, "-") + "-" + Math.random().toString(36).slice(2, 6);
 }
-function openLog(id, file, meta) {
+
+function openLog(id: string | undefined, file: string, meta: Record<string, any>) {
     let closed = false;
-    const append = (entry) => {
+    let seq = countLines(file);
+    const append = (entry: Record<string, any>) => {
         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 +158,28 @@ function openLog(id, file, meta) {
         id,
         file,
         append,
-        close() {
-            append({ type: "session_end" });
+        count() {
+            return seq;
+        },
+        close(info: SessionCloseInfo = {}) {
+            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,18 +188,37 @@ function openLog(id, file, meta) {
         },
     };
 }
-export function createSessionLog(meta = {}) {
+
+/** Summary files referenced by older compacted facts in this session. */
+export function staleSummaryRefs(file: string): string[] {
+    let facts: any[];
+    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): ref is string => typeof ref === "string" && ref.length > 0 && ref !== latest)));
+}
+
+export function createSessionLog(meta: Record<string, any> = {}) {
     const { sessions } = getPaths();
     mkdirSync(sessions, { recursive: true });
     const id = newId();
     const file = join(sessions, id + ".jsonl");
     return openLog(id, file, meta);
 }
-export function openSessionLog(file) {
+
+export function openSessionLog(file: string, meta: Record<string, any> = {}) {
     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();
     if (!existsSync(sessions))
@@ -79,7 +234,9 @@ 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
@@ -88,12 +245,14 @@ export function listSessions() {
         })
         .sort((a, b) => (a.modified < b.modified ? 1 : -1));
 }
-export function resolveSessionFile(idOrFile) {
+
+export function resolveSessionFile(idOrFile: string): string {
     const { sessions } = getPaths();
     const looksLikePath = idOrFile.includes("/") || idOrFile.includes(String.fromCharCode(92)) || idOrFile.endsWith(".jsonl");
     return looksLikePath ? idOrFile : join(sessions, idOrFile + ".jsonl");
 }
-export function readSession(idOrFile) {
+
+export function readSession(idOrFile: string) {
     const file = resolveSessionFile(idOrFile);
     if (!existsSync(file))
         return [];
@@ -101,29 +260,152 @@ export function readSession(idOrFile) {
         .split(NL)
         .filter(Boolean)
         .map((line) => {
-        try {
-            return JSON.parse(line);
-        }
-        catch {
-            return undefined;
-        }
-    })
+            try {
+                return JSON.parse(line);
+            }
+            catch {
+                return undefined;
+            }
+        })
         .filter(Boolean);
 }
-export function loadSessionMessages(idOrFile) {
+
+export function loadSessionMessages(idOrFile: string) {
     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() {
+
+export function latestSessionFile(): string | undefined {
     const all = listSessions();
     return all.length > 0 ? all[0].file : undefined;
 }
-export function pruneSessions(limit = sessionCacheLimitBytes()) {
+
+function summarize(id: string, file: string, entries: any[]): SessionSummary {
+    let cwd = "";
+    let providerId = "";
+    let model = "";
+    let turns = 0;
+    let activeFiles: ActiveFile[] = [];
+    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: string): any | undefined {
+    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(): SessionSummary[] {
+    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: SessionSummary[] = [];
+    for (const entry of files) {
+        const last = readLastEntry(entry.file);
+        if (!last || last.type === "session_end")
+            continue;
+        let entries: any[];
+        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(): SessionSummary | undefined {
+    return findUnclosedSessions()[0];
+}
+
+function ensureProjection(file: string): void {
+    // 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()): number {
     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;
         }