@datename/fastcode-termux 0.0.0-stage → 0.1.6

package/dist/ui/Prompt.d.ts

@@ -0,0 +1,10 @@
+export declare const Prompt: ({ theme, value, onChange, onSubmit, disabled, placeholder, stable, mask, }: {
+    theme: any;
+    value: any;
+    onChange: any;
+    onSubmit: any;
+    disabled: any;
+    placeholder: any;
+    stable?: boolean;
+    mask: any;
+}) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;

package/dist/ui/Prompt.js

@@ -0,0 +1,38 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Bottom prompt input, with a left-side caret + slash-command autocomplete.
+ *
+ * We re-use ink-text-input for low-level keyboard handling but wrap it with
+ * a fixed caret indicator + autocomplete preview to mirror the look of
+ * Claude Code's prompt.
+ *
+ * The caret used to blink on a 500 ms setInterval. That timer re-rendered the
+ * whole input line twice a second, which on some terminals rewrote the line
+ * while the text cursor was being re-positioned and made the caret occasionally
+ * jump one column ahead after the first keystroke. A static caret removes the
+ * timer-driven redraw; ink-text-input's own cursor still tracks the real caret.
+ */
+import { Box, Text } from "ink";
+import TextInput from "ink-text-input";
+import { COMMANDS } from "../commands/index.js";
+export const Prompt = ({ theme, value, onChange, onSubmit, disabled, placeholder, stable = false, mask, }) => {
+    const suggestion = autocomplete(value);
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: disabled ? theme.muted : theme.accent, paddingX: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: theme.accent, bold: true, children: "\u276F " }), disabled ? (_jsx(Text, { color: theme.muted, children: placeholder ?? "Working… (Esc to cancel)" })) : (_jsx(TextInput, { value: value, onChange: onChange, onSubmit: onSubmit, placeholder: placeholder ?? "Type a message or /help …", showCursor: !stable, mask: mask }))] }), !disabled && suggestion ? (_jsx(Box, { marginLeft: 2, children: _jsxs(Text, { color: theme.muted, children: ["\u21AA ", suggestion] }) })) : null] }));
+};
+function autocomplete(value) {
+    if (!value.startsWith("/") || value.includes(" "))
+        return undefined;
+    const partial = value.slice(1).toLowerCase();
+    if (!partial) {
+        return COMMANDS.filter((c) => !c.hidden)
+            .map((c) => `/${c.name}`)
+            .slice(0, 6)
+            .join("  ");
+    }
+    const matches = COMMANDS.filter((c) => !c.hidden &&
+        (c.name.startsWith(partial) ||
+            (c.aliases ?? []).some((a) => a.startsWith(partial))));
+    if (matches.length === 0)
+        return undefined;
+    return matches.map((c) => `/${c.name} — ${c.description}`).slice(0, 4).join("\n  ");
+}

package/dist/ui/Spinner.d.ts

@@ -0,0 +1,5 @@
+export declare const Spinner: ({ theme, label, stable }: {
+    theme: any;
+    label: any;
+    stable?: boolean;
+}) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;

package/dist/ui/Spinner.js

