@matterailab/orbcode 0.1.3

package/dist/utils/diff.js

@@ -0,0 +1,144 @@
+// Minimal unified-diff generator for showing file edits in the TUI.
+/** LCS-based line diff. Falls back to whole-block replace on very large inputs. */
+function diffLines(oldLines, newLines) {
+    // Trim common prefix/suffix so the DP table only covers the changed middle.
+    let start = 0;
+    while (start < oldLines.length && start < newLines.length && oldLines[start] === newLines[start]) {
+        start++;
+    }
+    let oldEnd = oldLines.length;
+    let newEnd = newLines.length;
+    while (oldEnd > start && newEnd > start && oldLines[oldEnd - 1] === newLines[newEnd - 1]) {
+        oldEnd--;
+        newEnd--;
+    }
+    const a = oldLines.slice(start, oldEnd);
+    const b = newLines.slice(start, newEnd);
+    let middle;
+    if (a.length * b.length > 1_000_000) {
+        // Too large for DP; show as a block replace.
+        middle = [
+            ...a.map((text) => ({ type: "-", text })),
+            ...b.map((text) => ({ type: "+", text })),
+        ];
+    }
+    else {
+        // Standard LCS dynamic program.
+        const rows = a.length + 1;
+        const cols = b.length + 1;
+        const table = new Uint32Array(rows * cols);
+        for (let i = a.length - 1; i >= 0; i--) {
+            for (let j = b.length - 1; j >= 0; j--) {
+                table[i * cols + j] =
+                    a[i] === b[j]
+                        ? table[(i + 1) * cols + j + 1] + 1
+                        : Math.max(table[(i + 1) * cols + j], table[i * cols + j + 1]);
+            }
+        }
+        middle = [];
+        let i = 0;
+        let j = 0;
+        while (i < a.length && j < b.length) {
+            if (a[i] === b[j]) {
+                middle.push({ type: " ", text: a[i] });
+                i++;
+                j++;
+            }
+            else if (table[(i + 1) * cols + j] >= table[i * cols + j + 1]) {
+                middle.push({ type: "-", text: a[i] });
+                i++;
+            }
+            else {
+                middle.push({ type: "+", text: b[j] });
+                j++;
+            }
+        }
+        while (i < a.length)
+            middle.push({ type: "-", text: a[i++] });
+        while (j < b.length)
+            middle.push({ type: "+", text: b[j++] });
+    }
+    return [
+        ...oldLines.slice(0, start).map((text) => ({ type: " ", text })),
+        ...middle,
+        ...oldLines.slice(oldEnd).map((text) => ({ type: " ", text })),
+    ];
+}
+/**
+ * Produce unified-diff hunks (without file headers) for two file contents.
+ * Returns "" when the contents are identical.
+ */
+export function unifiedDiff(oldText, newText, contextLines = 3) {
+    if (oldText === newText)
+        return "";
+    // An empty file is zero lines, not one empty line.
+    const ops = diffLines(oldText === "" ? [] : oldText.split("\n"), newText === "" ? [] : newText.split("\n"));
+    const out = [];
+    let oldLine = 1;
+    let newLine = 1;
+    let hunk = [];
+    let hunkOldStart = 1;
+    let hunkNewStart = 1;
+    let hunkOldCount = 0;
+    let hunkNewCount = 0;
+    let trailingContext = 0;
+    const flush = () => {
+        if (hunk.length === 0)
+            return;
+        // Drop context beyond the hunk's trailing window.
+        const extra = Math.max(0, trailingContext - contextLines);
+        if (extra > 0) {
+            hunk = hunk.slice(0, hunk.length - extra);
+            hunkOldCount -= extra;
+            hunkNewCount -= extra;
+        }
+        out.push(`@@ -${hunkOldStart},${hunkOldCount} +${hunkNewStart},${hunkNewCount} @@`);
+        out.push(...hunk);
+        hunk = [];
+        hunkOldCount = 0;
+        hunkNewCount = 0;
+        trailingContext = 0;
+    };
+    let pendingContext = [];
+    for (const op of ops) {
+        if (op.type === " ") {
+            if (hunk.length > 0) {
+                hunk.push(` ${op.text}`);
+                hunkOldCount++;
+                hunkNewCount++;
+                trailingContext++;
+                if (trailingContext > contextLines * 2)
+                    flush();
+            }
+            else {
+                pendingContext.push(op.text);
+                if (pendingContext.length > contextLines)
+                    pendingContext.shift();
+            }
+            oldLine++;
+            newLine++;
+        }
+        else {
+            if (hunk.length === 0) {
+                hunkOldStart = oldLine - pendingContext.length;
+                hunkNewStart = newLine - pendingContext.length;
+                hunk = pendingContext.map((text) => ` ${text}`);
+                hunkOldCount = pendingContext.length;
+                hunkNewCount = pendingContext.length;
+                pendingContext = [];
+            }
+            trailingContext = 0;
+            hunk.push(`${op.type}${op.text}`);
+            if (op.type === "-") {
+                hunkOldCount++;
+                oldLine++;
+            }
+            else {
+                hunkNewCount++;
+                newLine++;
+            }
+        }
+    }
+    flush();
+    return out.join("\n");
+}

package/dist/utils/shell.js

@@ -0,0 +1,19 @@
+/**
+ * Cross-platform shell selection. On Windows, $SHELL is normally unset and
+ * unix paths like /bin/sh do not exist, so we use ComSpec (cmd.exe); on
+ * POSIX systems we honor the user's shell with a /bin/sh fallback.
+ */
+export function getShell() {
+    if (process.platform === "win32") {
+        return process.env.ComSpec || "cmd.exe";
+    }
+    return process.env.SHELL || "/bin/sh";
+}
+/** Arguments that make the shell run a single command string. */
+export function getShellRunArgs(command) {
+    if (process.platform === "win32") {
+        // /d skips AutoRun, /s preserves quotes in the command string.
+        return ["/d", "/s", "/c", command];
+    }
+    return ["-c", command];
+}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@matterailab/orbcode",
+  "version": "0.1.3",
+  "description": "OrbCode CLI — agentic coding in your terminal, powered by Axon models by MatterAI",
+  "type": "module",
+  "bin": {
+    "orbcode": "./bin/orbcode.js"
+  },
+  "main": "./dist/index.js",
+  "files": [
+    "bin",
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MatterAIOrg/OrbCode.git"
+  },
+  "homepage": "https://github.com/MatterAIOrg/OrbCode#readme",
+  "bugs": {
+    "url": "https://github.com/MatterAIOrg/OrbCode/issues"
+  },
+  "author": "MatterAI",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "dev": "tsx src/index.tsx",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run typecheck && npm run build"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "ink": "^5.2.1",
+    "open": "^10.1.0",
+    "openai": "^4.78.0",
+    "picomatch": "^4.0.2",
+    "react": "^18.3.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.17.0",
+    "@types/picomatch": "^3.0.1",
+    "@types/react": "^18.3.12",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2"
+  },
+  "keywords": [
+    "orbcode",
+    "matterai",
+    "axon",
+    "cli",
+    "ai",
+    "coding-agent"
+  ],
+  "license": "MIT"
+}