@datename/fastcode-termux 0.0.0-stage → 0.1.6-beta

package/dist/session/log.js

@@ -0,0 +1,331 @@
+/**
+ * Append-only JSONL session log.
+ *
+ * Every entry is flushed as its own line, so a crash (or a kill from the
+ * Android task switcher) still leaves a readable transcript that can be
+ * resumed. A size cap keeps the sessions directory bounded; the oldest logs are
+ * pruned first.
+ *
+ *   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, closeSync, existsSync, fsyncSync, mkdirSync, openSync, readdirSync, readFileSync, readSync, rmSync, statSync, writeFileSync, writeSync } from "node:fs";
+import { basename, join } from "node:path";
+import { getPaths } from "../config/paths.js";
+const NL = String.fromCharCode(10);
+export function sessionCacheLimitBytes() {
+    const mb = Number(process.env["FASTCODE_SESSION_CACHE_MB"]);
+    return (Number.isFinite(mb) && mb > 0 ? mb : 256) * 1024 * 1024;
+}
+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 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 0;
+        const next = seq + 1;
+        const line = JSON.stringify({ ts: Date.now(), seq: next, ...entry }) + NL;
+        try {
+            writeLine(file, line, String(entry.type ?? ""));
+            seq = next;
+            return next;
+        }
+        catch {
+            return 0;
+        }
+    };
+    append({ type: "session_start", id, cwd: process.cwd(), ...meta });
+    return {
+        id,
+        file,
+        append,
+        count() {
+            return seq;
+        },
+        close() {
+            append({ type: "session_end" });
+            closed = true;
+            try {
+                pruneSessions();
+            }
+            catch {
+                // best effort
+            }
+        },
+    };
+}
+export function createSessionLog(meta = {}) {
+    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, meta = {}) {
+    const { sessions } = getPaths();
+    mkdirSync(sessions, { recursive: true });
+    return openLog(undefined, existsSync(file) ? file : join(sessions, file), meta);
+}
+export function listSessions() {
+    const { sessions } = getPaths();
+    if (!existsSync(sessions))
+        return [];
+    return readdirSync(sessions)
+        .filter((name) => name.endsWith(".jsonl"))
+        .map((name) => {
+        const file = join(sessions, name);
+        let bytes = 0;
+        let modified = "";
+        let messages = 0;
+        try {
+            const info = statSync(file);
+            bytes = info.size;
+            modified = info.mtime.toISOString();
+            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
+        }
+        return { id: name.replace(/[.]jsonl$/, ""), file, bytes, modified, messages };
+    })
+        .sort((a, b) => (a.modified < b.modified ? 1 : -1));
+}
+export function resolveSessionFile(idOrFile) {
+    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) {
+    const file = resolveSessionFile(idOrFile);
+    if (!existsSync(file))
+        return [];
+    return readFileSync(file, "utf8")
+        .split(NL)
+        .filter(Boolean)
+        .map((line) => {
+        try {
+            return JSON.parse(line);
+        }
+        catch {
+            return undefined;
+        }
+    })
+        .filter(Boolean);
+}
+export function loadSessionMessages(idOrFile) {
+    return readSession(idOrFile)
+        .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) {
+    const target = projectionPath(file);
+    if (existsSync(target))
+        return;
+    const entries = readSession(file);
+    if (entries.length === 0)
+        return;
+    const summary = summarize(basename(file).replace(/[.]jsonl$/, ""), file, entries);
+    const lastUser = [...entries].reverse().find((entry) => entry.type === "message" && entry.role === "user");
+    const lastAssistant = [...entries].reverse().find((entry) => entry.type === "message" && entry.role === "assistant");
+    const payload = {
+        version: 1,
+        kind: "pruned_session",
+        source: basename(file),
+        createdAt: new Date().toISOString(),
+        summary: {
+            cwd: summary.cwd,
+            providerId: summary.providerId,
+            model: summary.model,
+            turns: summary.turns,
+            messages: summary.messages,
+            activeFiles: summary.activeFiles.slice(0, 200),
+            lastUser: typeof lastUser?.content === "string" ? lastUser.content.slice(0, 2000) : "",
+            lastAssistant: typeof lastAssistant?.content === "string" ? lastAssistant.content.slice(0, 2000) : "",
+        },
+    };
+    writeFileSync(target, JSON.stringify(payload, null, 2), "utf8");
+}
+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;
+        }
+        catch {
+            // keep pruning the rest
+        }
+    }
+    return total;
+}

package/dist/session/projection.d.ts

@@ -0,0 +1,43 @@
+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 Projection {
+    version: 1;
+    kind: "projection";
+    cwd: string;
+    providerId: string;
+    model: string;
+    fingerprint: ProjectionFingerprint;
+    messages: ChatMessage[];
+    activeFiles: ActiveFile[];
+    lastFactSeq: number;
+}
+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 buildProjection(facts: any[], metaOverride?: Partial<SessionMeta>): Projection;
+export declare function readProjection(file: string): Projection | undefined;
+export declare function writeProjection(file: string, projection: Projection): void;
+export declare function resumeSession(file: string, currentCwd?: string): ResumeState;

package/dist/session/projection.js

@@ -0,0 +1,257 @@
+import { createHash } from "node:crypto";
+import { readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { formatToolResults } from "../agent/protocol.js";
+import { toolCatalogHash } from "../agent/registry.js";
+import { projectionPath, readSession } from "./log.js";
+const READ_ONLY_TOOLS = new Set(["read_file", "read_many", "grep", "list_files", "stat_path", "pwd"]);
+const IDEMPOTENT_TOOLS = new Set(["write_file"]);
+const MAX_MESSAGE_CHARS = 4000;
+const MAX_PROJECTION_BYTES = 19_000;
+export function unpairedToolNotice(tool) {
+    if (READ_ONLY_TOOLS.has(tool))
+        return "执行中断（只读工具，可安全重试）。";
+    if (IDEMPOTENT_TOOLS.has(tool))
+        return "执行中断，可安全重试（write_file 为全量写）。";
+    return "执行状态未知：进程中断时命令可能已完成。请先验证再操作（stat / git status / git diff），不要直接重做。";
+}
+export function cwdDigest(cwd) {
+    return createHash("sha1").update(cwd).digest("hex").slice(0, 8);
+}
+export function projectionFingerprint(meta, compactionSource = "none") {
+    return {
+        toolCatalogHash: toolCatalogHash(),
+        modelId: `${meta.providerId}::${meta.model}`,
+        cwdDigest: cwdDigest(meta.cwd),
+        compactionSource,
+    };
+}
+export function sameFingerprint(a, b) {
+    return Boolean(a) && a.toolCatalogHash === b.toolCatalogHash && a.modelId === b.modelId &&
+        a.cwdDigest === b.cwdDigest && a.compactionSource === b.compactionSource;
+}
+export function sessionMetaFromFacts(facts) {
+    let cwd = "";
+    let providerId = "";
+    let model = "";
+    for (const fact of facts) {
+        if (fact?.type === "session_start" || fact?.type === "checkpoint") {
+            if (typeof fact.cwd === "string" && fact.cwd)
+                cwd = fact.cwd;
+            if (typeof fact.providerId === "string" && fact.providerId)
+                providerId = fact.providerId;
+            if (typeof fact.model === "string" && fact.model)
+                model = fact.model;
+        }
+    }
+    return { cwd, providerId, model };
+}
+export function sessionMetaFromFile(file) {
+    return sessionMetaFromFacts(readSession(file));
+}
+function legacyMessages(facts) {
+    return facts
+        .filter((fact) => fact?.type === "message" && typeof fact.content === "string")
+        .map((fact) => ({ role: fact.role, content: fact.content }));
+}
+export function factsToMessages(facts) {
+    const calls = new Map();
+    const pending = [];
+    const messages = [];
+    let nativeTurn = false;
+    const flush = () => {
+        for (const [id, call] of calls) {
+            const output = unpairedToolNotice(String(call?.tool ?? "unknown"));
+            if (nativeTurn)
+                messages.push({ role: "tool", toolCallId: id, content: output });
+            else
+                pending.push({ call, ok: false, output });
+        }
+        calls.clear();
+        if (pending.length > 0)
+            messages.push({ role: "user", content: formatToolResults(pending.splice(0)) });
+    };
+    for (const fact of facts) {
+        if (!fact)
+            continue;
+        if (fact.type === "user") {
+            flush();
+            nativeTurn = false;
+            if (typeof fact.content === "string" && fact.content)
+                messages.push({ role: "user", content: fact.content });
+        }
+        else if (fact.type === "assistant_raw") {
+            flush();
+            const nativeCalls = Array.isArray(fact.toolCalls) ? fact.toolCalls : undefined;
+            nativeTurn = Boolean(nativeCalls && nativeCalls.length > 0);
+            if (typeof fact.content === "string")
+                messages.push({ role: "assistant", content: fact.content, ...(nativeTurn ? { toolCalls: nativeCalls } : {}) });
+        }
+        else if (fact.type === "tool_call") {
+            calls.set(String(fact.id ?? ""), fact.args ?? { tool: fact.tool });
+        }
+        else if (fact.type === "tool_result") {
+            const id = String(fact.id ?? "");
+            const call = calls.get(id) ?? { tool: fact.tool ?? "unknown" };
+            calls.delete(id);
+            if (nativeTurn) {
+                messages.push({ role: "tool", toolCallId: id, content: String(fact.output ?? "") });
+            }
+            else {
+                pending.push({
+                    call,
+                    ok: Boolean(fact.ok),
+                    output: String(fact.output ?? ""),
+                });
+            }
+        }
+    }
+    flush();
+    if (messages.length === 0)
+        return legacyMessages(facts);
+    return messages;
+}
+export function compactionSourceFromFacts(facts) {
+    let source = "none";
+    for (const fact of facts) {
+        if (fact?.type === "compacted" && (fact.source === "local" || fact.source === "server"))
+            source = fact.source;
+    }
+    return source;
+}
+function latestCompaction(facts) {
+    for (let i = facts.length - 1; i >= 0; i -= 1) {
+        if (facts[i]?.type === "compacted")
+            return facts[i];
+    }
+    return undefined;
+}
+function applySummary(messages, facts) {
+    const latest = latestCompaction(facts);
+    if (!latest || latest.source !== "local" || typeof latest.summaryRef !== "string")
+        return messages;
+    try {
+        const summary = readFileSync(latest.summaryRef, "utf8");
+        const keep = Number(latest.keepMessages);
+        const tail = Number.isFinite(keep) && keep > 0 ? messages.slice(-keep) : messages;
+        const first = messages[0]?.role === "user" ? messages[0] : undefined;
+        const marker = { role: "system", content: `[context summary]\n${summary}` };
+        if (first && tail[0] !== first)
+            return [first, marker, ...tail];
+        return [marker, ...tail];
+    }
+    catch {
+        return messages;
+    }
+}
+export function buildProjection(facts, metaOverride) {
+    const detected = sessionMetaFromFacts(facts);
+    const meta = {
+        cwd: metaOverride?.cwd || detected.cwd || process.cwd(),
+        providerId: metaOverride?.providerId || detected.providerId,
+        model: metaOverride?.model || detected.model,
+    };
+    const messages = clampMessages(applySummary(factsToMessages(facts), facts));
+    const source = compactionSourceFromFacts(facts);
+    let activeFiles = [];
+    let lastFactSeq = 0;
+    for (const fact of facts) {
+        if (typeof fact?.seq === "number" && fact.seq > lastFactSeq)
+            lastFactSeq = fact.seq;
+        if (fact?.type === "checkpoint" && Array.isArray(fact.activeFiles))
+            activeFiles = fact.activeFiles;
+    }
+    const projection = {
+        version: 1,
+        kind: "projection",
+        cwd: meta.cwd,
+        providerId: meta.providerId,
+        model: meta.model,
+        fingerprint: projectionFingerprint(meta, source),
+        messages,
+        activeFiles: activeFiles.slice(0, 200),
+        lastFactSeq,
+    };
+    return projection;
+}
+function clampMessages(messages) {
+    const list = messages.map((message) => {
+        const content = message.content.length > MAX_MESSAGE_CHARS
+            ? message.content.slice(0, MAX_MESSAGE_CHARS) + "\n[...truncated in projection...]"
+            : message.content;
+        return {
+            role: message.role,
+            content,
+            ...(message.toolCalls ? { toolCalls: message.toolCalls } : {}),
+            ...(message.toolCallId ? { toolCallId: message.toolCallId } : {}),
+        };
+    });
+    while (list.length > 1 && Buffer.byteLength(JSON.stringify(list), "utf8") > MAX_PROJECTION_BYTES) {
+        if (list.length > 2 && list[0].role === "user")
+            list.splice(1, 1);
+        else
+            list.shift();
+    }
+    return list;
+}
+export function readProjection(file) {
+    try {
+        const raw = JSON.parse(readFileSync(projectionPath(file), "utf8"));
+        if (!raw || raw.version !== 1 || !Array.isArray(raw.messages) || !raw.fingerprint)
+            return undefined;
+        return raw;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function writeProjection(file, projection) {
+    const target = projectionPath(file);
+    const tmp = target + "." + process.pid + ".tmp";
+    try {
+        writeFileSync(tmp, JSON.stringify(projection, null, 2), "utf8");
+        renameSync(tmp, target);
+    }
+    catch (err) {
+        try {
+            rmSync(tmp, { force: true });
+        }
+        catch {
+            // best effort
+        }
+        throw err;
+    }
+}
+export function resumeSession(file, currentCwd = process.cwd()) {
+    const facts = readSession(file);
+    const detected = sessionMetaFromFacts(facts);
+    const meta = {
+        cwd: detected.cwd || currentCwd,
+        providerId: detected.providerId,
+        model: detected.model,
+    };
+    const expected = projectionFingerprint(meta, compactionSourceFromFacts(facts));
+    const stored = readProjection(file);
+    const warnings = [];
+    let projection;
+    let rebuilt = false;
+    if (stored && sameFingerprint(stored.fingerprint, expected)) {
+        projection = stored;
+    }
+    else {
+        projection = buildProjection(facts, meta);
+        rebuilt = true;
+        if (stored)
+            warnings.push("Projection fingerprint changed (tools/model/cwd); rebuilt from facts.");
+        else
+            warnings.push("No projection found; rebuilt from facts.");
+        try {
+            writeProjection(file, projection);
+        }
+        catch {
+            warnings.push("Could not write the projection (filesystem is read-only?); using the in-memory rebuild.");
+        }
+    }
+    if (detected.cwd && detected.cwd !== currentCwd)
+        warnings.push(`Session was recorded in ${detected.cwd}; current directory is ${currentCwd}.`);
+    return { projection, messages: projection.messages, meta, warnings, rebuilt };
+}

package/dist/skills/manager.d.ts

@@ -0,0 +1,18 @@
+/** List skills currently installed under ~/.fastcode/skills. */
+export declare function listInstalledSkills(): any[];
+/** Look up a skill by name (matches folder name OR frontmatter name). */
+export declare function getSkill(name: any): any;
+/** Install a skill. Returns the parsed manifest on success. */
+export declare function installSkill(spec: any, opts?: any): Promise<{
+    name: any;
+    description: any;
+    source: any;
+    path: string;
+    body: any;
+}>;
+/** Remove an installed skill by name or folder. */
+export declare function uninstallSkill(name: any): boolean;
+/** Search the registry for skills matching a query. */
+export declare function searchRegistry(query: any, registry?: string): Promise<any>;
+/** Compose the system-prompt addendum for a list of enabled skill names. */
+export declare function buildSkillsPrompt(enabled: any): string;