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

package/dist/patch/apply.js

@@ -0,0 +1,172 @@
+import { closeSync, constants as fsConstants, fchmodSync, lstatSync, mkdirSync, openSync, renameSync, rmSync, unlinkSync, writeSync } from "node:fs";
+import { dirname } from "node:path";
+export function applyPatchPlan(plan) {
+    const warnings = [...plan.warnings];
+    const applied = [];
+    const touched = [];
+    const removed = [];
+    const temps = [];
+    try {
+        for (const file of plan.files) {
+            commit(file, warnings, temps);
+            applied.push(file);
+            if (file.kind === "delete") {
+                removed.push(file.path);
+            }
+            else if (file.kind === "add") {
+                touched.push(file.path);
+            }
+            else if (file.moveTo) {
+                removed.push(file.path);
+                touched.push(file.moveTo);
+            }
+            else {
+                touched.push(file.path);
+            }
+        }
+    }
+    catch (err) {
+        for (const tmp of temps) {
+            try {
+                rmSync(tmp, { force: true });
+            }
+            catch {
+                // best effort
+            }
+        }
+        rollback(applied, warnings);
+        return {
+            ok: false,
+            output: `patch failed: ${err?.message ?? String(err)}; rolled back ${applied.length} file(s)`,
+            files: [],
+            touched: [],
+            removed: [],
+            warnings,
+        };
+    }
+    const files = plan.files.map((file) => ({
+        path: file.moveTo ?? file.path,
+        kind: file.kind,
+        diff: file.diff,
+    }));
+    return {
+        ok: true,
+        output: [`applied ${plan.files.length} file(s)`, ...files.map((file) => file.diff)].join("\n\n"),
+        files,
+        touched,
+        removed,
+        warnings,
+    };
+}
+function commit(file, warnings, temps) {
+    if (file.kind === "delete") {
+        rejectSymlink(file.path);
+        unlinkSync(file.path);
+        return;
+    }
+    const target = file.moveTo ?? file.path;
+    if (file.kind === "add" || file.moveTo) {
+        if (lexists(target))
+            throw new Error(`target already exists: ${target}`);
+    }
+    rejectSymlink(target, true);
+    mkdirSync(dirname(target), { recursive: true });
+    const tmp = `${target}.fastcode-patch-${process.pid}-${Math.random().toString(36).slice(2, 8)}.tmp`;
+    temps.push(tmp);
+    const flags = fsConstants.O_WRONLY | fsConstants.O_CREAT | fsConstants.O_EXCL | (fsConstants.O_NOFOLLOW ?? 0);
+    const fd = openSync(tmp, flags, 0o600);
+    try {
+        writeSync(fd, file.newContent ?? "");
+        try {
+            fchmodSync(fd, file.origMode & 0o777);
+        }
+        catch {
+            warnings.push(`could not restore mode ${(file.origMode & 0o777).toString(8)} on ${target}; check permissions`);
+        }
+    }
+    finally {
+        closeSync(fd);
+    }
+    rejectSymlink(target, true);
+    renameSync(tmp, target);
+    const index = temps.indexOf(tmp);
+    if (index >= 0)
+        temps.splice(index, 1);
+    if (file.moveTo) {
+        try {
+            unlinkSync(file.path);
+        }
+        catch (err) {
+            try {
+                rmSync(target, { force: true });
+            }
+            catch {
+                // best effort
+            }
+            throw err;
+        }
+    }
+}
+function rejectSymlink(path, allowMissing = false) {
+    try {
+        if (lstatSync(path).isSymbolicLink())
+            throw new Error(`refusing to write through a symbolic link: ${path}`);
+    }
+    catch (err) {
+        if (err?.code === "ENOENT" && allowMissing)
+            return;
+        throw err;
+    }
+}
+function lexists(path) {
+    try {
+        lstatSync(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function rollback(applied, warnings) {
+    for (let i = applied.length - 1; i >= 0; i -= 1) {
+        const file = applied[i];
+        try {
+            if (file.kind === "add") {
+                rmSync(file.path, { force: true });
+                continue;
+            }
+            if (file.kind === "delete") {
+                restore(file.path, file.oldContent ?? "", file.origMode);
+                continue;
+            }
+            if (file.moveTo) {
+                rmSync(file.moveTo, { force: true });
+                restore(file.path, file.oldContent ?? "", file.origMode);
+                continue;
+            }
+            restore(file.path, file.oldContent ?? "", file.origMode);
+        }
+        catch (err) {
+            warnings.push(`rollback failed for ${file.path}: ${err?.message ?? String(err)}`);
+        }
+    }
+}
+function restore(path, content, mode) {
+    mkdirSync(dirname(path), { recursive: true });
+    const tmp = `${path}.fastcode-restore-${process.pid}-${Math.random().toString(36).slice(2, 8)}.tmp`;
+    const flags = fsConstants.O_WRONLY | fsConstants.O_CREAT | fsConstants.O_EXCL | (fsConstants.O_NOFOLLOW ?? 0);
+    const fd = openSync(tmp, flags, 0o600);
+    try {
+        writeSync(fd, content);
+        try {
+            fchmodSync(fd, mode & 0o777);
+        }
+        catch {
+            // best effort during rollback
+        }
+    }
+    finally {
+        closeSync(fd);
+    }
+    renameSync(tmp, path);
+}

package/dist/patch/parse.d.ts

@@ -0,0 +1,29 @@
+export type PatchLineType = " " | "-" | "+";
+export interface PatchLine {
+    type: PatchLineType;
+    text: string;
+}
+export interface PatchHunk {
+    lines: PatchLine[];
+}
+export type PatchOp = {
+    kind: "add";
+    path: string;
+    lines: string[];
+} | {
+    kind: "delete";
+    path: string;
+} | {
+    kind: "update";
+    path: string;
+    hunks: PatchHunk[];
+    moveTo?: string;
+};
+export type ParseResult = {
+    ok: true;
+    ops: PatchOp[];
+} | {
+    ok: false;
+    output: string;
+};
+export declare function parsePatch(patch: string): ParseResult;

package/dist/patch/parse.js

@@ -0,0 +1,112 @@
+export function parsePatch(patch) {
+    const lines = String(patch ?? "").split(/\r?\n/);
+    if (lines[0] !== "*** Begin Patch")
+        return fail("patch must start with *** Begin Patch");
+    const ops = [];
+    const seen = new Set();
+    const claim = (path) => {
+        if (!path)
+            return "empty file path in patch";
+        if (seen.has(path))
+            return `duplicate file in patch: ${path}`;
+        seen.add(path);
+        return undefined;
+    };
+    let i = 1;
+    let foundEnd = false;
+    while (i < lines.length) {
+        const line = lines[i];
+        if (line === "*** End Patch") {
+            foundEnd = true;
+            i += 1;
+            break;
+        }
+        if (line === "" || line === undefined) {
+            i += 1;
+            continue;
+        }
+        if (line.startsWith("*** Add File: ")) {
+            const path = line.slice("*** Add File: ".length).trim();
+            const duplicate = claim(path);
+            if (duplicate)
+                return fail(duplicate);
+            i += 1;
+            const content = [];
+            while (i < lines.length && !lines[i].startsWith("*** ")) {
+                const row = lines[i];
+                if (row === "") {
+                    content.push("");
+                    i += 1;
+                    continue;
+                }
+                if (!row.startsWith("+"))
+                    return fail(`Add File body must start with '+': ${row}`);
+                content.push(row.slice(1));
+                i += 1;
+            }
+            ops.push({ kind: "add", path, lines: content });
+            continue;
+        }
+        if (line.startsWith("*** Delete File: ")) {
+            const path = line.slice("*** Delete File: ".length).trim();
+            const duplicate = claim(path);
+            if (duplicate)
+                return fail(duplicate);
+            ops.push({ kind: "delete", path });
+            i += 1;
+            continue;
+        }
+        if (line.startsWith("*** Update File: ")) {
+            const path = line.slice("*** Update File: ".length).trim();
+            const duplicate = claim(path);
+            if (duplicate)
+                return fail(duplicate);
+            i += 1;
+            let moveTo;
+            if (i < lines.length && lines[i].startsWith("*** Move to: ")) {
+                moveTo = lines[i].slice("*** Move to: ".length).trim();
+                const movedDuplicate = claim(moveTo);
+                if (movedDuplicate)
+                    return fail(movedDuplicate);
+                i += 1;
+            }
+            const hunks = [];
+            let current;
+            while (i < lines.length && !lines[i].startsWith("*** ")) {
+                const row = lines[i];
+                if (row === "") {
+                    i += 1;
+                    continue;
+                }
+                if (row.startsWith("@@")) {
+                    current = { lines: [] };
+                    hunks.push(current);
+                    i += 1;
+                    continue;
+                }
+                const type = row[0];
+                if (type !== " " && type !== "-" && type !== "+")
+                    return fail(`invalid hunk line (must start with ' ', '-', or '+'): ${row}`);
+                if (!current) {
+                    current = { lines: [] };
+                    hunks.push(current);
+                }
+                current.lines.push({ type: type, text: row.slice(1) });
+                i += 1;
+            }
+            if (hunks.length === 0 && !moveTo)
+                return fail(`Update File has no hunks: ${path}`);
+            ops.push({ kind: "update", path, hunks, moveTo });
+            continue;
+        }
+        return fail(`unsupported patch directive: ${line}`);
+    }
+    if (!foundEnd)
+        return fail("patch must end with *** End Patch");
+    if (ops.length === 0)
+        return fail("patch contains no file operations");
+    return { ok: true, ops };
+}
+function fail(output) {
+    return { ok: false, output };
+}

package/dist/patch/plan.d.ts

@@ -0,0 +1,49 @@
+import { type PatchHunk } from "./parse.js";
+export interface PlannedFile {
+    kind: "add" | "delete" | "update";
+    relPath: string;
+    path: string;
+    moveRel?: string;
+    moveTo?: string;
+    existed: boolean;
+    origMode: number;
+    eol: "\n" | "\r\n";
+    oldContent?: string;
+    newContent?: string;
+    diff: string;
+    changedLines: number;
+}
+export interface PatchPlan {
+    files: PlannedFile[];
+    warnings: string[];
+}
+export type PlanResult = {
+    ok: true;
+    plan: PatchPlan;
+} | {
+    ok: false;
+    output: string;
+};
+export type PatchReview = {
+    kind: "allow";
+} | {
+    kind: "deny";
+    reason: string;
+} | {
+    kind: "pending";
+    reason: string;
+    changedLines: number;
+};
+export declare function planPatch(patch: string, cwd: string): PlanResult;
+export declare function reviewPatchPlan(plan: PatchPlan): PatchReview;
+export declare function detectEol(content: string): "\n" | "\r\n";
+type ApplyHunksResult = {
+    ok: true;
+    content: string;
+} | {
+    ok: false;
+    output: string;
+};
+export declare function applyHunks(oldContent: string, hunks: PatchHunk[]): ApplyHunksResult;
+export declare function makeDiff(oldPath: string | null, newPath: string | null, oldContent: string, newContent: string, kind: "add" | "delete" | "update"): string;
+export {};

package/dist/patch/plan.js

@@ -0,0 +1,273 @@
+import { closeSync, constants as fsConstants, lstatSync, openSync, readFileSync } from "node:fs";
+import { basename } from "node:path";
+import { sandboxPath } from "../agent/tools/paths.js";
+import { parsePatch } from "./parse.js";
+export function planPatch(patch, cwd) {
+    const parsed = parsePatch(patch);
+    if (parsed.ok === false)
+        return { ok: false, output: parsed.output };
+    const files = [];
+    const warnings = [];
+    for (const op of parsed.ops) {
+        const planned = planOp(op, cwd, warnings);
+        if (planned.ok === false)
+            return { ok: false, output: planned.output };
+        files.push(planned.file);
+    }
+    return { ok: true, plan: { files, warnings } };
+}
+function planOp(op, cwd, warnings) {
+    try {
+        const path = sandboxPath(cwd, op.path);
+        if (op.kind === "add") {
+            if (lexists(path))
+                return { ok: false, output: `Add File target already exists: ${op.path}` };
+            const newContent = op.lines.length > 0 ? op.lines.join("\n") + "\n" : "";
+            return {
+                ok: true,
+                file: {
+                    kind: "add",
+                    relPath: op.path,
+                    path,
+                    existed: false,
+                    origMode: 0o644,
+                    eol: "\n",
+                    newContent,
+                    diff: makeDiff(null, op.path, "", newContent, "add"),
+                    changedLines: newContent.split("\n").filter(Boolean).length,
+                },
+            };
+        }
+        if (!lexists(path))
+            return { ok: false, output: `file not found: ${op.path}` };
+        const info = lstatSync(path);
+        if (info.isSymbolicLink())
+            return { ok: false, output: `refusing to patch a symbolic link: ${op.path}` };
+        if (!info.isFile())
+            return { ok: false, output: `not a regular file: ${op.path}` };
+        const oldContent = readNoFollow(path);
+        if (op.kind === "delete") {
+            return {
+                ok: true,
+                file: {
+                    kind: "delete",
+                    relPath: op.path,
+                    path,
+                    existed: true,
+                    origMode: info.mode & 0o777,
+                    eol: detectEol(oldContent),
+                    oldContent,
+                    diff: makeDiff(op.path, null, oldContent, "", "delete"),
+                    changedLines: oldContent.split(/\r?\n/).length,
+                },
+            };
+        }
+        const eol = detectEol(oldContent);
+        if (eol === "\n" && /\r\n/.test(oldContent))
+            warnings.push(`mixed line endings in ${op.path}; writing LF`);
+        let newContent = oldContent;
+        if (op.hunks.length > 0) {
+            const applied = applyHunks(oldContent, op.hunks);
+            if (applied.ok === false)
+                return applied;
+            newContent = applied.content;
+            if (eol === "\r\n")
+                newContent = newContent.replace(/\n/g, "\r\n");
+        }
+        let moveTo;
+        let moveRel;
+        if (op.moveTo) {
+            moveTo = sandboxPath(cwd, op.moveTo);
+            if (lexists(moveTo))
+                return { ok: false, output: `Move target already exists: ${op.moveTo}` };
+            moveRel = op.moveTo;
+        }
+        const diff = makeDiff(op.path, op.moveTo ?? op.path, oldContent, newContent, "update");
+        return {
+            ok: true,
+            file: {
+                kind: "update",
+                relPath: op.path,
+                path,
+                moveRel,
+                moveTo,
+                existed: true,
+                origMode: info.mode & 0o777,
+                eol,
+                oldContent,
+                newContent,
+                diff,
+                changedLines: countChangedLines(oldContent, newContent),
+            },
+        };
+    }
+    catch (err) {
+        return { ok: false, output: err?.message ?? String(err) };
+    }
+}
+export function reviewPatchPlan(plan) {
+    let changed = 0;
+    for (const file of plan.files) {
+        changed += file.changedLines;
+        if (isHardDenied(file.path))
+            return { kind: "deny", reason: `patch targets a protected path: ${file.relPath}` };
+        if (isSensitivePath(file.path))
+            return { kind: "pending", reason: `patch targets a sensitive path: ${file.relPath}`, changedLines: changed };
+    }
+    if (changed > 200)
+        return { kind: "pending", reason: `patch changes ${changed} lines (limit 200)`, changedLines: changed };
+    return { kind: "allow" };
+}
+function isHardDenied(path) {
+    const normalized = path.replace(/\\/g, "/").toLowerCase();
+    const segments = normalized.split("/");
+    if (segments.includes(".ssh") || segments.includes(".gnupg"))
+        return true;
+    if (normalized.includes("/.git/hooks/"))
+        return true;
+    if (normalized.includes("/android/data/"))
+        return true;
+    const name = basename(normalized);
+    return name === "auth.json" || name === "trust.json";
+}
+function isSensitivePath(path) {
+    const normalized = path.replace(/\\/g, "/").toLowerCase();
+    const name = basename(normalized);
+    return name === ".env" || name.startsWith(".env.") || /[.](pem|key|p12|pfx)$/.test(name) || normalized.includes("/.git/hooks/");
+}
+function lexists(path) {
+    try {
+        lstatSync(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function readNoFollow(path) {
+    const flags = fsConstants.O_RDONLY | (fsConstants.O_NOFOLLOW ?? 0);
+    const fd = openSync(path, flags);
+    try {
+        return readFileSync(fd, "utf8");
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+export function detectEol(content) {
+    const crlf = (content.match(/\r\n/g) ?? []).length;
+    const lf = (content.match(/\n/g) ?? []).length;
+    return crlf > 0 && crlf === lf ? "\r\n" : "\n";
+}
+export function applyHunks(oldContent, hunks) {
+    const lines = oldContent.split(/\r?\n/);
+    let changed = false;
+    for (const hunk of hunks) {
+        const needle = hunk.lines.filter((line) => line.type !== "+").map((line) => line.text);
+        const replacement = hunk.lines.filter((line) => line.type !== "-").map((line) => line.text);
+        if (needle.length === 0) {
+            const at = lines.length > 0 && lines[lines.length - 1] === "" ? lines.length - 1 : lines.length;
+            lines.splice(at, 0, ...replacement);
+            changed = true;
+            continue;
+        }
+        const verdict = findHunk(lines, needle);
+        if (verdict.ok === false)
+            return verdict;
+        lines.splice(verdict.index, needle.length, ...replacement);
+        changed = true;
+    }
+    if (!changed)
+        return { ok: false, output: "patch made no changes" };
+    return { ok: true, content: lines.join("\n") };
+}
+function findHunk(lines, needle) {
+    for (let level = 0; level < 3; level += 1) {
+        const matches = matchAll(lines, needle, level);
+        if (matches.length === 0)
+            continue;
+        if (matches.length > 1) {
+            return {
+                ok: false,
+                output: `ambiguous patch context (${matches.length} candidates at lines ${matches.map((index) => index + 1).join(", ")}); add surrounding context`,
+            };
+        }
+        return { ok: true, index: matches[0] };
+    }
+    return { ok: false, output: `patch context not found: ${JSON.stringify(needle.slice(0, 4))}` };
+}
+function matchAll(lines, needle, level) {
+    const found = [];
+    const wanted = needle.map((line) => normalizeLine(line, level));
+    for (let i = 0; i + needle.length <= lines.length; i += 1) {
+        let match = true;
+        for (let j = 0; j < needle.length; j += 1) {
+            if (normalizeLine(lines[i + j], level) !== wanted[j]) {
+                match = false;
+                break;
+            }
+        }
+        if (match)
+            found.push(i);
+    }
+    return found;
+}
+function normalizeLine(line, level) {
+    if (level === 0)
+        return line;
+    if (level === 1)
+        return line.replace(/\s+$/, "");
+    return line.replace(/\s+/g, " ").trim();
+}
+export function makeDiff(oldPath, newPath, oldContent, newContent, kind) {
+    const oldLines = splitDiffLines(oldContent);
+    const newLines = splitDiffLines(newContent);
+    let prefix = 0;
+    while (prefix < oldLines.length && prefix < newLines.length && oldLines[prefix] === newLines[prefix])
+        prefix += 1;
+    let suffix = 0;
+    while (suffix < oldLines.length - prefix && suffix < newLines.length - prefix &&
+        oldLines[oldLines.length - 1 - suffix] === newLines[newLines.length - 1 - suffix])
+        suffix += 1;
+    const oldMiddle = oldLines.slice(prefix, oldLines.length - suffix);
+    const newMiddle = newLines.slice(prefix, newLines.length - suffix);
+    const oldStart = prefix + 1;
+    const newStart = prefix + 1;
+    const header = kind === "add"
+        ? `--- /dev/null\n+++ b/${newPath ?? ""}`
+        : kind === "delete"
+            ? `--- a/${oldPath ?? ""}\n+++ /dev/null`
+            : `--- a/${oldPath ?? ""}\n+++ b/${newPath ?? oldPath ?? ""}`;
+    const body = [
+        `@@ -${oldStart},${oldMiddle.length} +${newStart},${newMiddle.length} @@`,
+        ...oldMiddle.map((line) => "-" + line),
+        ...newMiddle.map((line) => "+" + line),
+    ];
+    return [header, ...body].join("\n");
+}
+function splitDiffLines(content) {
+    if (content === "")
+        return [];
+    const lines = content.split(/\r?\n/);
+    if (lines.length > 0 && lines[lines.length - 1] === "")
+        lines.pop();
+    return lines;
+}
+function countChangedLines(oldContent, newContent) {
+    const oldLines = oldContent.split(/\r?\n/);
+    const newLines = newContent.split(/\r?\n/);
+    let changed = 0;
+    let i = 0;
+    let j = 0;
+    while (i < oldLines.length && j < newLines.length) {
+        if (oldLines[i] === newLines[j]) {
+            i += 1;
+            j += 1;
+            continue;
+        }
+        changed += 1;
+        i += 1;
+        j += 1;
+    }
+    return changed + Math.abs(oldLines.length - newLines.length);
+}

package/dist/plugins/manager.d.ts

@@ -0,0 +1,23 @@
+export declare function listInstalledPlugins(): {
+    name: any;
+    description: any;
+    path: any;
+    body: string;
+    skills: any[];
+}[];
+export declare function getPlugin(name: any): {
+    name: any;
+    description: any;
+    path: any;
+    body: string;
+    skills: any[];
+};
+export declare function importPlugin(source: any, name: any): {
+    name: any;
+    description: any;
+    path: any;
+    body: string;
+    skills: any[];
+};
+export declare function removePlugin(name: any): boolean;
+export declare function buildPluginsPrompt(enabled: any): string;