flintmaker 0.0.0-stage → 0.1.0

package/README.md

@@ -1,3 +1,17 @@
-# Temporary Holding Version
+# flint — FlintMaker for your terminal
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+`flint` is an AI coding agent from [FlintMaker](https://flintmaker.com). It reads your project, edits files and runs commands — always showing you the diff or command first.
+
+```sh
+npm install -g flintmaker
+flint login          # connect your FlintMaker account (opens the browser)
+cd my-project
+flint                # interactive session
+flint "add a dark mode toggle"   # one task, then exit
+```
+
+- Every file change is shown as a diff and needs your approval (or `a` = always for this session).
+- Commands run only after you approve them; secret files such as `.env` and private keys are never read.
+- Uses credits from your FlintMaker plan. See [pricing](https://flintmaker.com/pricing).
+
+Made by PT Jiji Labs Digital · hello@jijilabsdigital.com

package/dist/flint.js

@@ -0,0 +1,1000 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+));
+
+// node_modules/picocolors/picocolors.js
+var require_picocolors = __commonJS({
+  "node_modules/picocolors/picocolors.js"(exports, module) {
+    var p = process || {}, argv = p.argv || [], env = p.env || {}, isColorSupported = !(env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI), formatter = (open, close, replace = open) => (input) => {
+      let string = "" + input, index = string.indexOf(close, open.length);
+      return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+    }, replaceClose = (string, close, replace, index) => {
+      let result = "", cursor = 0;
+      do
+        result += string.substring(cursor, index) + replace, cursor = index + close.length, index = string.indexOf(close, cursor);
+      while (~index);
+      return result + string.substring(cursor);
+    }, createColors = (enabled = isColorSupported) => {
+      let f = enabled ? formatter : () => String;
+      return {
+        isColorSupported: enabled,
+        reset: f("\x1B[0m", "\x1B[0m"),
+        bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+        dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+        italic: f("\x1B[3m", "\x1B[23m"),
+        underline: f("\x1B[4m", "\x1B[24m"),
+        inverse: f("\x1B[7m", "\x1B[27m"),
+        hidden: f("\x1B[8m", "\x1B[28m"),
+        strikethrough: f("\x1B[9m", "\x1B[29m"),
+        black: f("\x1B[30m", "\x1B[39m"),
+        red: f("\x1B[31m", "\x1B[39m"),
+        green: f("\x1B[32m", "\x1B[39m"),
+        yellow: f("\x1B[33m", "\x1B[39m"),
+        blue: f("\x1B[34m", "\x1B[39m"),
+        magenta: f("\x1B[35m", "\x1B[39m"),
+        cyan: f("\x1B[36m", "\x1B[39m"),
+        white: f("\x1B[37m", "\x1B[39m"),
+        gray: f("\x1B[90m", "\x1B[39m"),
+        bgBlack: f("\x1B[40m", "\x1B[49m"),
+        bgRed: f("\x1B[41m", "\x1B[49m"),
+        bgGreen: f("\x1B[42m", "\x1B[49m"),
+        bgYellow: f("\x1B[43m", "\x1B[49m"),
+        bgBlue: f("\x1B[44m", "\x1B[49m"),
+        bgMagenta: f("\x1B[45m", "\x1B[49m"),
+        bgCyan: f("\x1B[46m", "\x1B[49m"),
+        bgWhite: f("\x1B[47m", "\x1B[49m"),
+        blackBright: f("\x1B[90m", "\x1B[39m"),
+        redBright: f("\x1B[91m", "\x1B[39m"),
+        greenBright: f("\x1B[92m", "\x1B[39m"),
+        yellowBright: f("\x1B[93m", "\x1B[39m"),
+        blueBright: f("\x1B[94m", "\x1B[39m"),
+        magentaBright: f("\x1B[95m", "\x1B[39m"),
+        cyanBright: f("\x1B[96m", "\x1B[39m"),
+        whiteBright: f("\x1B[97m", "\x1B[39m"),
+        bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+        bgRedBright: f("\x1B[101m", "\x1B[49m"),
+        bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+        bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+        bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+        bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+        bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+        bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+      };
+    };
+    module.exports = createColors();
+    module.exports.createColors = createColors;
+  }
+});
+
+// src/index.ts
+import { spawn as spawn2 } from "node:child_process";
+import { createInterface } from "node:readline/promises";
+import { homedir as homedir2 } from "node:os";
+
+// src/agent.ts
+var ContextTooLarge = class extends Error {
+}, DETAIL = {
+  list_files: (a) => String(a.path ?? "."),
+  read_file: (a) => `${a.path}${a.start_line ? `:${a.start_line}-${a.end_line ?? ""}` : ""}`,
+  search: (a) => `/${a.pattern}/ ${a.path ?? ""}`.trim(),
+  write_file: (a) => String(a.path),
+  edit_file: (a) => String(a.path),
+  run_command: (a) => String(a.command)
+};
+async function execute(ws, name, args, ui) {
+  switch (name) {
+    case "list_files":
+      return ws.listFiles(typeof args.path == "string" ? args.path : ".");
+    case "read_file":
+      return ws.readFile(String(args.path), num(args.start_line), num(args.end_line));
+    case "search":
+      return ws.search(String(args.pattern ?? ""), typeof args.path == "string" ? args.path : ".");
+    case "write_file":
+    case "edit_file": {
+      let change = await ws.plan(name, args);
+      return await ui.approveChange(change) ? (await change.apply(), `${change.created ? "Created" : "Updated"} ${change.path}.`) : "The user declined this change. Ask what they want instead, or try a different approach.";
+    }
+    case "run_command": {
+      let command = String(args.command ?? "").trim();
+      if (!command) throw new Error("command is required");
+      return await ui.approveCommand(command) ? ws.runCommand(command) : "The user declined to run this command.";
+    }
+    default:
+      throw new Error(`unknown tool ${name}`);
+  }
+}
+var num = (v) => typeof v == "number" && Number.isFinite(v) ? v : void 0;
+function compact(messages) {
+  let out = structuredClone(messages), tools = out.map((m, i) => ({ m, i })).filter((x) => x.m.role === "tool" && (x.m.content?.length ?? 0) > 400);
+  for (let { m } of tools.slice(0, Math.max(1, Math.ceil(tools.length / 2))))
+    m.role === "tool" && (m.content = `${m.content.slice(0, 300)}
+[output trimmed to save context; read again if needed]`);
+  return tools.length === 0 && out.length > 4 && out.splice(1, 2), out;
+}
+async function runAgent(ws, start, step, ui, opts = {}) {
+  let messages = [...start];
+  for (let i = 0; i < (opts.maxSteps ?? 25); i++) {
+    let result = null;
+    for (let attempt = 0; attempt < 4 && !result; attempt++)
+      try {
+        result = await step(messages, ui.onDelta);
+      } catch (e) {
+        if (!(e instanceof ContextTooLarge)) throw e;
+        messages = compact(messages);
+      }
+    if (!result) throw new Error("This conversation is too long. Start a new one with /clear.");
+    if (result.toolCalls.length === 0)
+      return messages.push({ role: "assistant", content: result.text }), messages;
+    messages.push({
+      role: "assistant",
+      content: result.text || null,
+      tool_calls: result.toolCalls.map((c) => ({ id: c.id, type: "function", function: { name: c.name, arguments: c.arguments } }))
+    });
+    for (let call of result.toolCalls) {
+      let args = {};
+      try {
+        args = JSON.parse(call.arguments || "{}");
+      } catch {
+      }
+      ui.onToolStart(call.name, (DETAIL[call.name] ?? (() => ""))(args));
+      let content;
+      try {
+        content = await execute(ws, call.name, args, ui), ui.onToolResult(call.name, !0);
+      } catch (e) {
+        content = `Error: ${e.message}`, ui.onToolResult(call.name, !1, e.message);
+      }
+      messages.push({ role: "tool", tool_call_id: call.id, content });
+    }
+  }
+  return messages.push({ role: "assistant", content: "I stopped after many steps. Tell me how to continue." }), messages;
+}
+
+// src/sse.ts
+function createSSEParser() {
+  let buffer = "";
+  return (chunk) => {
+    buffer += chunk;
+    let blocks = buffer.split(`
+
+`);
+    return buffer = blocks.pop() ?? "", blocks.filter(Boolean).map((block) => {
+      let event = "message", data = [];
+      for (let line of block.split(`
+`))
+        line.startsWith("event:") ? event = line.slice(6).trim() : line.startsWith("data:") && data.push(line.slice(5).replace(/^ /, ""));
+      return { event, data: data.join(`
+`) };
+    });
+  };
+}
+
+// src/api.ts
+var FlintError = class extends Error {
+  constructor(message, reason = "error", status = 0) {
+    super(message);
+    this.reason = reason;
+    this.status = status;
+  }
+  reason;
+  status;
+}, when = (iso) => iso ? new Date(iso).toLocaleString(void 0, { weekday: "short", hour: "2-digit", minute: "2-digit" }) : "soon";
+async function failure(res, base) {
+  let body = await res.json().catch(() => ({})), ref = body.requestId ? ` (ref ${body.requestId})` : "";
+  switch (body.reason) {
+    case "signed_out":
+      return new FlintError("You are signed out. Run: flint login", "signed_out", res.status);
+    case "limit":
+      return new FlintError(`Out of credits until ${when(body.resetAt)}. Get more at ${base}/pricing`, "limit", res.status);
+    case "busy":
+      return new FlintError("FlintMaker is very busy right now. Please try again later.", "busy", res.status);
+    case "upgrade_required":
+      return new FlintError(`The smart model needs a paid plan: ${base}/pricing`, "upgrade_required", res.status);
+    case "in_progress":
+      return new FlintError("Another flint session is still working. Wait for it to finish.", "in_progress", res.status);
+    default:
+      return new FlintError(`Request failed (${res.status} ${body.reason ?? ""})${ref}`, body.reason ?? "error", res.status);
+  }
+}
+var Client = class {
+  constructor(base, token) {
+    this.base = base;
+    this.token = token;
+  }
+  base;
+  token;
+  headers() {
+    return { "content-type": "application/json", "user-agent": "flint-cli", ...this.token ? { authorization: `Bearer ${this.token}` } : {} };
+  }
+  async json(path, init = {}) {
+    let res = await fetch(`${this.base}/api${path}`, { ...init, headers: { ...this.headers(), ...init.headers } });
+    if (!res.ok) throw await failure(res, this.base);
+    return await res.json();
+  }
+  me() {
+    return this.json("/me");
+  }
+  /** Device login: show the code, wait until the user approves in the browser. */
+  async deviceLogin(show) {
+    let start = await this.json("/auth/device", {
+      method: "POST",
+      body: "{}"
+    });
+    show(start.userCode, start.verifyUrl);
+    let deadline = Date.now() + start.expiresIn * 1e3;
+    for (; Date.now() < deadline; ) {
+      await new Promise((r) => setTimeout(r, start.interval * 1e3));
+      let res = await fetch(`${this.base}/api/auth/device/token`, { method: "POST", headers: this.headers(), body: JSON.stringify({ deviceCode: start.deviceCode }) });
+      if (res.status !== 428) {
+        if (res.ok) return await res.json();
+        throw new FlintError("The login code expired. Run flint login again.", "expired", res.status);
+      }
+    }
+    throw new FlintError("The login code expired. Run flint login again.", "expired");
+  }
+  /** A StepFn bound to this account: one /api/agent call, streamed. */
+  stepper(model, signal, onCredits) {
+    return async (messages, onDelta) => {
+      let res = await fetch(`${this.base}/api/agent`, {
+        method: "POST",
+        headers: this.headers(),
+        body: JSON.stringify({ messages, model: model() }),
+        signal: signal()
+      });
+      if (res.status === 413) throw new ContextTooLarge();
+      if (!res.ok || !res.body) throw await failure(res, this.base);
+      let parse = createSSEParser(), decoder = new TextDecoder(), text = "", toolCalls = [];
+      for await (let chunk of res.body)
+        for (let ev of parse(decoder.decode(chunk, { stream: !0 }))) {
+          let data = ev.data ? JSON.parse(ev.data) : {};
+          if (ev.event === "delta")
+            text += data.text, onDelta(data.text);
+          else if (ev.event === "tool_call") toolCalls.push(data);
+          else if (ev.event === "done") onCredits(data.credits, data.usage);
+          else if (ev.event === "error") throw new FlintError(`The model hit a problem; no credits were used.${data.requestId ? ` (ref ${data.requestId})` : ""}`, "model");
+        }
+      return { text, toolCalls };
+    };
+  }
+};
+
+// src/config.ts
+import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+var DEFAULT_API = "https://flintmaker.com", configDir = () => join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), "flintmaker"), authPath = (dir = configDir()) => join(dir, "auth.json");
+function loadAuth(dir = configDir()) {
+  try {
+    let a = JSON.parse(readFileSync(authPath(dir), "utf8"));
+    return typeof a?.token == "string" ? a : null;
+  } catch {
+    return null;
+  }
+}
+function saveAuth(a, dir = configDir()) {
+  mkdirSync(dir, { recursive: !0, mode: 448 }), writeFileSync(authPath(dir), JSON.stringify(a, null, 2), { mode: 384 }), chmodSync(authPath(dir), 384);
+}
+function clearAuth(dir = configDir()) {
+  existsSync(authPath(dir)) && rmSync(authPath(dir));
+}
+function apiBase(auth) {
+  return (process.env.FLINT_API || auth?.api || DEFAULT_API).replace(/\/$/, "");
+}
+
+// src/tools.ts
+import { spawn, execFileSync } from "node:child_process";
+import { existsSync as existsSync2, lstatSync, realpathSync } from "node:fs";
+import { mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join as join2, relative, resolve, sep } from "node:path";
+
+// node_modules/diff/libesm/diff/base.js
+var Diff = class {
+  diff(oldStr, newStr, options = {}) {
+    let callback;
+    typeof options == "function" ? (callback = options, options = {}) : "callback" in options && (callback = options.callback);
+    let oldString = this.castInput(oldStr, options), newString = this.castInput(newStr, options), oldTokens = this.removeEmpty(this.tokenize(oldString, options)), newTokens = this.removeEmpty(this.tokenize(newString, options));
+    return this.diffWithOptionsObj(oldTokens, newTokens, options, callback);
+  }
+  diffWithOptionsObj(oldTokens, newTokens, options, callback) {
+    var _a;
+    let done = (value) => {
+      if (value = this.postProcess(value, options), callback) {
+        setTimeout(function() {
+          callback(value);
+        }, 0);
+        return;
+      } else
+        return value;
+    }, newLen = newTokens.length, oldLen = oldTokens.length, editLength = 1, maxEditLength = newLen + oldLen;
+    options.maxEditLength != null && (maxEditLength = Math.min(maxEditLength, options.maxEditLength));
+    let maxExecutionTime = (_a = options.timeout) !== null && _a !== void 0 ? _a : 1 / 0, abortAfterTimestamp = Date.now() + maxExecutionTime, bestPath = [{ oldPos: -1, lastComponent: void 0 }], newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);
+    if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen)
+      return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
+    let minDiagonalToConsider = -1 / 0, maxDiagonalToConsider = 1 / 0, execEditLength = () => {
+      for (let diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
+        let basePath, removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
+        removePath && (bestPath[diagonalPath - 1] = void 0);
+        let canAdd = !1;
+        if (addPath) {
+          let addPathNewPos = addPath.oldPos - diagonalPath;
+          canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
+        }
+        let canRemove = removePath && removePath.oldPos + 1 < oldLen;
+        if (!canAdd && !canRemove) {
+          bestPath[diagonalPath] = void 0;
+          continue;
+        }
+        if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos ? basePath = this.addToPath(addPath, !0, !1, 0, options) : basePath = this.addToPath(removePath, !1, !0, 1, options), newPos = this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options), basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen)
+          return done(this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || !0;
+        bestPath[diagonalPath] = basePath, basePath.oldPos + 1 >= oldLen && (maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1)), newPos + 1 >= newLen && (minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1));
+      }
+      editLength++;
+    };
+    if (callback)
+      (function exec() {
+        setTimeout(function() {
+          if (editLength > maxEditLength || Date.now() > abortAfterTimestamp)
+            return callback(void 0);
+          execEditLength() || exec();
+        }, 0);
+      })();
+    else
+      for (; editLength <= maxEditLength && Date.now() <= abortAfterTimestamp; ) {
+        let ret = execEditLength();
+        if (ret)
+          return ret;
+      }
+  }
+  addToPath(path, added, removed, oldPosInc, options) {
+    let last = path.lastComponent;
+    return last && !options.oneChangePerToken && last.added === added && last.removed === removed ? {
+      oldPos: path.oldPos + oldPosInc,
+      lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
+    } : {
+      oldPos: path.oldPos + oldPosInc,
+      lastComponent: { count: 1, added, removed, previousComponent: last }
+    };
+  }
+  extractCommon(basePath, newTokens, oldTokens, diagonalPath, options) {
+    let newLen = newTokens.length, oldLen = oldTokens.length, oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
+    for (; newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options); )
+      newPos++, oldPos++, commonCount++, options.oneChangePerToken && (basePath.lastComponent = { count: 1, previousComponent: basePath.lastComponent, added: !1, removed: !1 });
+    return commonCount && !options.oneChangePerToken && (basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: !1, removed: !1 }), basePath.oldPos = oldPos, newPos;
+  }
+  equals(left, right, options) {
+    return options.comparator ? options.comparator(left, right) : left === right || !!options.ignoreCase && left.toLowerCase() === right.toLowerCase();
+  }
+  removeEmpty(array) {
+    let ret = [];
+    for (let i = 0; i < array.length; i++)
+      array[i] && ret.push(array[i]);
+    return ret;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  castInput(value, options) {
+    return value;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  tokenize(value, options) {
+    return Array.from(value);
+  }
+  join(chars) {
+    return chars.join("");
+  }
+  postProcess(changeObjects, options) {
+    return changeObjects;
+  }
+  get useLongestToken() {
+    return !1;
+  }
+  buildValues(lastComponent, newTokens, oldTokens) {
+    let components = [], nextComponent;
+    for (; lastComponent; )
+      components.push(lastComponent), nextComponent = lastComponent.previousComponent, delete lastComponent.previousComponent, lastComponent = nextComponent;
+    components.reverse();
+    let componentLen = components.length, componentPos = 0, newPos = 0, oldPos = 0;
+    for (; componentPos < componentLen; componentPos++) {
+      let component = components[componentPos];
+      if (component.removed)
+        component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count)), oldPos += component.count;
+      else {
+        if (!component.added && this.useLongestToken) {
+          let value = newTokens.slice(newPos, newPos + component.count);
+          value = value.map(function(value2, i) {
+            let oldValue = oldTokens[oldPos + i];
+            return oldValue.length > value2.length ? oldValue : value2;
+          }), component.value = this.join(value);
+        } else
+          component.value = this.join(newTokens.slice(newPos, newPos + component.count));
+        newPos += component.count, component.added || (oldPos += component.count);
+      }
+    }
+    return components;
+  }
+};
+
+// node_modules/diff/libesm/diff/line.js
+var LineDiff = class extends Diff {
+  constructor() {
+    super(...arguments), this.tokenize = tokenize;
+  }
+  equals(left, right, options) {
+    return options.ignoreWhitespace ? ((!options.newlineIsToken || !left.includes(`
+`)) && (left = left.trim()), (!options.newlineIsToken || !right.includes(`
+`)) && (right = right.trim())) : options.ignoreNewlineAtEof && !options.newlineIsToken && (left.endsWith(`
+`) && (left = left.slice(0, -1)), right.endsWith(`
+`) && (right = right.slice(0, -1))), super.equals(left, right, options);
+  }
+}, lineDiff = new LineDiff();
+function diffLines(oldStr, newStr, options) {
+  return lineDiff.diff(oldStr, newStr, options);
+}
+function tokenize(value, options) {
+  options.stripTrailingCr && (value = value.replace(/\r\n/g, `
+`));
+  let retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
+  linesAndNewlines[linesAndNewlines.length - 1] || linesAndNewlines.pop();
+  for (let i = 0; i < linesAndNewlines.length; i++) {
+    let line = linesAndNewlines[i];
+    i % 2 && !options.newlineIsToken ? retLines[retLines.length - 1] += line : retLines.push(line);
+  }
+  return retLines;
+}
+
+// node_modules/diff/libesm/patch/create.js
+function needsQuoting(s) {
+  for (let i = 0; i < s.length; i++)
+    if (s[i] < " " || s[i] > "~" || s[i] === '"' || s[i] === "\\")
+      return !0;
+  return !1;
+}
+function quoteFileNameIfNeeded(s) {
+  if (!needsQuoting(s))
+    return s;
+  let result = '"', bytes = new TextEncoder().encode(s), i = 0;
+  for (; i < bytes.length; ) {
+    let b = bytes[i];
+    b === 7 ? result += "\\a" : b === 8 ? result += "\\b" : b === 9 ? result += "\\t" : b === 10 ? result += "\\n" : b === 11 ? result += "\\v" : b === 12 ? result += "\\f" : b === 13 ? result += "\\r" : b === 34 ? result += '\\"' : b === 92 ? result += "\\\\" : b >= 32 && b <= 126 ? result += String.fromCharCode(b) : result += "\\" + b.toString(8).padStart(3, "0"), i++;
+  }
+  return result += '"', result;
+}
+var INCLUDE_HEADERS = {
+  includeIndex: !0,
+  includeUnderline: !0,
+  includeFileHeaders: !0
+};
+function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
+  let optionsObj;
+  options ? typeof options == "function" ? optionsObj = { callback: options } : optionsObj = options : optionsObj = {}, typeof optionsObj.context > "u" && (optionsObj.context = 4);
+  let context = optionsObj.context;
+  if (optionsObj.newlineIsToken)
+    throw new Error("newlineIsToken may not be used with patch-generation functions, only with diffing functions");
+  if (optionsObj.callback) {
+    let { callback } = optionsObj;
+    diffLines(oldStr, newStr, Object.assign(Object.assign({}, optionsObj), { callback: (diff) => {
+      let patch = diffLinesResultToPatch(diff);
+      callback(patch);
+    } }));
+  } else
+    return diffLinesResultToPatch(diffLines(oldStr, newStr, optionsObj));
+  function diffLinesResultToPatch(diff) {
+    if (!diff)
+      return;
+    diff.push({ value: "", lines: [] });
+    function contextLines(lines) {
+      return lines.map(function(entry) {
+        return " " + entry;
+      });
+    }
+    let hunks = [], oldRangeStart = 0, newRangeStart = 0, curRange = [], oldLine = 1, newLine = 1;
+    for (let i = 0; i < diff.length; i++) {
+      let current = diff[i], lines = current.lines || splitLines(current.value);
+      if (current.lines = lines, current.added || current.removed) {
+        if (!oldRangeStart) {
+          let prev = diff[i - 1];
+          oldRangeStart = oldLine, newRangeStart = newLine, prev && (curRange = context > 0 ? contextLines(prev.lines.slice(-context)) : [], oldRangeStart -= curRange.length, newRangeStart -= curRange.length);
+        }
+        for (let line of lines)
+          curRange.push((current.added ? "+" : "-") + line);
+        current.added ? newLine += lines.length : oldLine += lines.length;
+      } else {
+        if (oldRangeStart)
+          if (lines.length <= context * 2 && i < diff.length - 2)
+            for (let line of contextLines(lines))
+              curRange.push(line);
+          else {
+            let contextSize = Math.min(lines.length, context);
+            for (let line of contextLines(lines.slice(0, contextSize)))
+              curRange.push(line);
+            let hunk = {
+              oldStart: oldRangeStart,
+              oldLines: oldLine - oldRangeStart + contextSize,
+              newStart: newRangeStart,
+              newLines: newLine - newRangeStart + contextSize,
+              lines: curRange
+            };
+            hunks.push(hunk), oldRangeStart = 0, newRangeStart = 0, curRange = [];
+          }
+        oldLine += lines.length, newLine += lines.length;
+      }
+    }
+    for (let hunk of hunks)
+      for (let i = 0; i < hunk.lines.length; i++)
+        hunk.lines[i].endsWith(`
+`) ? hunk.lines[i] = hunk.lines[i].slice(0, -1) : (hunk.lines.splice(i + 1, 0, "\"), i++);
+    return {
+      oldFileName,
+      newFileName,
+      oldHeader,
+      newHeader,
+      hunks
+    };
+  }
+}
+function formatPatch(patch, headerOptions) {
+  var _a, _b, _c, _d, _e, _f;
+  if (headerOptions || (headerOptions = INCLUDE_HEADERS), Array.isArray(patch)) {
+    if (patch.length > 1 && !headerOptions.includeFileHeaders && !patch.every((p) => p.isGit))
+      throw new Error("Cannot omit file headers on a multi-file patch. (The result would be unparseable; how would a tool trying to apply the patch know which changes are to which file?)");
+    return patch.map((p) => formatPatch(p, headerOptions)).join(`
+`);
+  }
+  let ret = [];
+  if (patch.isGit) {
+    if (headerOptions = INCLUDE_HEADERS, !patch.oldFileName)
+      throw new Error("oldFileName must be specified for Git patches");
+    if (!patch.newFileName)
+      throw new Error("newFileName must be specified for Git patches");
+    let gitOldName = patch.oldFileName, gitNewName = patch.newFileName;
+    patch.isCreate && gitOldName === "/dev/null" ? gitOldName = gitNewName.replace(/^b\//, "a/") : patch.isDelete && gitNewName === "/dev/null" && (gitNewName = gitOldName.replace(/^a\//, "b/")), ret.push("diff --git " + quoteFileNameIfNeeded(gitOldName) + " " + quoteFileNameIfNeeded(gitNewName)), patch.isDelete && ret.push("deleted file mode " + ((_a = patch.oldMode) !== null && _a !== void 0 ? _a : "100644")), patch.isCreate && ret.push("new file mode " + ((_b = patch.newMode) !== null && _b !== void 0 ? _b : "100644")), patch.oldMode && patch.newMode && !patch.isDelete && !patch.isCreate && (ret.push("old mode " + patch.oldMode), ret.push("new mode " + patch.newMode)), patch.isRename && (ret.push("rename from " + quoteFileNameIfNeeded(((_c = patch.oldFileName) !== null && _c !== void 0 ? _c : "").replace(/^a\//, ""))), ret.push("rename to " + quoteFileNameIfNeeded(((_d = patch.newFileName) !== null && _d !== void 0 ? _d : "").replace(/^b\//, "")))), patch.isCopy && (ret.push("copy from " + quoteFileNameIfNeeded(((_e = patch.oldFileName) !== null && _e !== void 0 ? _e : "").replace(/^a\//, ""))), ret.push("copy to " + quoteFileNameIfNeeded(((_f = patch.newFileName) !== null && _f !== void 0 ? _f : "").replace(/^b\//, ""))));
+  } else
+    headerOptions.includeIndex && patch.oldFileName == patch.newFileName && patch.oldFileName !== void 0 && ret.push("Index: " + patch.oldFileName), headerOptions.includeUnderline && ret.push("===================================================================");
+  let hasHunks = patch.hunks.length > 0;
+  headerOptions.includeFileHeaders && patch.oldFileName !== void 0 && patch.newFileName !== void 0 && (!patch.isGit || hasHunks) && (ret.push("--- " + quoteFileNameIfNeeded(patch.oldFileName) + (patch.oldHeader ? "	" + patch.oldHeader : "")), ret.push("+++ " + quoteFileNameIfNeeded(patch.newFileName) + (patch.newHeader ? "	" + patch.newHeader : "")));
+  for (let i = 0; i < patch.hunks.length; i++) {
+    let hunk = patch.hunks[i], oldStart = hunk.oldLines === 0 ? hunk.oldStart - 1 : hunk.oldStart, newStart = hunk.newLines === 0 ? hunk.newStart - 1 : hunk.newStart;
+    ret.push("@@ -" + oldStart + "," + hunk.oldLines + " +" + newStart + "," + hunk.newLines + " @@");
+    for (let line of hunk.lines)
+      ret.push(line);
+  }
+  return ret.join(`
+`) + `
+`;
+}
+function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
+  if (typeof options == "function" && (options = { callback: options }), options?.callback) {
+    let { callback } = options;
+    structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, Object.assign(Object.assign({}, options), { callback: (patchObj) => {
+      callback(patchObj ? formatPatch(patchObj, options.headerOptions) : void 0);
+    } }));
+  } else {
+    let patchObj = structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options);
+    return patchObj ? formatPatch(patchObj, options?.headerOptions) : void 0;
+  }
+}
+function splitLines(text) {
+  let hasTrailingNl = text.endsWith(`
+`), result = text.split(`
+`).map((line) => line + `
+`);
+  return hasTrailingNl ? result.pop() : result.push(result.pop().slice(0, -1)), result;
+}
+
+// src/tools.ts
+var IGNORED_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".next", ".nuxt", ".svelte-kit", "coverage", ".venv", "venv", "__pycache__", ".turbo", ".cache", "Pods", "DerivedData"]), SECRET = /^(\.env(\..+)?|\.envrc|\.dev\.vars|\.netrc|\.git-credentials|\.npmrc|\.pypirc|.*\.(pem|key|p12|pfx|keystore|jks|tfvars|tfstate)|id_(rsa|dsa|ecdsa|ed25519)(\.pub)?|credentials(\.json)?|.*service[-_]?account.*\.json|.*-credentials\.json)$/i, SECRET_OK = /^\.env\.(example|sample|template)$/i, MAX_READ = 1e5, MAX_LIST = 400, MAX_OUTPUT = 12e3, Workspace = class {
+  root;
+  constructor(root) {
+    this.root = realpathSync(root);
+  }
+  /** Resolve a project-relative path, refusing anything outside the root (incl. via symlinks) and secret files. */
+  resolve(path) {
+    if (typeof path != "string" || path.trim() === "") throw new Error("path is required");
+    let p = path.trim();
+    if (isAbsolute(p)) throw new Error(`${p} is outside the project`);
+    let abs = resolve(this.root, p);
+    if (abs !== this.root && !abs.startsWith(this.root + sep)) throw new Error(`${p} is outside the project`);
+    let cur = this.root;
+    for (let seg of relative(this.root, abs).split(sep).filter(Boolean)) {
+      cur = join2(cur, seg);
+      let info;
+      try {
+        info = lstatSync(cur);
+      } catch {
+        break;
+      }
+      if (info.isSymbolicLink()) {
+        let real;
+        try {
+          real = realpathSync(cur);
+        } catch {
+          throw new Error(`${p} goes through a broken symlink; refusing`);
+        }
+        if (real !== this.root && !real.startsWith(this.root + sep)) throw new Error(`${p} is outside the project`);
+      }
+    }
+    let name = basename(abs);
+    if (SECRET.test(name) && !SECRET_OK.test(name)) throw new Error(`${p} looks like a secret file; flint does not read or change it`);
+    return abs;
+  }
+  rel(abs) {
+    return relative(this.root, abs) || ".";
+  }
+  async listFiles(path = ".") {
+    let base = this.resolve(path), files;
+    try {
+      files = execFileSync("git", ["ls-files", "--cached", "--others", "--exclude-standard", "--", this.rel(base)], {
+        cwd: this.root,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        maxBuffer: 16 * 1024 * 1024
+      }).split(`
+`).filter(Boolean);
+    } catch {
+      files = [], await this.walk(base, files);
+    }
+    return files.sort(), files.slice(0, MAX_LIST).join(`
+`) + (files.length > MAX_LIST ? `
+\u2026 ${files.length - MAX_LIST} more files` : "") || "(empty)";
+  }
+  async walk(dir, out) {
+    if (!(out.length > 5e3))
+      for (let entry of await readdir(dir, { withFileTypes: !0 }))
+        entry.isDirectory() ? IGNORED_DIRS.has(entry.name) || await this.walk(join2(dir, entry.name), out) : entry.isFile() && out.push(this.rel(join2(dir, entry.name)));
+  }
+  async readFile(path, start, end) {
+    let abs = this.resolve(path), info = await stat(abs);
+    if (!info.isFile()) throw new Error(`${path} is not a file`);
+    let buf = await readFile(abs);
+    if (buf.subarray(0, 8e3).includes(0)) return `[binary file, ${info.size} bytes]`;
+    let lines = buf.toString("utf8").split(`
+`);
+    lines.at(-1) === "" && lines.pop();
+    let from = Math.max(1, start ?? 1), to = Math.min(lines.length, end ?? lines.length), out = "";
+    for (let i = from; i <= to; i++) {
+      let line = `${i}	${lines[i - 1]}`;
+      if (out.length + line.length > MAX_READ) {
+        out += `
+[truncated at line ${i - 1} of ${lines.length}; read more with start_line]`;
+        break;
+      }
+      out += (out ? `
+` : "") + line;
+    }
+    return out;
+  }
+  async search(pattern, path = ".") {
+    let re;
+    try {
+      re = new RegExp(pattern);
+    } catch {
+      throw new Error("invalid regular expression");
+    }
+    let files = (await this.listFiles(path)).split(`
+`).filter((f) => f && !f.startsWith("\u2026 ")), hits = [];
+    for (let f of files) {
+      if (hits.length >= 200) break;
+      let text;
+      try {
+        let abs = this.resolve(f);
+        if ((await stat(abs)).size > 4e5) continue;
+        let buf = await readFile(abs);
+        if (buf.subarray(0, 8e3).includes(0)) continue;
+        text = buf.toString("utf8");
+      } catch {
+        continue;
+      }
+      text.split(`
+`).forEach((line, i) => {
+        hits.length < 200 && re.test(line) && hits.push(`${f}:${i + 1}:${line.slice(0, 300)}`);
+      });
+    }
+    return hits.join(`
+`) || "No matches.";
+  }
+  /** Prepare a file change and its diff. Nothing is written until apply(). */
+  async plan(tool, args) {
+    let abs = this.resolve(args.path), path = this.rel(abs), before = existsSync2(abs) ? await readFile(abs, "utf8") : null, after;
+    if (tool === "write_file") {
+      if (typeof args.content != "string") throw new Error("content is required");
+      after = args.content;
+    } else {
+      if (before === null) throw new Error(`${path} does not exist`);
+      let oldText = args.old_text, newText = args.new_text;
+      if (typeof oldText != "string" || oldText === "" || typeof newText != "string") throw new Error("old_text and new_text are required");
+      let count = before.split(oldText).length - 1;
+      if (count === 0) throw new Error(`old_text not found in ${path}`);
+      if (count > 1) throw new Error(`old_text matches ${count} times in ${path}; include more context`);
+      after = before.replace(oldText, () => newText);
+    }
+    let diff = createTwoFilesPatch(`a/${path}`, `b/${path}`, before ?? "", after, "", "", { context: 3 });
+    return {
+      path,
+      diff,
+      created: before === null,
+      apply: async () => {
+        await mkdir(dirname(abs), { recursive: !0 }), await writeFile(abs, after);
+      }
+    };
+  }
+  runCommand(command, timeoutMs = 12e4) {
+    return new Promise((resolvePromise) => {
+      let child = spawn("/bin/sh", ["-c", command], { cwd: this.root, detached: !0, env: { ...process.env, FORCE_COLOR: "0", CI: "1" } }), head = "", tail = "", dropped = 0, take = (chunk) => {
+        let s = chunk.toString("utf8");
+        if (head.length < 4e3) {
+          let room = 4e3 - head.length;
+          head += s.slice(0, room), tail += s.slice(room);
+        } else tail += s;
+        tail.length > 8e3 && (dropped += tail.length - 8e3, tail = tail.slice(-8e3));
+      };
+      child.stdout.on("data", take), child.stderr.on("data", take);
+      let timedOut = !1, timer = setTimeout(() => {
+        timedOut = !0;
+        try {
+          process.kill(-child.pid, "SIGKILL");
+        } catch {
+          child.kill("SIGKILL");
+        }
+      }, timeoutMs);
+      child.on("close", (code) => {
+        clearTimeout(timer);
+        let body = head + (dropped ? `
+[\u2026 ${dropped} characters omitted \u2026]
+` : "") + tail, status = timedOut ? `[timed out after ${Math.round(timeoutMs / 1e3)}s]` : `[exit code ${code}]`;
+        resolvePromise(`${body.slice(0, MAX_OUTPUT)}
+${status}`.trim());
+      }), child.on("error", (err) => {
+        clearTimeout(timer), resolvePromise(`[could not run command: ${err.message}]`);
+      });
+    });
+  }
+};
+
+// src/ui.ts
+var import_picocolors = __toESM(require_picocolors(), 1);
+function sanitize(text) {
+  return text.replace(/\x1b\][^\x07\x1b]*(\x07|\x1b\\)?/g, "").replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "").replace(/\x1b[@-Z\\-_]/g, "").replace(/[\x00-\x08\x0b-\x1f\x7f-\x9f]/g, "");
+}
+var truecolor = /truecolor|24bit/i.test(process.env.COLORTERM ?? "") && import_picocolors.default.isColorSupported, FIRE = [
+  [123, 47, 247],
+  [232, 51, 107],
+  [255, 122, 26],
+  [255, 194, 74]
+];
+function fire(text) {
+  if (!truecolor) return import_picocolors.default.bold(import_picocolors.default.yellow(text));
+  let n = Math.max(1, text.length - 1);
+  return [...text].map((ch, i) => {
+    let t = i / n * (FIRE.length - 1), a = FIRE[Math.floor(t)], b = FIRE[Math.min(FIRE.length - 1, Math.floor(t) + 1)], f = t - Math.floor(t), [r, g, bl] = a.map((v, k) => Math.round(v + (b[k] - v) * f));
+    return `\x1B[1;38;2;${r};${g};${bl}m${ch}\x1B[0m`;
+  }).join("");
+}
+var ember = (s) => truecolor ? `\x1B[38;2;255;122;26m${s}\x1B[0m` : import_picocolors.default.yellow(s), crimson = (s) => truecolor ? `\x1B[38;2;232;51;107m${s}\x1B[0m` : import_picocolors.default.magenta(s), dim = import_picocolors.default.dim, bold = import_picocolors.default.bold;
+function banner(version, lines) {
+  console.log(), console.log(`  ${ember("\u2726")} ${fire("flintmaker")}  ${dim(`v${version}`)}`);
+  for (let l of lines) console.log(`  ${dim(l)}`);
+  console.log();
+}
+var MarkdownStream = class {
+  buf = "";
+  inCode = !1;
+  started = !1;
+  write(raw) {
+    let text = sanitize(raw);
+    this.started || (process.stdout.write(`
+`), this.started = !0), this.buf += text;
+    let nl;
+    for (; (nl = this.buf.indexOf(`
+`)) >= 0; )
+      this.line(this.buf.slice(0, nl)), this.buf = this.buf.slice(nl + 1);
+  }
+  end() {
+    this.buf && this.line(this.buf), this.buf = "", this.started && process.stdout.write(`
+`), this.started = !1, this.inCode = !1;
+  }
+  line(l) {
+    if (/^\s*```/.test(l)) {
+      this.inCode = !this.inCode, process.stdout.write(dim(this.inCode ? `  \u250C\u2500 ${l.replace(/^\s*```/, "") || "code"}` : "  \u2514\u2500") + `
+`);
+      return;
+    }
+    if (this.inCode) return void process.stdout.write(`  ${dim("\u2502")} ${import_picocolors.default.cyan(l)}
+`);
+    let out = l.replace(/`([^`]+)`/g, (_, c) => import_picocolors.default.cyan(c)).replace(/\*\*([^*]+)\*\*/g, (_, b) => bold(b));
+    /^#{1,3} /.test(l) ? out = bold(ember(l.replace(/^#{1,3} /, ""))) : /^\s*[-*] /.test(l) && (out = out.replace(/^(\s*)[-*] /, (_, s) => `${s}${ember("\u2022")} `)), process.stdout.write(`  ${out}
+`);
+  }
+}, Spinner = class {
+  timer;
+  i = 0;
+  start(label = "thinking") {
+    if (!process.stdout.isTTY || this.timer) return;
+    let frames = ["\u2726", "\u2727", "\u22C6", "\u2727"];
+    this.timer = setInterval(() => {
+      process.stdout.write(`\r  ${ember(frames[this.i++ % frames.length])} ${dim(label + "\u2026")}   `);
+    }, 120);
+  }
+  stop() {
+    this.timer && (clearInterval(this.timer), this.timer = void 0, process.stdout.write("\r\x1B[2K"));
+  }
+};
+function printDiff(diff) {
+  let lines = sanitize(diff).split(`
+`).slice(2);
+  for (let l of lines)
+    l.startsWith("===") || l.startsWith("Index:") || (l.startsWith("+++") || l.startsWith("---") ? console.log(dim(`  ${l}`)) : l.startsWith("+") ? console.log(import_picocolors.default.green(`  ${l}`)) : l.startsWith("-") ? console.log(import_picocolors.default.red(`  ${l}`)) : l.startsWith("@@") ? console.log(import_picocolors.default.cyan(`  ${l}`)) : console.log(dim(`  ${l}`)));
+}
+
+// src/index.ts
+var VERSION = "0.1.0", HELP = `
+  ${bold("flint")} \u2014 the FlintMaker coding agent for your terminal
+
+  ${bold("Usage")}
+    flint                 start an interactive session in this folder
+    flint "task"          do one task, then exit
+    flint login           connect this computer to your FlintMaker account
+    flint logout          disconnect
+    flint whoami          show account and credits
+
+  ${bold("Options")}
+    --smart               use the smart model (paid plans, more credits)
+    --yes                 approve every change and command (careful!)
+    --help, --version
+
+  ${bold("In a session")}
+    /help  /credits  /smart  /standard  /clear  /exit
+`;
+function parseArgs(argv) {
+  let flags = new Set(argv.filter((a) => a.startsWith("--"))), rest = argv.filter((a) => !a.startsWith("--"));
+  return { flags, rest };
+}
+function openBrowser(url) {
+  if (!/^https:\/\/[\w.-]+\/device(\?[\w=&%-]*)?$/.test(url)) return;
+  let [cmd, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["rundll32", ["url.dll,FileProtocolHandler", url]] : ["xdg-open", [url]];
+  try {
+    spawn2(cmd, args, { stdio: "ignore", detached: !0 }).unref();
+  } catch {
+  }
+}
+var shortPath = (p) => p.startsWith(homedir2()) ? `~${p.slice(homedir2().length)}` : p, creditsLine = (u) => u.creditsLeftToday !== null ? `${u.creditsLeftToday} credits left today \xB7 ${u.creditsLeftMonth} this month` : `${u.creditsLeftMonth.toLocaleString("en-US")} of ${u.monthlyCredits.toLocaleString("en-US")} credits left`;
+async function login() {
+  let client = new Client(apiBase(null));
+  console.log();
+  let result = await client.deviceLogin((code, url) => {
+    console.log(`  ${ember("\u2726")} Your code: ${bold(code)}`), console.log(`  ${dim("Opening")} ${url}`), console.log(`  ${dim("Approve it in the browser. Waiting\u2026")}`), openBrowser(url);
+  });
+  saveAuth({ token: result.token, email: result.user.email, api: client.base }), console.log(`
+  ${ember("\u2713")} Signed in as ${bold(result.user.email)}. Run ${bold("flint")} in any project folder.
+`);
+}
+async function main() {
+  let { flags, rest } = parseArgs(process.argv.slice(2));
+  if (flags.has("--version")) return console.log(VERSION);
+  if (flags.has("--help") || rest[0] === "help") return console.log(HELP);
+  if (rest[0] === "login") return login();
+  if (rest[0] === "logout")
+    return clearAuth(), console.log(`
+  Signed out. ${dim("Disconnect old terminals any time on your account page.")}
+`);
+  if (!loadAuth() && (console.log(`
+  ${ember("\u2726")} Welcome to flint. First, connect your FlintMaker account:
+`), await login(), rest.length === 0 && !process.stdin.isTTY))
+    return;
+  let saved = loadAuth(), base = apiBase(saved);
+  if (base !== saved.api) throw new FlintError(`This token belongs to ${saved.api}. Run flint login to use ${base}.`);
+  let client = new Client(base, saved.token);
+  if (rest[0] === "whoami") {
+    let me2 = await client.me();
+    return console.log(`
+  ${bold(me2.user.email)} \xB7 ${me2.user.plan} \xB7 ${creditsLine(me2.usage)}
+`);
+  }
+  let ws = new Workspace(process.cwd()), model = flags.has("--smart") ? "smart" : "standard", autoYes = flags.has("--yes"), rl = process.stdin.isTTY && process.stdout.isTTY ? createInterface({ input: process.stdin, output: process.stdout, terminal: !0 }) : null, alwaysChanges = autoYes, alwaysCommands = autoYes, controller, lastUsage = null, ask = async (q, defaultYes) => {
+    if (!rl) return "n";
+    let a = (await rl.question(q)).trim().toLowerCase();
+    return a === "" ? defaultYes ? "y" : "n" : a === "a" ? "a" : a === "y" || a === "yes" ? "y" : "n";
+  }, md = new MarkdownStream(), spinner = new Spinner(), ui = {
+    onDelta: (t) => {
+      spinner.stop(), md.write(t);
+    },
+    onToolStart: (name, detail) => {
+      spinner.stop(), md.end();
+      let d = sanitize(detail);
+      console.log(`  ${ember("\u23FA")} ${bold(name.replace("_", " "))} ${dim(name === "run_command" || d.length <= 80 ? d : `${d.slice(0, 77)}\u2026`)}`);
+    },
+    onToolResult: (_name, ok, summary) => {
+      ok || console.log(`    ${crimson("\u2717")} ${dim(sanitize(summary ?? "failed"))}`), spinner.start("working");
+    },
+    approveChange: async (change) => {
+      if (spinner.stop(), printDiff(change.diff), alwaysChanges) return !0;
+      let a = await ask(`  ${change.created ? "Create" : "Apply changes to"} ${bold(sanitize(change.path))}? ${dim("[Y]es / [n]o / [a]lways this session")} `, !0);
+      return a === "a" && (alwaysChanges = !0), a !== "n";
+    },
+    approveCommand: async (command) => {
+      if (spinner.stop(), alwaysCommands) return !0;
+      let a = await ask(`  Run ${bold(JSON.stringify(sanitize(command)))}? ${dim("[y]es / [N]o / [a]lways this session")} `, !1);
+      return a === "a" && (alwaysCommands = !0), a !== "n";
+    }
+  }, step = client.stepper(
+    () => model,
+    () => controller?.signal,
+    (_credits, usage) => {
+      lastUsage = usage;
+    }
+  ), history = [], run = async (task) => {
+    controller = new AbortController(), spinner.start();
+    try {
+      history = await runAgent(ws, [...history, { role: "user", content: task }], step, ui);
+    } catch (e) {
+      spinner.stop(), md.end(), e.name === "AbortError" ? console.log(dim(`
+  Stopped.`)) : console.log(`
+  ${crimson("\u2717")} ${e.message}`), e instanceof FlintError && e.reason === "signed_out" && clearAuth();
+    } finally {
+      spinner.stop(), md.end(), controller = void 0;
+    }
+    lastUsage && console.log(dim(`  ${creditsLine(lastUsage)}`));
+  };
+  if (rest.length > 0) {
+    await run(rest.join(" ")), rl?.close();
+    return;
+  }
+  let me = await client.me().catch((e) => {
+    throw e;
+  });
+  if (lastUsage = me.usage, banner(VERSION, [`${me.user.email} \xB7 ${me.user.plan} plan \xB7 ${creditsLine(me.usage)}`, shortPath(ws.root), "Describe a task. /help for commands, Ctrl+C to stop."]), !rl) throw new FlintError('Interactive mode needs a terminal. Pass a task: flint "fix the failing test"');
+  for (rl.on("SIGINT", () => {
+    controller ? controller.abort() : (console.log(dim(`
+  Bye.`)), process.exit(0));
+  }); ; ) {
+    let line = (await rl.question(`${crimson("\u276F")} `)).trim();
+    if (line) {
+      if (line === "/exit" || line === "/quit") break;
+      if (line === "/help") {
+        console.log(HELP);
+        continue;
+      }
+      if (line === "/clear") {
+        history = [], console.log(dim("  New conversation."));
+        continue;
+      }
+      if (line === "/smart" || line === "/standard") {
+        model = line.slice(1), console.log(dim(`  Model: ${model}`));
+        continue;
+      }
+      if (line === "/credits") {
+        let u = (await client.me()).usage;
+        console.log(dim(`  ${creditsLine(u)}`));
+        continue;
+      }
+      await run(line);
+    }
+  }
+  rl.close();
+}
+main().catch((e) => {
+  console.error(`
+  ${crimson("\u2717")} ${e.message}
+`), process.exit(1);
+});

package/package.json

@@ -1,6 +1,33 @@
 {
   "name": "flintmaker",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "flint — the FlintMaker AI coding agent for your terminal.",
+  "license": "UNLICENSED",
+  "author": "PT Jiji Labs Digital",
+  "homepage": "https://flintmaker.com",
+  "type": "module",
+  "bin": {
+    "flint": "dist/flint.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "esbuild src/index.ts --bundle --platform=node --format=esm --target=node20 --outfile=dist/flint.js --banner:js='#!/usr/bin/env node' --minify-syntax",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@types/diff": "^7.0.2",
+    "@types/node": "^22.20.5",
+    "diff": "^9.0.0",
+    "esbuild": "^0.28.2",
+    "picocolors": "^1.1.1",
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.4"
+  }
+}