@@ -0,0 +1,33 @@
+import { jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Custom thinking spinner.
+ *
+ * We don't use ink-spinner's built-in spinners directly because we want to
+ * (1) cycle through a varied set of action verbs ("Thinking…", "Pondering…")
+ * and (2) keep the dots animation in sync with the verb rotation.
+ */
+import { useEffect, useState } from "react";
+import { Text } from "ink";
+const FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const VERBS = [
+    "Thinking",
+    "Pondering",
+    "Reasoning",
+    "Cooking",
+    "Crafting",
+    "Brewing",
+    "Sketching",
+    "Charging",
+];
+export const Spinner = ({ theme, label, stable = false }) => {
+    const [tick, setTick] = useState(0);
+    useEffect(() => {
+        if (stable)
+            return;
+        const id = setInterval(() => setTick((t) => t + 1), 80);
+        return () => clearInterval(id);
+    }, [stable]);
+    const frame = stable ? "⠋" : FRAMES[tick % FRAMES.length];
+    const verb = label ?? VERBS[Math.floor(tick / 24) % VERBS.length];
+    return (_jsxs(Text, { color: theme.accent, children: [frame, " ", _jsxs(Text, { color: theme.muted, children: [verb, "\u2026"] })] }));
+};

package/dist/ui/StatusBar.d.ts

@@ -0,0 +1,10 @@
+export declare const StatusBar: ({ theme, providerId, model, inputTokens, outputTokens, costUsd, enabledSkillCount, hint, }: {
+    theme: any;
+    providerId: any;
+    model: any;
+    inputTokens: any;
+    outputTokens: any;
+    costUsd: any;
+    enabledSkillCount: any;
+    hint: any;
+}) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;

package/dist/ui/StatusBar.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useStdout } from "ink";
+import { platformLabel } from "../lib/platform.js";
+export const StatusBar = ({ theme, providerId, model, inputTokens, outputTokens, costUsd, enabledSkillCount, hint, }) => {
+    const { stdout } = useStdout();
+    const columns = stdout?.columns ?? process.stdout.columns ?? 80;
+    const compact = columns < 88;
+    const cost = costUsd > 0 ? `$${costUsd.toFixed(4)}` : "$0.0000";
+    const providerModel = `${providerId}/${model}`;
+    const label = compact ? truncate(providerModel, Math.max(18, columns - 28)) : providerModel;
+    return (_jsxs(Box, { flexDirection: compact ? "column" : "row", justifyContent: "space-between", borderStyle: "round", borderColor: theme.border, paddingX: 1, children: [_jsxs(Text, { color: theme.muted, children: [_jsx(Text, { color: theme.accent, children: "\u25CF" }), " ", label, _jsx(Text, { color: theme.muted, children: "  \u00B7  " }), inputTokens, "\u2191 ", outputTokens, "\u2193 ", cost, !compact ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: theme.muted, children: "  \u00B7  " }), "skills: ", enabledSkillCount, _jsx(Text, { color: theme.muted, children: "  \u00B7  " }), platformLabel()] })) : null] }), _jsx(Text, { color: theme.muted, children: compact
+                    ? `${platformLabel()} · skills:${enabledSkillCount} · ${hint ?? "/help · esc · ctrl+c"}`
+                    : hint ?? "/help · esc cancel · ctrl+c quit" })] }));
+};
+function truncate(value, max) {
+    if (value.length <= max)
+        return value;
+    return `${value.slice(0, Math.max(1, max - 1))}…`;
+}

package/dist/ui/TrustGate.d.ts

@@ -0,0 +1,5 @@
+export declare const TrustGate: ({ theme, cwd, onDecision }: {
+    theme: any;
+    cwd: any;
+    onDecision: any;
+}) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;

package/dist/ui/TrustGate.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * First-run confirmation for a folder the agent is not trusted with yet.
+ *
+ * Agent tools can read, write, delete and execute in the workspace, so the user
+ * decides before anything loads.
+ */
+import { Box, Text, useInput } from "ink";
+export const TrustGate = ({ theme, cwd, onDecision }) => {
+    useInput((input) => {
+        const value = String(input ?? "").toLowerCase();
+        if (value === "y")
+            onDecision(true);
+        else if (value === "n" || value === "q")
+            onDecision(false);
+    });
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.accent, paddingX: 1, marginTop: 1, children: [
+            _jsx(Text, { color: theme.accent, bold: true, children: "Trust this folder?" }),
+            _jsx(Text, { color: theme.muted, children: cwd }),
+            _jsx(Text, { children: "" }),
+            _jsx(Text, { children: "FastCode agent tools can read, write and delete files here, and run shell commands." }),
+            _jsx(Text, { children: "Continue only if you trust this project." }),
+            _jsx(Text, { children: "" }),
+            _jsx(Text, { children: "[y] trust and continue    [n] decline (chat only)    [q] quit" }),
+        ] }));
+};

package/package.json

