@lumpcode/cli 0.0.0

package/dist/presets/commands/copilot.js

@@ -0,0 +1,25 @@
+export const command = (({ prompt, stepVariables }) => {
+    const { model = 'auto' } = stepVariables || {};
+
+    if (!prompt) return null;
+
+    return {
+        executable: 'copilot',
+        args: [
+            '-p',
+            prompt,
+            '--allow-all-tools',
+            '--silent',
+            '--model',
+            model,
+        ],
+    };
+});
+
+export const setup = (async ({}) => {
+    return {};
+});
+
+export const teardown = (() => {
+    return;
+});

package/dist/presets/commands/cursor.js

@@ -0,0 +1,70 @@
+import { execAsync } from '@lumpcode/core';
+import { defineCommand, defineCommandSetup, defineCommandTeardown } from "@lumpcode/cli-types";
+
+export const command = defineCommand(async ({ prompt, stepVariables, contextRunState, stepIndex }) => {
+    const { model = 'auto', newChat = false, chatIdIndex = null } = stepVariables || {};
+
+    const chatState = contextRunState.cursorSetup ?? (contextRunState.cursorSetup = {});
+    const chatKey = Array.isArray(stepIndex) ? stepIndex.join('.') : String(stepIndex);
+
+    let chatId = chatIdIndex != null
+        ? chatState.chatsIds?.[chatIdIndex]
+        : chatState.setupChatId;
+
+    if (!chatId) {
+        throw new Error(
+            chatIdIndex != null
+                ? `Chat ID not found for index: ${chatIdIndex}`
+                : 'Chat ID not found in cursor setup state',
+        );
+    }
+
+    if (newChat) {
+        const createChatResult = await execAsync("cursor-agent create-chat");
+
+        if (!createChatResult.success) {
+            throw new Error(`Failed to create chat: ${createChatResult.data.message}`);
+        }
+
+        chatId = (createChatResult.data.stdout || createChatResult.data.stderr).trim();
+
+        chatState.chatsIds ??= {};
+        chatState.chatsIds[chatKey] = chatId;
+    }
+
+    return {
+        executable: 'cursor-agent',
+        args: [
+            '-p',
+            `"${prompt}"`,
+            '--force',
+            '--model',
+            model,
+            '--resume',
+            chatId,
+        ],
+    }
+});
+
+export const setup = defineCommandSetup(async ({}) => {
+    const setupChatId = await execAsync("cursor-agent create-chat");
+
+    if (!setupChatId.success) {
+        throw new Error(`Failed to create chat: ${setupChatId.data.message}`);
+    }
+
+    const setupChatIdStr = (setupChatId.data.stdout || setupChatId.data.stderr).trim();
+    
+    return {
+        contextRunState: {
+            setupChatId: setupChatIdStr,
+            chatsIds: {
+                "0": setupChatIdStr,
+            }
+        }
+    };
+});
+
+export const teardown = defineCommandTeardown((() => {
+    return;
+}));

package/dist/schemas/localConfig.schema.json

@@ -0,0 +1,29 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "localConfig.schema.json",
+  "title": "Lumpcode local configuration",
+  "description": "Schema for .lumpcode/local.json — a gitignored, per-machine file that controls where and how Lumpcode runs lumps from this checkout. Created by `lumpcode project-setup`; edit it on a daemon machine (e.g. switch `mode` to \"dedicated\").",
+  "type": "object",
+  "required": ["mode", "projectBaseBranch"],
+  "additionalProperties": false,
+  "properties": {
+    "mode": {
+      "type": "string",
+      "enum": ["shared", "dedicated"],
+      "description": "How Lumpcode handles the current checkout. `shared`: this is your day-to-day clone; Lumpcode never touches it and runs in a separate copy under ~/.lumpcode/project-copies/<projectName>/. `dedicated`: this clone is owned by Lumpcode (typical daemon machine); Lumpcode pulls and runs in place, including a destructive `git reset --hard` on `projectBaseBranch` before each tick."
+    },
+    "projectBaseBranch": {
+      "type": "string",
+      "description": "Branch Lumpcode pulls (and resets to) before running any lump. Also the default `baseBranch` for lumps that don't override it. Status checks (`finished`) compare against `origin/<projectBaseBranch>`."
+    },
+    "workspaceStrategy": {
+      "type": "string",
+      "enum": ["checkout", "worktree"],
+      "description": "How each lump run prepares git inside the preflight workspace. `checkout` (default): switch the main worktree to a fresh lump branch. `worktree`: run in a linked worktree under `.lumpcode/worktrees/<branch>/` so the main worktree stays on `projectBaseBranch`."
+    },
+    "disabled": {
+      "type": "boolean",
+      "description": "When true, the background daemon (`lumpcode start`) skips every lump on this machine without stopping the scheduler. Manual `lumpcode run` is unaffected."
+    }
+  }
+}

