@alisio/alisio-code 0.1.0-alpha.9 → 0.1.0

package/dist/tui/theme.js

@@ -17,8 +17,521 @@ export const style = {
     userBg: sgr("48;5;236", 49),
 };
 export const levelColor = (level) => level === "ok" ? style.green : level === "warn" ? style.yellow : style.red;
+const TS_KEYWORDS = new Set([
+    "abstract",
+    "as",
+    "async",
+    "await",
+    "break",
+    "case",
+    "catch",
+    "class",
+    "const",
+    "constructor",
+    "continue",
+    "debugger",
+    "declare",
+    "default",
+    "delete",
+    "do",
+    "else",
+    "enum",
+    "export",
+    "extends",
+    "false",
+    "finally",
+    "for",
+    "from",
+    "function",
+    "get",
+    "if",
+    "implements",
+    "import",
+    "in",
+    "instanceof",
+    "interface",
+    "is",
+    "keyof",
+    "let",
+    "namespace",
+    "new",
+    "never",
+    "null",
+    "of",
+    "override",
+    "private",
+    "protected",
+    "public",
+    "readonly",
+    "return",
+    "satisfies",
+    "set",
+    "static",
+    "super",
+    "switch",
+    "this",
+    "throw",
+    "true",
+    "try",
+    "type",
+    "typeof",
+    "unknown",
+    "using",
+    "var",
+    "void",
+    "while",
+    "with",
+    "yield",
+]);
+const PYTHON_KEYWORDS = new Set([
+    "and",
+    "as",
+    "assert",
+    "async",
+    "await",
+    "break",
+    "case",
+    "class",
+    "continue",
+    "def",
+    "del",
+    "elif",
+    "else",
+    "except",
+    "False",
+    "finally",
+    "for",
+    "from",
+    "global",
+    "if",
+    "import",
+    "in",
+    "is",
+    "lambda",
+    "match",
+    "None",
+    "nonlocal",
+    "not",
+    "or",
+    "pass",
+    "raise",
+    "return",
+    "True",
+    "try",
+    "while",
+    "with",
+    "yield",
+]);
+const SHELL_KEYWORDS = new Set([
+    "alias",
+    "break",
+    "case",
+    "continue",
+    "do",
+    "done",
+    "elif",
+    "else",
+    "esac",
+    "exit",
+    "export",
+    "fi",
+    "for",
+    "function",
+    "if",
+    "in",
+    "local",
+    "readonly",
+    "return",
+    "select",
+    "set",
+    "shift",
+    "source",
+    "then",
+    "time",
+    "true",
+    "false",
+    "until",
+    "while",
+]);
+const CSS_KEYWORDS = new Set([
+    "@charset",
+    "@font-face",
+    "@import",
+    "@keyframes",
+    "@layer",
+    "@media",
+    "@namespace",
+    "@page",
+    "@supports",
+    "important",
+]);
+/** Standalone words highlighted in HTML (tags themselves are matched structurally). */
+const HTML_WORDS = new Set([]);
+/** Rules used for TS/JS and as the fallback for unknown language tags. */
+const TS_RULES = {
+    keywords: TS_KEYWORDS,
+    lineComment: "//",
+    blockComment: ["/*", "*/"],
+    strings: ['"', "'", "`"],
+};
+const LANG_RULES = {
+    ts: TS_RULES,
+    js: TS_RULES,
+    json: {
+        keywords: new Set(["true", "false", "null"]),
+        lineComment: "//",
+        blockComment: ["/*", "*/"],
+        strings: ['"', "'"],
+        keyString: true,
+    },
+    python: {
+        keywords: PYTHON_KEYWORDS,
+        lineComment: "#",
+        strings: ['"', "'"],
+        triple: ['"""', "'''"],
+        defNames: true,
+        decorators: true,
+        prefixedStrings: true,
+    },
+    bash: {
+        keywords: SHELL_KEYWORDS,
+        lineComment: "#",
+        strings: ['"', "'"],
+        dollarVars: true,
+        eqKey: true,
+    },
+    sh: {
+        keywords: SHELL_KEYWORDS,
+        lineComment: "#",
+        strings: ['"', "'"],
+        dollarVars: true,
+        eqKey: true,
+    },
+    yaml: {
+        keywords: new Set(["true", "false", "yes", "no", "on", "off", "null"]),
+        lineComment: "#",
+        strings: ['"', "'"],
+        colonKey: true,
+    },
+    css: {
+        keywords: CSS_KEYWORDS,
+        blockComment: ["/*", "*/"],
+        strings: ['"', "'"],
+        colonKey: true,
+        hexColors: true,
+        atWord: true,
+    },
+    html: {
+        keywords: HTML_WORDS,
+        blockComment: ["<!--", "-->"],
+        strings: ['"', "'"],
+        html: true,
+        eqKey: true,
+        hexColors: true,
+    },
+    md: { keywords: new Set(), strings: ["`"], headings: true },
+};
+const LANG_ALIASES = {
+    typescript: "ts",
+    tsx: "ts",
+    javascript: "js",
+    jsx: "js",
+    node: "js",
+    jsonc: "json",
+    json5: "json",
+    shell: "bash",
+    zsh: "bash",
+    python3: "python",
+    py: "python",
+    yml: "yaml",
+    markdown: "md",
+};
+/** Unknown or missing language tags fall back to TypeScript rules (closest to plain code). */
+const rulesFor = (lang) => {
+    const base = (lang ?? "")
+        .trim()
+        .toLowerCase()
+        .split(/[\s.]+/)[0] ?? "";
+    return LANG_RULES[LANG_ALIASES[base] ?? base] ?? TS_RULES;
+};
+/** Strips ANSI escapes, OSC sequences and control characters; normalizes tabs. */
+export function sanitizeCode(code) {
+    return code
+        .replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, "")
+        .replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, "")
+        .replace(/\x1b[()][0-9A-Za-z]/g, "")
+        .replace(/\x1b/g, "")
+        .replace(/[\u0000-\u0008\u000B\u000C\u000D\u000E-\u001F\u007F]/g, "")
+        .replace(/\t/g, "  ");
+}
+function scanLine(line, rules, state) {
+    const out = [];
+    const len = line.length;
+    const push = (text, style) => {
+        if (text)
+            out.push({ text, style });
+    };
+    /** Finds the unescaped closing delimiter of a string starting at `from`. */
+    const scanString = (from, delimiter) => {
+        let j = from;
+        while (j < len) {
+            if (line[j] === "\\") {
+                j += 2;
+                continue;
+            }
+            if (line.startsWith(delimiter, j))
+                return { end: j + delimiter.length, closed: true };
+            j++;
+        }
+        return { end: len, closed: false };
+    };
+    let i = 0;
+    // Continue a multi-line string opened on a previous line.
+    if (state.inString) {
+        const end = line.indexOf(state.inString);
+        if (end < 0) {
+            push(line, "string");
+            return out;
+        }
+        push(line.slice(0, end + state.inString.length), "string");
+        i = end + state.inString.length;
+        state.inString = undefined;
+    }
+    // Continue a block comment opened on a previous line.
+    if (state.inComment) {
+        const end = line.indexOf(state.inComment);
+        if (end < 0) {
+            push(line, "comment");
+            return out;
+        }
+        push(line.slice(0, end + state.inComment.length), "comment");
+        i = end + state.inComment.length;
+        state.inComment = undefined;
+    }
+    while (i < len) {
+        const rem = line.slice(i);
+        // Markdown headings: color the `#` marker run (approximate; only at the start of a line).
+        if (rules.headings && /^#{1,6}[ \t]/.test(rem)) {
+            const m = /^#{1,6}/.exec(rem);
+            push(m?.[0] ?? "", "keyword");
+            push(rem.slice(m?.[0].length ?? 0), "plain");
+            break;
+        }
+        const ws = /^ +/.exec(rem);
+        if (ws) {
+            push(ws[0], "plain");
+            i += ws[0].length;
+            continue;
+        }
+        if (rules.triple) {
+            const delim = rules.triple.find((d) => rem.startsWith(d));
+            if (delim) {
+                const end = line.indexOf(delim, i + delim.length);
+                if (end >= 0) {
+                    push(line.slice(i, end + delim.length), "string");
+                    i = end + delim.length;
+                }
+                else {
+                    push(line.slice(i), "string");
+                    state.inString = delim;
+                    i = len;
+                }
+                continue;
+            }
+        }
+        // Escape-aware quoted strings, with optional Python-style prefixes (`f"..."`, `r"..."`).
+        const anyQuote = () => {
+            for (const d of rules.strings) {
+                if (rem.startsWith(d)) {
+                    const scan = scanString(i + d.length, d);
+                    return { quote: d, from: i, closed: scan.closed, end: scan.end };
+                }
+            }
+            if (rules.prefixedStrings) {
+                const pm = /^(?:[fF][rR]?|[rR][fF]?|[bB]|[uU])(["'])/.exec(rem);
+                if (pm?.[1] && rules.strings.includes(pm[1])) {
+                    const scan = scanString(i + pm[0].length, pm[1]);
+                    return { quote: pm[1], from: i, closed: scan.closed, end: scan.end };
+                }
+            }
+            return undefined;
+        };
+        const str = anyQuote();
+        if (str) {
+            const key = rules.keyString && /^\s*:/.test(line.slice(str.end));
+            push(line.slice(str.from, str.end), key ? "property" : "string");
+            i = str.end;
+            if (!str.closed && str.quote === "`")
+                state.inString = str.quote;
+            continue;
+        }
+        if (rules.lineComment && rem.startsWith(rules.lineComment)) {
+            push(rem, "comment");
+            break;
+        }
+        if (rules.blockComment && rem.startsWith(rules.blockComment[0])) {
+            const end = line.indexOf(rules.blockComment[1], i + rules.blockComment[0].length);
+            if (end >= 0) {
+                push(line.slice(i, end + rules.blockComment[1].length), "comment");
+                i = end + rules.blockComment[1].length;
+            }
+            else {
+                push(line.slice(i), "comment");
+                state.inComment = rules.blockComment[1];
+                i = len;
+            }
+            continue;
+        }
+        if (rules.dollarVars && rem.startsWith("$")) {
+            const m = /^\$(?:\{[^}]*\}|\d+|[A-Za-z_][\w]*)/.exec(rem);
+            if (m) {
+                push(m[0], "number");
+                i += m[0].length;
+                continue;
+            }
+        }
+        if (rules.decorators && rem.startsWith("@")) {
+            const m = /^@[A-Za-z_][\w]*/.exec(rem);
+            if (m) {
+                push("@", "plain");
+                push(m[0].slice(1), "function");
+                i += m[0].length;
+                continue;
+            }
+        }
+        if (rules.atWord && rem.startsWith("@")) {
+            const m = /^@[A-Za-z-][\w-]*/.exec(rem);
+            if (m) {
+                push(m[0], "keyword");
+                i += m[0].length;
+                continue;
+            }
+        }
+        if (rules.html) {
+            const tag = /^<\/?[A-Za-z][\w-]*/.exec(rem);
+            if (tag && tag[0].length > 1) {
+                push(tag[0], "keyword");
+                i += tag[0].length;
+                continue;
+            }
+        }
+        if (rules.hexColors && rem.startsWith("#")) {
+            const m = /^#[0-9a-fA-F]{3,8}\b/.exec(rem);
+            if (m) {
+                push(m[0], "number");
+                i += m[0].length;
+                continue;
+            }
+        }
+        const num = /^(?:0[xX][0-9a-fA-F]+|0[bB][01]+|\d[\d_]*(?:\.\d+)?(?:[eE][+-]?\d+)?)/.exec(rem);
+        if (num) {
+            push(num[0], "number");
+            i += num[0].length;
+            continue;
+        }
+        const word = /^[A-Za-z_$][\w$]*/.exec(rem);
+        if (word) {
+            const w = word[0];
+            const rest = line.slice(i + w.length);
+            const prevWord = out.at(-1)?.text;
+            if (rules.keywords.has(w))
+                push(w, "keyword");
+            else if (rules.defNames && (prevWord === "def" || prevWord === "class"))
+                push(w, "function");
+            else if (/^\(/.test(rest))
+                push(w, "function");
+            else if (rules.eqKey && /^=/.test(rest))
+                push(w, "property");
+            else if (rules.colonKey && /^:/.test(rest))
+                push(w, "property");
+            else
+                push(w, "plain");
+            i += w.length;
+            continue;
+        }
+        push(line[i] ?? "", "plain");
+        i++;
+    }
+    return out;
+}
+/** Tokenizes code into styled segments, maintaining multi-line string/comment state. */
+export function tokenizeCode(code, lang) {
+    const rules = rulesFor(lang);
+    const state = {};
+    return sanitizeCode(code)
+        .split("\n")
+        .map((line) => scanLine(line, rules, state));
+}
+const TOKEN_PAINT = {
+    keyword: (t) => style.bold(style.magenta(t)),
+    string: (t) => style.green(t),
+    comment: (t) => style.gray(style.italic(t)),
+    number: (t) => style.yellow(t),
+    function: (t) => style.cyan(t),
+    property: (t) => style.brightCyan(t),
+    plain: (t) => t,
+};
+/**
+ * Per-line highlighting for markdown code blocks (pi-tui `MarkdownTheme.highlightCode`).
+ * Returns one styled (or plain, under NO_COLOR) line per source line; never emits ANSI for
+ * bytes that came from the input.
+ */
+export function highlightCode(code, lang) {
+    const lines = tokenizeCode(code, lang);
+    if (process.env.NO_COLOR !== undefined)
+        return lines.map((tokens) => tokens.map((t) => t.text).join(""));
+    return lines.map((tokens) => tokens.map((t) => (t.style === "plain" ? t.text : TOKEN_PAINT[t.style](t.text))).join(""));
+}
+/**
+ * Normalizes table separator rows so models' sloppy ASCII art still renders as aligned tables:
+ * em/en/box dashes become plain `-` runs (marked's table tokenizer only accepts `-`), while
+ * alignment colons are preserved. Anything that is not an obvious separator row, including
+ * fenced or indented code, is left untouched. A bare `---` (horizontal rule / setext) has no
+ * `|` and is never touched.
+ */
+export function normalizeTableSeparators(markdown) {
+    const out = [];
+    let fence;
+    for (const line of markdown.split("\n")) {
+        const fenceMatch = /^ {0,3}(`{3,}|~{3,})/.exec(line);
+        if (fenceMatch) {
+            const marker = fenceMatch[1]?.[0] ?? "";
+            if (!fence)
+                fence = marker;
+            else if (fenceMatch[1]?.startsWith(fence))
+                fence = undefined;
+            out.push(line);
+            continue;
+        }
+        if (!fence && isTableSeparator(line)) {
+            out.push(line.replace(/(:)?[-—–─]+(:)?/g, (_m, left, right) => `${left ?? ""}---${right ?? ""}`));
+            continue;
+        }
+        out.push(line);
+    }
+    return out.join("\n");
+}
+function isTableSeparator(line) {
+    if (!line.includes("|") || /^ {4}/.test(line))
+        return false;
+    const cells = line.split("|");
+    let dashes = 0;
+    for (const cell of cells) {
+        const c = cell.trim();
+        if (c === "")
+            continue;
+        if (!/^:?[-—–─]+:?$/.test(c))
+            return false;
+        dashes++;
+    }
+    return dashes > 0;
+}
+/** Pre-parse hook for the Markdown component: normalizes table separators before marked parses. */
+export const markdownTransform = (markdown, _availableWidth) => normalizeTableSeparators(markdown);
+/** Subtle base tone for response body text; inline styles override it. */
+export const markdownDefaultTextStyle = { color: (t) => style.gray(t) };
 export const markdownTheme = {
-    heading: (t) => style.bold(style.cyan(t)),
+    heading: (t) => style.bold(style.brightCyan(t)),
     link: (t) => style.underline(style.blue(t)),
     linkUrl: (t) => style.dim(t),
     code: (t) => style.yellow(t),
@@ -32,6 +545,8 @@ export const markdownTheme = {
     italic: (t) => style.italic(t),
     strikethrough: (t) => style.strike(t),
     underline: (t) => style.underline(t),
+    highlightCode,
+    codeBlockIndent: "  ",
 };
 export const selectListTheme = {
     selectedPrefix: (t) => style.cyan(t),

package/dist/tui/viewer-state.d.ts

@@ -0,0 +1,7 @@
+export interface ViewerState {
+    lastSeenVersion?: string;
+}
+export declare const viewerStateFile: (stateDir: string) => string;
+export declare function readViewerState(stateDir: string): Promise<ViewerState>;
+/** Merges `patch` into the stored state with an atomic replace; returns whether it was saved. */
+export declare function writeViewerState(stateDir: string, patch: Partial<ViewerState>): Promise<boolean>;

package/dist/tui/viewer-state.js

@@ -0,0 +1,36 @@
+/**
+ * Per-viewer state of the terminal UI that is not configuration: the last version whose changelog
+ * the user has been told about (`lastSeenVersion`). Stored next to the session database as
+ * `tui-state.json`; every failure (read-only disk, corrupt file) is swallowed, because a missing
+ * notice must never break the terminal.
+ */
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+export const viewerStateFile = (stateDir) => join(stateDir, "tui-state.json");
+export async function readViewerState(stateDir) {
+    try {
+        const parsed = JSON.parse(await readFile(viewerStateFile(stateDir), "utf8"));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return {};
+        const version = parsed.lastSeenVersion;
+        return typeof version === "string" && version.length <= 100 ? { lastSeenVersion: version } : {};
+    }
+    catch {
+        return {};
+    }
+}
+/** Merges `patch` into the stored state with an atomic replace; returns whether it was saved. */
+export async function writeViewerState(stateDir, patch) {
+    try {
+        const file = viewerStateFile(stateDir);
+        const next = { ...(await readViewerState(stateDir)), ...patch };
+        await mkdir(dirname(file), { recursive: true });
+        const temporary = `${file}.${process.pid}.tmp`;
+        await writeFile(temporary, `${JSON.stringify(next)}\n`, { mode: 0o600 });
+        await rename(temporary, file);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/version.d.ts

@@ -1,8 +1,10 @@
 /**
- * Reads the package version at runtime so --version, doctor, plugin metadata and MCP client
- * metadata stay in sync with the published package without a build-time constant to update.
- * The manifest is resolved relative to the module (`src/version.ts` → `../package.json` in the
- * source tree; `dist/version.js` → `../package.json` of the installed package). Standalone
- * binaries inject the version at build time via ALISIO_PACKAGE_VERSION (scripts/binary-build.ts).
+ * Reads the package version at runtime so --version, the TUI header, doctor, plugin metadata and
+ * MCP client metadata stay in sync with the published package without a build-time constant to
+ * update. The manifest is resolved by walking UP from the module directory until a package.json
+ * with a string `version` is found (bounded, any depth: module, then up to 8 parents), so deeply
+ * nested call sites like `src/tui/app.ts` and compiled `dist/*` resolve the same manifest as
+ * `src/main.ts`. Standalone binaries inject the version at build time via
+ * ALISIO_PACKAGE_VERSION (scripts/binary-build.ts).
  */
 export declare function loadVersion(fromHere: string): string;

package/dist/version.js

@@ -8,19 +8,55 @@ import { fileURLToPath } from "node:url";
  */
 const FALLBACK = "dev";
 /**
- * Reads the package version at runtime so --version, doctor, plugin metadata and MCP client
- * metadata stay in sync with the published package without a build-time constant to update.
- * The manifest is resolved relative to the module (`src/version.ts` → `../package.json` in the
- * source tree; `dist/version.js` → `../package.json` of the installed package). Standalone
- * binaries inject the version at build time via ALISIO_PACKAGE_VERSION (scripts/binary-build.ts).
+ * How many parent directories the loader walks up before giving up. Bounded so a missing
+ * manifest can never make the lookup climb an unbounded path.
+ */
+const MAX_PARENT_HOPS = 8;
+/** Manifests whose `name` identifies the CLI package; preferred when several are hit. */
+const CLI_MANIFEST_NAMES = new Set(["@alisio/alisio-code", "alisio"]);
+/**
+ * Walks up from `dir` looking for a package manifest. Returns the version of the nearest
+ * manifest that declares a string `version`, preferring a manifest whose `name` identifies the
+ * CLI package (`@alisio/alisio-code`/`alisio`) when several are hit — e.g. running from source
+ * inside the monorepo, where the repo-root manifest is also a candidate. `undefined` when no
+ * manifest with a version is reached within the bound.
+ */
+function findManifestVersion(dir) {
+    let nearest;
+    let current = dir;
+    for (let hop = 0; hop <= MAX_PARENT_HOPS; hop++) {
+        try {
+            const parsed = JSON.parse(readFileSync(join(current, "package.json"), "utf8"));
+            if (typeof parsed.version === "string" && parsed.version) {
+                if (typeof parsed.name === "string" && CLI_MANIFEST_NAMES.has(parsed.name))
+                    return parsed.version;
+                nearest ??= parsed.version;
+            }
+        }
+        catch {
+            // No manifest here; keep walking up.
+        }
+        const parent = dirname(current);
+        if (parent === current)
+            break; // Filesystem root.
+        current = parent;
+    }
+    return nearest;
+}
+/**
+ * Reads the package version at runtime so --version, the TUI header, doctor, plugin metadata and
+ * MCP client metadata stay in sync with the published package without a build-time constant to
+ * update. The manifest is resolved by walking UP from the module directory until a package.json
+ * with a string `version` is found (bounded, any depth: module, then up to 8 parents), so deeply
+ * nested call sites like `src/tui/app.ts` and compiled `dist/*` resolve the same manifest as
+ * `src/main.ts`. Standalone binaries inject the version at build time via
+ * ALISIO_PACKAGE_VERSION (scripts/binary-build.ts).
  */
 export function loadVersion(fromHere) {
     if (process.env.ALISIO_PACKAGE_VERSION)
         return process.env.ALISIO_PACKAGE_VERSION;
     try {
-        const manifest = join(dirname(fileURLToPath(fromHere)), "..", "package.json");
-        const parsed = JSON.parse(readFileSync(manifest, "utf8"));
-        return typeof parsed.version === "string" && parsed.version ? parsed.version : FALLBACK;
+        return findManifestVersion(dirname(fileURLToPath(fromHere))) ?? FALLBACK;
     }
     catch {
         return FALLBACK;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alisio/alisio-code",
-  "version": "0.1.0-alpha.9",
+  "version": "0.1.0",
   "description": "Alisio: an extensible, provider-agnostic coding-agent harness for your terminal. TUI, OpenAI-compatible providers, permissioned local tools, context compaction, persistent memory and a typed plugin SDK.",
   "author": "Gustavo Gutiérrez",
   "license": "MIT",
@@ -45,14 +45,12 @@
     "alisio": "./dist/main.js"
   },
   "dependencies": {
-    "@alisio/core": "0.1.0-alpha.7",
-    "@alisio/plugin-deepseek": "0.1.0-alpha.7",
-    "@alisio/plugin-memory": "0.1.0-alpha.6",
-    "@alisio/plugin-openai-compatible": "0.1.0-alpha.7",
-    "@alisio/plugin-opencode": "0.1.0-alpha.6",
-    "@alisio/plugin-opencode-go": "0.1.0-alpha.6",
-    "@alisio/plugin-subagents": "0.1.0-alpha.6",
-    "@alisio/sdk": "0.1.0-alpha.5",
+    "@alisio/core": "0.1.0",
+    "@alisio/plugin-memory": "0.1.0",
+    "@alisio/plugin-openai-compatible": "0.1.0",
+    "@alisio/plugin-subagents": "0.1.0",
+    "@alisio/sdk": "0.1.0",
+    "@alisio/server": "0.1.0",
     "@earendil-works/pi-tui": "0.87.1",
     "commander": "15.0.0"
   },