@@ -1,6 +1,98 @@
 {
   "name": "@datename/fastcode-termux",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.6",
+  "description": "FastCode — a blazing-fast TUI coding assistant. Multi-LLM, skills.sh skills, slash commands. Works on Termux, Linux, Windows, and macOS.",
+  "type": "module",
+  "bin": {
+    "fastcode": "bin/fastcode.mjs",
+    "fc": "bin/fastcode.mjs"
+  },
+  "main": "./dist/index.js",
+  "files": [
+    "bin",
+    "dist",
+    "src",
+    "tsconfig.json",
+    "assets",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18.17"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node scripts/build.mjs",
+    "build:bundle": "node scripts/build.mjs",
+    "dev": "tsx src/index.ts",
+    "start": "node bin/fastcode.mjs",
+    "check": "npm test && npm run typecheck && npm run lint && npm run build",
+    "lint": "eslint \"src/**/*.{ts,tsx}\"",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "node ../scripts/smoke-test.mjs",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "tui",
+    "cli",
+    "ai",
+    "coding-agent",
+    "claude",
+    "claude-code",
+    "openclaude",
+    "fastcode",
+    "skills",
+    "termux",
+    "openai",
+    "anthropic",
+    "gemini",
+    "openrouter",
+    "ollama",
+    "deepseek",
+    "groq",
+    "mistral",
+    "agent",
+    "ink",
+    "react"
+  ],
+  "author": "SimpleLittleDev",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dateName/fastcode-termux.git"
+  },
+  "homepage": "https://github.com/dateName/fastcode-termux#readme",
+  "bugs": {
+    "url": "https://github.com/dateName/fastcode-termux/issues"
+  },
+  "dependencies": {
+    "boxen": "^7.1.1",
+    "chalk": "^5.3.0",
+    "cli-highlight": "^2.1.11",
+    "figures": "^6.1.0",
+    "gradient-string": "^2.0.2",
+    "ink": "^5.0.1",
+    "ink-big-text": "^2.0.0",
+    "ink-gradient": "^3.0.0",
+    "ink-link": "^4.1.0",
+    "ink-markdown": "^1.0.1",
+    "ink-select-input": "^6.0.0",
+    "ink-spinner": "^5.0.0",
+    "ink-text-input": "^6.0.0",
+    "marked": "^12.0.2",
+    "marked-terminal": "^7.1.0",
+    "meow": "^13.2.0",
+    "react": "^18.3.1",
+    "tar": "^7.4.3"
+  },
+  "devDependencies": {
+    "@types/marked-terminal": "^6.1.1",
+    "@types/node": "^22.10.0",
+    "@types/react": "^18.3.12",
+    "@typescript-eslint/eslint-plugin": "^8.18.0",
+    "@typescript-eslint/parser": "^8.18.0",
+    "esbuild": "^0.28.2",
+    "eslint": "^9.16.0",
+    "tsx": "^4.19.2",
+    "typescript": "^5.6.3"
+  }
+}

package/src/agent/guards.ts