package/dist/schemas/lumpConfig.schema.json

@@ -0,0 +1,195 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "lumpConfig.schema.json",
+  "title": "Lump JSON Configuration",
+  "description": "JSON configuration schema for a Lump — a long-running automated coding campaign managed by Lumpcode. This schema defines the JSON-serializable subset of the full Lump configuration (LumpJsonConfig). Function-valued fields from the JS config are either excluded entirely or replaced by file paths pointing to modules that export the corresponding function.",
+  "type": "object",
+  "additionalProperties": true,
+  "allOf": [
+    {
+      "oneOf": [
+        { "required": ["contextListJson"], "not": { "anyOf": [{ "required": ["getContextListFn"] }, { "required": ["contextMatchFn"] }] } },
+        { "required": ["getContextListFn"], "not": { "anyOf": [{ "required": ["contextListJson"] }, { "required": ["contextMatchFn"] }] } },
+        { "required": ["contextMatchFn"], "not": { "anyOf": [{ "required": ["contextListJson"] }, { "required": ["getContextListFn"] }] } }
+      ],
+      "description": "Exactly one context source must be provided: 'contextListJson' (a static json or path to a json file), 'getContextListFn' (a file path to a dynamic context-fetching function), or 'contextMatchFn' (a file path to a MatchFn that builds contexts by scanning codebase files)."
+    },
+    {
+      "oneOf": [
+        { "required": ["prompt"], "not": { "required": ["steps"] } },
+        { "required": ["steps"], "not": { "required": ["prompt"] } }
+      ],
+      "description": "Exactly one prompt definition must be provided: either 'prompt' (a single prompt item) or 'steps' (an ordered list of prompt steps)."
+    }
+  ],
+  "properties": {
+    "baseBranch": {
+      "type": "string",
+      "description": "Optional override of the project-wide `projectBaseBranch` (from `.lumpcode/local.json`). When set, this lump runs against the given branch instead; the per-lump workspace flow will fetch and pull it before creating the lump branch. Most lumps omit this field.",
+      "examples": ["main", "develop", "release/2.0"]
+    },
+    "branchFn": {
+      "type": "string",
+      "description": "File path to a module that default-exports a BranchFn — a function that determines the branch name for a given set of contexts. In the JS config this can be the function itself; in JSON it must be a file path to the module.",
+      "examples": ["./lump/branchFn.ts", "./lump/branchFn.js"]
+    },
+    "command": {
+      "type": "string",
+      "description": "A top-level command shorthand applied to all prompt items. Can be either:\n  • A registered command string (e.g. 'claude') that will receive the prompt\n  • A file path to a module containing a CommandFn\nWhen set here, individual prompt items inherit this command unless they override it.",
+      "examples": ["claude", "aider", "./command.ts"]
+    },
+    "contextListJson": {
+      "oneOf": [
+        {
+          "type": "string",
+          "description": "File path to a JSON file containing a { [variableName]: pathTemplate } mapping."
+        },
+        {
+          "type": "object",
+          "additionalProperties": {
+            "type": "string"
+          },
+          "description": "Inline mapping from variable name to path template. Each value is a path template with {PLACEHOLDER} captures (e.g. 'src/{NAME}.ts'); each key is the variable name exposed to the prompt as {KEY} / @{KEY}."
+        }
+      ],
+      "description": "Static context source. The engine scans the tree and, for every path that matches a template, builds a context whose variables map keys (e.g. 'FILE') to the matched path. Path templates support {PLACEHOLDER} captures and $modifier{PLACEHOLDER} (e.g. $upperFirst{NAME}) for naming-convention checks. Prefer paths without a leading './'. Mutually exclusive with getContextListFn / contextMatchFn.",
+      "examples": [
+        "./contextList.json",
+        {
+            "FILE": "src/{NAME}.ts"
+        },
+        {
+            "FOLDER": "src/components/{COMPONENT_NAME}/",
+            "INDEX": "src/components/{COMPONENT_NAME}/index.ts",
+            "TYPES": "src/components/{COMPONENT_NAME}/{COMPONENT_NAME}.types.ts",
+            "COMPONENT": "src/components/{COMPONENT_NAME}/$upperFirst{COMPONENT_NAME}.tsx"
+        }
+      ]
+    },
+    "contextMatchFn": {
+      "type": "string",
+      "description": "File path to a module exporting a MatchFn — a function that builds contexts by scanning codebase files. For each codeBasePath, the function returns an object { contextName, filePathVariableName, moreContextVariables?, contextOptions? } or null if the file doesn't match. Multiple matches with the same contextName merge into one context (variables accumulate; later matches override duplicate keys). This is an alternative to 'contextListJson' and 'getContextListFn' for dynamically grouping files into contexts based on custom matching logic.",
+      "examples": ["./lump/contextMatchFn.ts"]
+    },
+    "contextOptionsFn": {
+      "type": "string",
+      "description": "File path to a module exporting a function that provides additional options or configuration for each context. In the JS config this can be the function itself; in JSON it must be a file path.",
+      "examples": ["./lump/contextOptionsFn.ts"]
+    },
+    "disabled": {
+      "type": "boolean",
+      "description": "When true, this lump configuration is skipped during execution. Useful for temporarily disabling a lump without removing its configuration.",
+      "default": false
+    },
+    "getContextListFn": {
+      "type": "string",
+      "description": "File path to a module exporting a GetContextListFn — a function that dynamically retrieves the list of contexts to process. In the JS config this can be the function itself; in JSON it must be a file path. Use contextListJson instead if your context list is static.",
+      "examples": ["./lump/getContextListFn.ts"]
+    },
+    "maximumNumberOfConcurrentBranches": {
+      "type": "integer",
+      "minimum": 1,
+      "description": "Maximum number of context branches that can be processed concurrently. Limits parallelism to avoid overwhelming the system or hitting rate limits."
+    },
+    "numberOfContextsPerBranch": {
+      "type": "integer",
+      "minimum": 1,
+      "description": "Number of contexts to group into a single branch. Defaults to 1, meaning each context gets its own branch.",
+      "default": 1
+    },
+    "lumpVariables": {
+      "type": "object",
+      "additionalProperties": true,
+      "description": "An arbitrary key-value object of variables passed through to prompt functions, setup/teardown hooks, and other lifecycle functions. Use this to parameterize your lump without changing code.",
+      "examples": [
+        { "language": "TypeScript", "style": "functional" }
+      ]
+    },
+    "verbose": {
+      "type": "boolean",
+      "description": "When true, enables verbose logging output during lump execution for debugging purposes.",
+      "default": false
+    },
+    "registerCommands": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "description": "An array of command names to pre-register before processing prompt items. Required when prompt items are defined dynamically (via functions) and reference commands by name, since dynamic prompt items cannot trigger command registration at build time. Each name is resolved to a command module file (e.g. 'cursor-agent' resolves to 'commands/cursor-agent.js').",
+      "examples": [["claude-code"], ["cursor-agent", "aider"]]
+    },
+    "prompt": {
+      "$ref": "#/$defs/LumpJsonConfigStep",
+      "description": "A single prompt item defining the prompt template or function, the command to run, and optional lifecycle hooks. Use this shorthand for simple lumps that only require one prompt step. For multi-step lumps, use 'steps' instead."
+    },
+    "steps": {
+      "type": "array",
+      "items": {
+        "oneOf": [
+          {
+            "$ref": "#/$defs/LumpJsonConfigStep"
+          },
+          {
+            "type": "string",
+            "description": "A shorthand string interpreted as a prompt template — either inline prompt text or a file path to a template file. Equivalent to a LumpJsonConfigStep with only the 'promptTemplate' field set."
+          }
+        ]
+      },
+      "description": "An ordered list of prompt items executed sequentially for each context. Each element can be:\n  • A full LumpJsonConfigStep object with explicit fields\n  • A string shorthand interpreted as a promptTemplate (inline text or file path)\nUse this for multi-step lumps that need multiple sequential prompt/command cycles per context."
+    }
+  },
+  "$defs": {
+    "LumpJsonConfigStep": {
+      "type": ["object", "string"],
+      "additionalProperties": false,
+      "description": "A single step in a lump's execution pipeline. Defines an optional prompt, which command to execute, and optional post-processing. Prompt fields are optional; when omitted the command receives an empty prompt string. The top-level 'command' is used when this step does not set 'command'.",
+      "oneOf": [
+        { "type": "string", "description": "Shorthand: inline prompt template or file path to a template file." },
+        {
+          "type": "object",
+          "not": { "required": ["promptTemplate", "promptFn"] }
+        }
+      ],
+      "properties": {
+        "promptTemplate": {
+          "type": "string",
+          "description": "The prompt content for this step. Accepts two forms:\n  • Inline template string — the literal prompt text, which may contain braced placeholders from the context's variables: `{VAR}` (literal) and `@{VAR}` (same value with a leading `@` for agents that use `@path` file context). Double-brace forms like {{FILE}} are NOT substituted.\n  • File path — a path to a template file whose contents will be read and used as the prompt (e.g. './prompts/refactor.md')\nFor dynamic prompt generation based on context at runtime, use 'promptFn' instead.",
+          "examples": [
+            "Refactor the following file to use modern syntax",
+            "./prompts/my-template.md",
+            "./prompts/refactor.txt"
+          ]
+        },
+        "promptFn": {
+          "type": "string",
+          "description": "File path to a module exporting a PromptFn — a function that dynamically generates prompt text at runtime. The function signature is:\n  (params: { context, stepIndex, contextRunState, lumpVariables, stepVariables? }) => string | Promise<string>\nUse this instead of 'promptTemplate' when the prompt needs to vary based on context, run state, or other dynamic data.",
+          "examples": ["./lump/promptFn.ts", "./lump/promptFn.js"]
+        },
+        "command": {
+          "type": "string",
+          "description": "The command to execute with the generated prompt. Accepts two forms:\n  • Registered command name — the bare name of a command module (e.g. 'claude', 'aider'). Lumpcode resolves it to '.lumpcode/commands/<name>.js' (project-local) or '~/.lumpcode/commands/<name>.js' (global). Do NOT include flags here; agent-specific flags go inside the command module's CommandFn output.\n  • File path — a path to a module exporting a CommandFn directly\nThe prompt text is passed by the command module as args to the underlying agent.",
+          "examples": ["claude", "aider", "./lump/command.ts"]
+        },
+        "postCommandExecFn": {
+          "type": "string",
+          "description": "File path to a module exporting a PostCommandExecFn — a function called after the command finishes executing. The function receives:\n  { commandResult, context, prompt, stepIndex, contextRunState, lumpVariables }\nUse this for validation, logging, cleanup, or other side effects after each prompt/command cycle.",
+          "examples": ["./lump/postCommandExecFn.ts"]
+        },
+        "stepVariables": {
+          "type": "object",
+          "additionalProperties": true,
+          "description": "An arbitrary key-value object of variables specific to this prompt item. Passed to the promptFn alongside the global lumpVariables, enabling per-step parameterization without modifying the top-level lumpVariables.",
+          "examples": [
+            { "maxRetries": 3, "style": "concise" }
+          ]
+        },
+        "timeoutMillis": {
+          "type": "integer",
+          "minimum": 0,
+          "description": "Maximum time in milliseconds to wait for the command to complete before it is considered timed out. If omitted or set to 0, no timeout is enforced.",
+          "examples": [60000, 300000]
+        }
+      }
+    }
+  }
+}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@lumpcode/cli",
+  "version": "0.0.0",
+  "description": "CLI for Lumpcode — automate batched coding work with CLI coding agents over contexts using git for tracking",
+  "license": "Apache-2.0",
+  "author": "",
+  "type": "commonjs",
+  "main": "dist/index.js",
+  "engines": {
+    "node": ">=22"
+  },
+  "bin": {
+    "lumpcode": "./bin/lumpcode.js"
+  },
+  "files": [
+    "bin/lumpcode.js",
+    "dist/index.js",
+    "dist/schemas",
+    "dist/presets",
+    "scripts/native-binary.mjs",
+    "scripts/postinstall.mjs",
+    "README.md",
+    "LICENSE",
+    "DOCS"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "clean": "rm -rf dist && rm -rf bin",
+    "build:bundle": "node scripts/build.js",
+    "build:npm": "npm run build:bundle",
+    "build:sea": "npm run build:bundle && bash scripts/build-sea.sh",
+    "build:sea:windows": "npm run build:bundle && powershell -ExecutionPolicy Bypass -File scripts/build-sea.ps1",
+    "build": "npm run clean && npm run build:sea",
+    "postinstall": "node scripts/postinstall.mjs",
+    "prepublishOnly": "npm run build:bundle",
+    "check-types": "tsc --noEmit",
+    "test": "vitest run --config vitest.config.ts",
+    "test:e2e": "node scripts/run-e2e.mjs",
+    "test:e2e:node": "node scripts/run-e2e.mjs --node",
+    "test:e2e:ci": "node scripts/run-e2e.mjs --ci",
+    "test:e2e:ci:node": "node scripts/run-e2e.mjs --node --ci"
+  },
+  "dependencies": {
+    "@lumpcode/core": "^0.0.0",
+    "ajv": "^8.20.0",
+    "commander": "^9.5.0",
+    "croner": "^9.1.0",
+    "dotenv": "^16.6.1",
+    "lodash": "^4.18.1",
+    "node-machine-id": "^1.1.12"
+  },
+  "devDependencies": {
+    "@types/lodash": "^4.17.24",
+    "@vercel/ncc": "^0.38.4",
+    "postject": "^1.0.0-alpha.6",
+    "tslib": "^2.8.1",
+    "typescript": "^5.7.2"
+  }
+}

package/scripts/native-binary.mjs

@@ -0,0 +1,180 @@
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+const DEFAULT_INSTALL_REPO = 'YOUR_ORG/Lumpcode';
+
+/**
+ * @param {string} [platform]
+ * @param {string} [arch]
+ * @returns {{ platform: string; arch: string; assetBase: string } | null}
+ */
+export function detectPlatformArch(platform = process.platform, arch = process.arch) {
+    let archName;
+    if (arch === 'arm64' || arch === 'aarch64') {
+        archName = 'arm64';
+    } else if (arch === 'x64' || arch === 'x86_64') {
+        archName = 'x64';
+    } else {
+        return null;
+    }
+
+    let platformName;
+    if (platform === 'linux') {
+        platformName = 'linux';
+    } else if (platform === 'darwin') {
+        platformName = 'darwin';
+    } else if (platform === 'win32') {
+        platformName = 'windows';
+    } else {
+        return null;
+    }
+
+    if (platformName === 'windows' && archName !== 'x64') {
+        return null;
+    }
+
+    const assetBase =
+        platformName === 'windows'
+            ? `lumpcode-${platformName}-${archName}.exe`
+            : `lumpcode-${platformName}-${archName}`;
+
+    return { platform: platformName, arch: archName, assetBase };
+}
+
+/**
+ * @param {{ version: string; assetBase: string; repo?: string }} input
+ * @returns {string}
+ */
+export function getReleaseDownloadUrl({ version, assetBase, repo = process.env.LUMPCODE_INSTALL_REPO || DEFAULT_INSTALL_REPO }) {
+    const tag = version.startsWith('v') ? version : `v${version}`;
+    return `https://github.com/${repo}/releases/download/${tag}/${assetBase}`;
+}
+
+/**
+ * @param {string} pkgRoot
+ * @returns {string}
+ */
+export function getVendorBinaryPath(pkgRoot) {
+    return process.platform === 'win32'
+        ? path.join(pkgRoot, 'vendor', 'lumpcode.exe')
+        : path.join(pkgRoot, 'vendor', 'lumpcode');
+}
+
+/**
+ * @param {string} pkgRoot
+ * @returns {boolean}
+ */
+export function isNativeBinaryInstalled(pkgRoot) {
+    const marker = path.join(pkgRoot, 'vendor', '.installed');
+    const binary = getVendorBinaryPath(pkgRoot);
+    return fs.existsSync(marker) && fs.existsSync(binary);
+}
+
+/**
+ * @param {string} src
+ * @param {string} dest
+ */
+function copyDirRecursive(src, dest) {
+    fs.mkdirSync(dest, { recursive: true });
+    fs.cpSync(src, dest, { recursive: true });
+}
+
+/**
+ * @param {string} data
+ * @param {string} expectedHex
+ * @returns {boolean}
+ */
+function verifySha256(data, expectedHex) {
+    const actual = crypto.createHash('sha256').update(data).digest('hex');
+    return actual === expectedHex.trim().toLowerCase();
+}
+
+/**
+ * @param {string} url
+ * @param {typeof fetch} fetchFn
+ * @returns {Promise<{ ok: true; buffer: Buffer } | { ok: false; status?: number; error?: string }>}
+ */
+async function downloadUrl(url, fetchFn) {
+    try {
+        const response = await fetchFn(url);
+        if (!response.ok) {
+            return { ok: false, status: response.status };
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        return { ok: true, buffer: Buffer.from(arrayBuffer) };
+    } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { ok: false, error: message };
+    }
+}
+
+/**
+ * @param {{
+ *   pkgRoot: string;
+ *   version: string;
+ *   platform?: string;
+ *   arch?: string;
+ *   fetchFn?: typeof fetch;
+ * }} input
+ * @returns {Promise<{ installed: boolean; reason?: string; assetBase?: string }>}
+ */
+export async function installNativeBinary({
+    pkgRoot,
+    version,
+    platform = process.platform,
+    arch = process.arch,
+    fetchFn = fetch,
+}) {
+    const detected = detectPlatformArch(platform, arch);
+    if (!detected) {
+        return { installed: false, reason: 'unsupported-platform' };
+    }
+
+    const { assetBase } = detected;
+    const url = getReleaseDownloadUrl({ version, assetBase });
+    const download = await downloadUrl(url, fetchFn);
+    if (!download.ok) {
+        return {
+            installed: false,
+            reason: download.status === 404 ? 'not-found' : 'download-failed',
+            assetBase,
+        };
+    }
+
+    const checksumUrl = `${url}.sha256`;
+    const checksumDownload = await downloadUrl(checksumUrl, fetchFn);
+    if (checksumDownload.ok) {
+        const expectedHex = checksumDownload.buffer.toString('utf-8').split(/\s+/)[0];
+        if (!verifySha256(download.buffer, expectedHex)) {
+            return { installed: false, reason: 'checksum-mismatch', assetBase };
+        }
+    }
+
+    const vendorDir = path.join(pkgRoot, 'vendor');
+    const binaryPath = getVendorBinaryPath(pkgRoot);
+    const schemasSrc = path.join(pkgRoot, 'dist', 'schemas');
+    const presetsSrc = path.join(pkgRoot, 'dist', 'presets');
+
+    if (!fs.existsSync(schemasSrc) || !fs.existsSync(presetsSrc)) {
+        return { installed: false, reason: 'missing-dist-sidecars', assetBase };
+    }
+
+    fs.mkdirSync(vendorDir, { recursive: true });
+    fs.writeFileSync(binaryPath, download.buffer);
+    if (platform !== 'win32') {
+        fs.chmodSync(binaryPath, 0o755);
+    }
+
+    copyDirRecursive(schemasSrc, path.join(vendorDir, 'schemas'));
+    copyDirRecursive(presetsSrc, path.join(vendorDir, 'presets'));
+
+    const marker = {
+        version,
+        assetBase,
+        installedAt: new Date().toISOString(),
+    };
+    fs.writeFileSync(path.join(vendorDir, '.installed'), `${JSON.stringify(marker)}\n`, 'utf-8');
+
+    return { installed: true, assetBase };
+}