@@ -0,0 +1,74 @@
+/**
+ * Dangerous-command guard.
+ *
+ * Blocks destructive shell patterns before execution. Word-boundary escapes
+ * are written as character classes so the intent is identical without
+ * boundary syntax.
+ *
+ * Overrides:
+ *   FASTCODE_ALLOW_DANGEROUS=1        bypass the deny list (reported in output)
+ *   FASTCODE_SHELL_ALLOWLIST=a;b      only commands matching these regexes run
+ *   FASTCODE_SHELL_DENY_EXTRA=x;y     extra regexes to deny
+ *   FASTCODE_RESTRICT_TO_WORKSPACE=1  also reject ../ and .. escapes
+ */
+export const DEFAULT_DENY_PATTERNS = [
+    "(^|[^a-z])rm +-[rf]{1,2}([^a-z]|$)",
+    "(^|[^a-z])del +/[fq]([^a-z]|$)",
+    "(^|[^a-z])rmdir +/s([^a-z]|$)",
+    "(^|[^a-z-])(format|mkfs|diskpart)([^a-z]|$)",
+    "(^|[^a-z])dd +if=",
+    "> */dev/sd",
+    "(^|[^a-z])(shutdown|reboot|poweroff)([^a-z]|$)",
+];
+export const FORK_BOMB_MARKERS = [":(){", ":|:&"];
+function enabled(name) {
+    const value = process.env[name];
+    if (value === undefined)
+        return false;
+    return ["1", "true", "yes", "on"].includes(value.trim().toLowerCase());
+}
+function splitList(value) {
+    return (value ?? "").split(/[;,]/).map((entry) => entry.trim()).filter(Boolean);
+}
+function matches(lower, pattern) {
+    try {
+        return new RegExp(pattern).test(lower);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Decide whether a shell command may run.
+ * Returns { allow: true } or { allow: false, output: explanation }.
+ */
+export function evaluateShellCommand(command) {
+    const cmd = String(command ?? "").trim();
+    const lower = cmd.toLowerCase();
+    if (enabled("FASTCODE_ALLOW_DANGEROUS"))
+        return { allow: true, output: undefined, bypassed: true };
+    const deny = DEFAULT_DENY_PATTERNS.concat(splitList(process.env["FASTCODE_SHELL_DENY_EXTRA"]));
+    for (const pattern of deny) {
+        if (matches(lower, pattern)) {
+            return {
+                allow: false,
+                pattern,
+                output: "Error: blocked by the safety guard (dangerous pattern: " + pattern + "). " +
+                    "Set FASTCODE_ALLOW_DANGEROUS=1 to override.",
+            };
+        }
+    }
+    for (const marker of FORK_BOMB_MARKERS) {
+        if (lower.includes(marker))
+            return { allow: false, output: "Error: blocked by the safety guard (fork bomb pattern)." };
+    }
+    const allowlist = splitList(process.env["FASTCODE_SHELL_ALLOWLIST"]);
+    if (allowlist.length > 0 && !allowlist.some((pattern) => matches(lower, pattern)))
+        return { allow: false, output: "Error: blocked by the safety guard (not in FASTCODE_SHELL_ALLOWLIST)." };
+    if (enabled("FASTCODE_RESTRICT_TO_WORKSPACE")) {
+        const backslash = String.fromCharCode(92);
+        if (cmd.includes("../") || cmd.includes(".." + backslash))
+            return { allow: false, output: "Error: blocked by the safety guard (path traversal)." };
+    }
+    return { allow: true, output: undefined };
+}

package/src/agent/limits.ts

@@ -0,0 +1,71 @@
+/**
+ * Single source of truth for how much tool output reaches the model.
+ *
+ * Output is bounded while it is produced, not by slicing a finished string
+ * afterwards, so a runaway command or a huge directory listing cannot grow
+ * without limit. Override the cap with FASTCODE_TOOL_OUTPUT_LIMIT (characters).
+ */
+export const DEFAULT_TOOL_OUTPUT_LIMIT = 30000;
+export function toolOutputLimit() {
+    const raw = Number(process.env["FASTCODE_TOOL_OUTPUT_LIMIT"]);
+    return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : DEFAULT_TOOL_OUTPUT_LIMIT;
+}
+/**
+ * Bounded text accumulator.
+ *
+ * mode "head" keeps the first N characters (listings, search hits);
+ * mode "tail" keeps the last N (command logs, where the error is last).
+ * trimEnd()/toString() mimic a plain string so callers stay simple.
+ */
+export function createOutputBuffer(limit = toolOutputLimit(), mode = "head") {
+    const NL = String.fromCharCode(10);
+    let text = "";
+    let dropped = 0;
+    const buffer = {
+        get full() {
+            return text.length >= limit;
+        },
+        push(chunk) {
+            const value = String(chunk);
+            if (mode === "tail") {
+                text += value;
+                if (text.length > limit) {
+                    const over = text.length - limit;
+                    dropped += over;
+                    text = text.slice(over);
+                }
+                return;
+            }
+            if (text.length >= limit) {
+                dropped += value.length;
+                return;
+            }
+            const room = limit - text.length;
+            if (value.length <= room) {
+                text += value;
+            }
+            else {
+                text += value.slice(0, room);
+                dropped += value.length - room;
+            }
+        },
+        line(value) {
+            if (text.length > 0)
+                buffer.push(NL);
+            buffer.push(value);
+        },
+        value() {
+            if (dropped <= 0)
+                return text;
+            const note = "[" + dropped + " more characters omitted]";
+            return mode === "tail" ? note + NL + text : text + NL + note;
+        },
+        trimEnd() {
+            return buffer.value().trimEnd();
+        },
+        toString() {
+            return buffer.value();
+        },
+    };
+    return buffer;
+}

package/src/agent/protocol.ts

@@ -0,0 +1,126 @@
+const TOOL_RE = /<fastcode_tool>([\s\S]*?)<\/fastcode_tool>/g;
+// Some models (notably DeepSeek) emit their native "DSML" tool-call markup
+// instead of <fastcode_tool>. The markers look like `<｜DSML｜invoke ...>`
+// (U+FF5C fullwidth bar, sometimes doubled or spaced). We canonicalize those
+// markers back to plain angle-bracket tags and then parse the
+// calls -> invoke -> parameter structure as a second dialect.
+const DSML_OPEN_RE = /<\s*(?:[|｜]\s*)+DSML\s*(?:[|｜]\s*)+/gi;
+const DSML_CLOSE_RE = /<\/\s*(?:[|｜]\s*)+DSML\s*(?:[|｜]\s*)+/gi;
+const DSML_BLOCK_RE = /<([a-z_]*calls?)>([\s\S]*?)<\/\1>/gi;
+const DSML_INVOKE_RE = /<invoke\s+name="([^"]+)"\s*>([\s\S]*?)<\/invoke>/gi;
+const DSML_PARAM_RE = /<parameter\s+name="([^"]+)"([^>]*)>([\s\S]*?)<\/parameter>/gi;
+/** Turn the DSML glyph markers into ordinary `<tag>` / `</tag>` tags. */
+function canonicalizeDsml(text) {
+    return text.replace(DSML_CLOSE_RE, "</").replace(DSML_OPEN_RE, "<");
+}
+function coerceDsmlValue(attrs, raw) {
+    const value = raw.replace(/^\n/, "").replace(/\n$/, "");
+    if (/\bstring\s*=\s*"true"/i.test(attrs))
+        return value;
+    const trimmed = value.trim();
+    if (trimmed === "")
+        return "";
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        if (trimmed === "true")
+            return true;
+        if (trimmed === "false")
+            return false;
+        const n = Number(trimmed);
+        return Number.isNaN(n) ? value : n;
+    }
+}
+function parseDsmlCalls(text) {
+    const canonical = canonicalizeDsml(text);
+    const bodies = [];
+    for (const block of canonical.matchAll(DSML_BLOCK_RE))
+        bodies.push(block[2] ?? "");
+    if (bodies.length === 0)
+        bodies.push(canonical);
+    const calls = [];
+    for (const body of bodies) {
+        for (const invoke of body.matchAll(DSML_INVOKE_RE)) {
+            const call = { tool: invoke[1] };
+            for (const param of (invoke[2] ?? "").matchAll(DSML_PARAM_RE))
+                call[param[1]] = coerceDsmlValue(param[2] ?? "", param[3] ?? "");
+            calls.push(call);
+        }
+    }
+    return calls;
+}
+export function parseToolCalls(text) {
+    const calls = [];
+    for (const match of text.matchAll(TOOL_RE)) {
+        const raw = match[1]?.trim();
+        if (!raw)
+            continue;
+        try {
+            const parsed = JSON.parse(raw);
+            if (typeof parsed.tool === "string")
+                calls.push(parsed);
+        }
+        catch {
+            // Ignore malformed tool blocks; the model can correct itself next turn.
+        }
+    }
+    calls.push(...parseDsmlCalls(text));
+    return calls;
+}
+export function stripToolCalls(text) {
+    return canonicalizeDsml(text).replace(TOOL_RE, "").replace(DSML_BLOCK_RE, "").trim();
+}
+export function formatToolResults(results) {
+    const blocks = results.map((r, index) => {
+        const status = r.ok ? "ok" : "error";
+        return [
+            `Tool result ${index + 1} (${status})`,
+            `call: ${JSON.stringify(r.call)}`,
+            "output:",
+            fence(r.output),
+        ].join("\n");
+    });
+    return [
+        "FastCode executed the requested local tools. Use these results to continue.",
+        ...blocks,
+    ].join("\n\n");
+}
+export const AGENT_SYSTEM_PROMPT = `
+You are FastCode Agent, a local coding agent running inside the user's terminal.
+Tools run inside a filesystem sandbox rooted at the current working directory.
+File tools cannot access paths outside that root. Shell commands run with FASTCODE_SANDBOX=1 and FASTCODE_SANDBOX_ROOT set.
+
+You can inspect and change the user's machine by emitting exactly one or more tool calls in this format:
+<fastcode_tool>{"tool":"shell","command":"npm test"}</fastcode_tool>
+
+Available tools:
+- shell: {"tool":"shell","command":"command to run"}
+- shell with timeout: {"tool":"shell","command":"npm test","timeoutMs":120000}
+- pwd: {"tool":"pwd"}
+- read_file: {"tool":"read_file","path":"path/to/file"}
+- read_many: {"tool":"read_many","paths":["file1","file2"]}
+- write_file: {"tool":"write_file","path":"path/to/file","content":"full file contents"}
+- append_file: {"tool":"append_file","path":"path/to/file","content":"text to append"}
+- apply_patch: {"tool":"apply_patch","patch":"*** Begin Patch\\n*** Update File: path\\n@@\\n-old\\n+new\\n*** End Patch\\n"}
+- list_files: {"tool":"list_files","path":"optional/path","maxDepth":2}
+- grep: {"tool":"grep","pattern":"text or regex","path":"optional/path"}
+- replace_in_file: {"tool":"replace_in_file","path":"path/to/file","find":"exact text","replace":"replacement"}
+- stat_path: {"tool":"stat_path","path":"path/to/file"}
+- make_dir: {"tool":"make_dir","path":"path/to/dir"}
+- copy_file: {"tool":"copy_file","from":"src","to":"dest"}
+- move_path: {"tool":"move_path","from":"src","to":"dest"}
+- delete_file: {"tool":"delete_file","path":"path/to/file"}
+
+Rules:
+- Prefer inspecting files before editing.
+- Use shell for tests, builds, package scripts, git inspection, and OS commands.
+- Use apply_patch or replace_in_file for focused edits.
+- Use write_file only when replacing the whole file is appropriate.
+- Run verification commands after code changes.
+- After tool results come back, continue working until the user's request is done.
+- When done, answer normally without tool calls.
+`.trim();
+function fence(text) {
+    return `\`\`\`\n${text}\n\`\`\``;
+}