package/scripts/postinstall.mjs

@@ -0,0 +1,52 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { installNativeBinary } from './native-binary.mjs';
+
+const pkgRoot = path.join(path.dirname(fileURLToPath(import.meta.url)), '..');
+
+function shouldSkipPostinstall() {
+    if (process.env.LUMPCODE_SKIP_BINARY === '1') {
+        return true;
+    }
+    if (process.env.npm_config_ignore_scripts === 'true') {
+        return true;
+    }
+    if (process.env.CI === 'true') {
+        return true;
+    }
+    if (!fs.existsSync(path.join(pkgRoot, 'dist', 'index.js'))) {
+        return true;
+    }
+    if (fs.existsSync(path.join(pkgRoot, 'src', 'root.ts'))) {
+        return true;
+    }
+    return false;
+}
+
+function logVerbose(message) {
+    if (process.env.LUMPCODE_INSTALL_VERBOSE === '1') {
+        console.log(`[lumpcode] ${message}`);
+    }
+}
+
+async function main() {
+    if (shouldSkipPostinstall()) {
+        logVerbose('postinstall: skipped native binary download');
+        return;
+    }
+
+    const pkg = JSON.parse(fs.readFileSync(path.join(pkgRoot, 'package.json'), 'utf-8'));
+    const result = await installNativeBinary({ pkgRoot, version: pkg.version });
+
+    if (result.installed) {
+        logVerbose(`postinstall: installed native binary (${result.assetBase})`);
+    } else {
+        logVerbose(`postinstall: native binary not available (${result.reason ?? 'unknown'}), using Node fallback`);
+    }
+}
+
+main().catch((error) => {
+    logVerbose(`postinstall: native binary install failed (${error instanceof Error ? error.message : String(error)}), using Node fallback`);
+});