@balise.dev/cli 0.1.3 → 0.2.0

package/README.md

@@ -61,6 +61,25 @@ Tokens are written to a plaintext JSON file with restrictive permissions:
 
 If you need OS-keychain-grade protection, set `BALISE_CREDENTIALS_FILE` to a path on an encrypted volume, or feed `BALISE_TOKEN` from your existing secret manager.
 
+## Build-time policy patterns
+
+`balise init` ships with two compile-time pattern lists baked into the bundle via tsup `define`:
+
+| Env var (build) | Used for | SSOT contract |
+|---|---|---|
+| `BALISE_BAN_PATTERNS` | Directories the extractor will never read (`.git`, `node_modules`, …). Displayed as 🔒 read-only in the `balise init` ignore tree. | **MUST** match the worker-side env var of the same name (read by `balise_mcp/diff_loc.py`). Changing one without the other breaks the SSOT verrou between credit estimate and what the agent sees. |
+| `BALISE_DEFAULT_PATTERNS` | Globs pre-checked-out in the ignore tree as a sensible default (lockfiles, minified assets, snapshots, …). User remains free to scan them — they just pay the tokens. | CLI-only. |
+
+Override at build time:
+
+```bash
+BALISE_BAN_PATTERNS=.git,node_modules,dist \
+BALISE_DEFAULT_PATTERNS='*.lock,*.min.js' \
+  npm run build
+```
+
+The defaults baked when these env vars are unset are visible in `cli/tsup.config.ts`.
+
 ## Dev
 
 ```bash

package/dist/index.js

@@ -548,8 +548,8 @@ var ApiClient = class {
     }
     return res.json();
   }
-  async getJson(path5) {
-    const url = joinUrl(this.opts.apiUrl, path5);
+  async getJson(path7) {
+    const url = joinUrl(this.opts.apiUrl, path7);
     return this.withAuth(async (headers) => {
       const { statusCode, body } = await wrapNetwork(() => request2(url, {
         method: "GET",
@@ -564,8 +564,8 @@ var ApiClient = class {
       };
     });
   }
-  async postJson(path5, payload) {
-    const url = joinUrl(this.opts.apiUrl, path5);
+  async postJson(path7, payload) {
+    const url = joinUrl(this.opts.apiUrl, path7);
     return this.withAuth(async (headers) => {
       const { statusCode, body } = await wrapNetwork(() => request2(url, {
         method: "POST",
@@ -589,10 +589,10 @@ var ApiClient = class {
    * metadata travels in the query string. Matches the FastAPI contract
    * `POST /v1/repos/:owner/:slug/sync?commit_sha=...&branch=...`.
    */
-  async uploadBundle(path5, opts) {
+  async uploadBundle(path7, opts) {
     await this.ensureFreshToken();
     const qs = new URLSearchParams(opts.query).toString();
-    const url = `${joinUrl(this.opts.apiUrl, path5)}${qs ? `?${qs}` : ""}`;
+    const url = `${joinUrl(this.opts.apiUrl, path7)}${qs ? `?${qs}` : ""}`;
     return this.withAuth(async (headers) => {
       const { statusCode, body } = await wrapNetwork(() => request2(url, {
         method: "POST",
@@ -622,10 +622,10 @@ var ApiClient = class {
    * `withAuth` for the 401-then-retry plumbing. Non-401 statuses are
    * returned to the caller verbatim — `withAuth` only treats 401 specially.
    */
-  async uploadBundleRaw(path5, opts) {
+  async uploadBundleRaw(path7, opts) {
     await this.ensureFreshToken();
     const qs = new URLSearchParams(opts.query).toString();
-    const url = `${joinUrl(this.opts.apiUrl, path5)}${qs ? `?${qs}` : ""}`;
+    const url = `${joinUrl(this.opts.apiUrl, path7)}${qs ? `?${qs}` : ""}`;
     let tokens = await loadTokens();
     if (!tokens) throw new NotAuthenticatedError();
     const exec = async (token) => {
@@ -648,8 +648,8 @@ var ApiClient = class {
     throw new NotAuthenticatedError();
   }
 };
-function joinUrl(base, path5) {
-  return `${base.replace(/\/$/, "")}${path5.startsWith("/") ? path5 : `/${path5}`}`;
+function joinUrl(base, path7) {
+  return `${base.replace(/\/$/, "")}${path7.startsWith("/") ? path7 : `/${path7}`}`;
 }
 
 // src/config.ts
@@ -734,8 +734,8 @@ account_id  : ${me.account_id}
 }
 
 // src/commands/init.ts
-import path3 from "path";
-import React2 from "react";
+import path5 from "path";
+import React3 from "react";
 import { render } from "ink";
 
 // src/git.ts
@@ -921,13 +921,14 @@ function normalizeSlug(raw) {
 }
 function InitPicker(props) {
   const { exit } = useApp();
-  const [field, setField] = useState("slug");
+  const currentMatches = props.currentRepoId !== void 0 && props.repos.some((r) => r.id === props.currentRepoId);
+  const [field, setField] = useState(currentMatches ? "link" : "slug");
   const [slug, setSlug] = useState(normalizeSlug(props.defaultSlug));
   const [ownerId, setOwnerId] = useState(
     props.ownerships[0]?.id
   );
   const [repoId, setRepoId] = useState(
-    props.repos[0]?.id
+    currentMatches ? props.currentRepoId : props.repos[0]?.id
   );
   const submit = () => {
     if (field === "link") {
@@ -964,7 +965,7 @@ function InitPicker(props) {
     value: o.id
   }));
   const repoOptions = props.repos.map((r) => ({
-    label: `${r.owner_login}/${r.slug}`,
+    label: r.id === props.currentRepoId ? `${r.owner_login}/${r.slug} (current)` : `${r.owner_login}/${r.slug}`,
     value: r.id
   }));
   return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React.createElement(Text, { bold: true }, "Balise \u2014 link or create a repo"), /* @__PURE__ */ React.createElement(Box, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React.createElement(Text, { color: field === "slug" ? "cyan" : "gray" }, field === "slug" ? "\u25B8 " : "  ", "New repo slug"), /* @__PURE__ */ React.createElement(Box, { marginLeft: 2 }, /* @__PURE__ */ React.createElement(
@@ -992,6 +993,550 @@ function InitPicker(props) {
   ) : /* @__PURE__ */ React.createElement(Text, { dimColor: true }, "tab to browse"))), /* @__PURE__ */ React.createElement(Box, { marginTop: 1 }, /* @__PURE__ */ React.createElement(Text, { dimColor: true }, "Tab: next field \xB7 \u2191/\u2193: navigate \xB7 Enter: confirm \xB7 Esc: cancel")));
 }
 
+// src/scan.ts
+import { isUtf8 } from "buffer";
+import { execFile as execFileCb } from "child_process";
+import { promises as fs3 } from "fs";
+import path3 from "path";
+import { promisify } from "util";
+import picomatch from "picomatch";
+
+// src/policy.ts
+var BAN_PATTERNS = [
+  ".git",
+  "node_modules",
+  "__pycache__",
+  ".venv",
+  "venv",
+  "dist",
+  "build",
+  ".next",
+  ".turbo",
+  ".cache",
+  "target"
+];
+var DEFAULT_PATTERNS = [
+  "*.lock",
+  "package-lock.json",
+  "yarn.lock",
+  "pnpm-lock.yaml",
+  "*.min.js",
+  "*.min.css",
+  "*.svg",
+  "*.png",
+  "*.jpg",
+  "*.jpeg",
+  "*.gif",
+  "*.ico",
+  "*.woff",
+  "*.woff2",
+  "*.snap",
+  "CHANGELOG.md"
+];
+var LOC_THRESHOLD = 2500;
+var MAX_FILE_BYTES = 1e6;
+
+// src/scan.ts
+var execFile = promisify(execFileCb);
+var BAN_DIRS = new Set(BAN_PATTERNS);
+var matchesDefault = DEFAULT_PATTERNS.length > 0 ? picomatch([...DEFAULT_PATTERNS], { dot: true, matchBase: true }) : () => false;
+function countLines(buf) {
+  let count = 0;
+  for (let i = 0; i < buf.length; i++) {
+    if (buf[i] === 10) count++;
+  }
+  if (buf.length > 0 && buf[buf.length - 1] !== 10) count++;
+  return count;
+}
+async function scanFile(absPath) {
+  let stat;
+  try {
+    stat = await fs3.stat(absPath);
+  } catch {
+    return null;
+  }
+  if (stat.size > MAX_FILE_BYTES) return null;
+  const buf = await fs3.readFile(absPath);
+  if (!isUtf8(buf)) return null;
+  return countLines(buf);
+}
+async function listTrackedFiles(cwd) {
+  try {
+    const { stdout } = await execFile("git", ["ls-files", "-z"], {
+      cwd,
+      maxBuffer: 50 * 1024 * 1024
+    });
+    return new Set(stdout.split("\0").filter((l) => l.length > 0));
+  } catch {
+    return null;
+  }
+}
+async function walk(absDir, relDir, out, tracked) {
+  let dirents;
+  try {
+    dirents = await fs3.readdir(absDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const d of dirents) {
+    const relPath = relDir ? `${relDir}/${d.name}` : d.name;
+    const absPath = path3.join(absDir, d.name);
+    if (d.isDirectory()) {
+      if (BAN_DIRS.has(d.name)) {
+        out.push({
+          path: relPath,
+          locCount: 0,
+          isBan: true,
+          isDefault: false,
+          isLarge: false
+        });
+        continue;
+      }
+      await walk(absPath, relPath, out, tracked);
+    } else if (d.isFile()) {
+      if (tracked !== null && !tracked.has(relPath)) continue;
+      const locCount = await scanFile(absPath);
+      if (locCount === null) continue;
+      out.push({
+        path: relPath,
+        locCount,
+        isBan: false,
+        isDefault: matchesDefault(relPath),
+        isLarge: locCount > LOC_THRESHOLD
+      });
+    }
+  }
+}
+async function scan(cwd) {
+  const tracked = await listTrackedFiles(cwd);
+  const out = [];
+  await walk(cwd, "", out, tracked);
+  return out;
+}
+
+// src/baliseignore.ts
+import { promises as fs4 } from "fs";
+import path4 from "path";
+var FILENAME2 = ".baliseignore";
+var HEADER = [
+  "# Generated by balise init.",
+  "# balise init will overwrite this file on next run.",
+  ""
+].join("\n");
+async function readBaliseignore(cwd) {
+  const file = path4.join(cwd, FILENAME2);
+  let raw;
+  try {
+    raw = await fs4.readFile(file, "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT") return /* @__PURE__ */ new Set();
+    throw err;
+  }
+  const out = /* @__PURE__ */ new Set();
+  for (const line of raw.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    out.add(trimmed);
+  }
+  return out;
+}
+async function writeBaliseignore(cwd, patterns) {
+  const sorted = [...new Set(patterns)].filter((p) => p.length > 0).sort((a, b) => a.localeCompare(b));
+  const body = sorted.length > 0 ? sorted.join("\n") + "\n" : "";
+  await fs4.writeFile(path4.join(cwd, FILENAME2), HEADER + body, "utf-8");
+}
+
+// src/ui/IgnoreTree.tsx
+import React2, { useMemo, useState as useState2 } from "react";
+import { Box as Box2, Text as Text2, useApp as useApp2, useInput as useInput2 } from "ink";
+function buildTree(entries) {
+  const root = {
+    path: "",
+    name: ".",
+    isDir: true,
+    isBan: false,
+    locCount: 0,
+    isDefault: false,
+    isLarge: false,
+    children: [],
+    parent: null
+  };
+  const dirMap = /* @__PURE__ */ new Map();
+  dirMap.set("", root);
+  const ensureDir = (dirPath) => {
+    if (!dirPath) return root;
+    const existing = dirMap.get(dirPath);
+    if (existing) return existing;
+    const parts = dirPath.split("/");
+    const name = parts[parts.length - 1];
+    const parentPath = parts.slice(0, -1).join("/");
+    const parent = ensureDir(parentPath);
+    const node = {
+      path: dirPath,
+      name,
+      isDir: true,
+      isBan: false,
+      locCount: 0,
+      isDefault: false,
+      isLarge: false,
+      children: [],
+      parent
+    };
+    parent.children.push(node);
+    dirMap.set(dirPath, node);
+    return node;
+  };
+  const sorted = [...entries].sort((a, b) => a.path.localeCompare(b.path));
+  for (const e of sorted) {
+    const parts = e.path.split("/");
+    const name = parts[parts.length - 1];
+    const parentPath = parts.slice(0, -1).join("/");
+    const parent = ensureDir(parentPath);
+    const node = {
+      path: e.path,
+      name,
+      isDir: e.isBan,
+      // ban entries from scan() are directories by construction
+      isBan: e.isBan,
+      locCount: e.locCount,
+      isDefault: e.isDefault,
+      isLarge: e.isLarge,
+      children: [],
+      parent
+    };
+    parent.children.push(node);
+    if (e.isBan) dirMap.set(e.path, node);
+  }
+  const sortChildren = (n) => {
+    n.children.sort((a, b) => {
+      if (a.isDir !== b.isDir) return a.isDir ? -1 : 1;
+      return a.name.localeCompare(b.name);
+    });
+    for (const c of n.children) sortChildren(c);
+  };
+  sortChildren(root);
+  return root;
+}
+function collectDescendantFiles(node) {
+  const out = [];
+  const recurse = (n) => {
+    if (!n.isDir && !n.isBan) out.push(n.path);
+    for (const c of n.children) recurse(c);
+  };
+  recurse(node);
+  return out;
+}
+function flattenVisible(root, expanded) {
+  const out = [];
+  const recurse = (node, depth) => {
+    if (node !== root) {
+      out.push({ node, depth });
+    }
+    if (node === root || node.isDir && !node.isBan && expanded.has(node.path)) {
+      for (const c of node.children) recurse(c, depth + 1);
+    }
+  };
+  recurse(root, -1);
+  return out;
+}
+function dirAllIncluded(node, excluded) {
+  const files = collectDescendantFiles(node);
+  if (files.length === 0) return true;
+  return files.every((f) => !excluded.has(f));
+}
+function computeInitialExcluded(scan2, current) {
+  const out = /* @__PURE__ */ new Set();
+  const scanPaths = /* @__PURE__ */ new Set();
+  for (const e of scan2) {
+    if (e.isBan) continue;
+    scanPaths.add(e.path);
+    if (e.isDefault || e.isLarge) out.add(e.path);
+  }
+  for (const p of current) {
+    if (!scanPaths.has(p)) out.add(p);
+  }
+  return out;
+}
+function computeDiff(current, excluded) {
+  const all = /* @__PURE__ */ new Set([...current, ...excluded]);
+  return [...all].sort((a, b) => a.localeCompare(b)).map((pattern) => {
+    const inCurrent = current.has(pattern);
+    const inExcluded = excluded.has(pattern);
+    const kind = inCurrent && inExcluded ? "unchanged" : inExcluded ? "added" : "removed";
+    return { pattern, kind };
+  });
+}
+var VIEWPORT_HEIGHT = 18;
+function IgnoreTree(props) {
+  const { exit } = useApp2();
+  const root = useMemo(() => buildTree(props.scan), [props.scan]);
+  const [excluded, setExcluded] = useState2(
+    () => computeInitialExcluded(props.scan, props.currentBaliseignore)
+  );
+  const [expandedDirs, setExpandedDirs] = useState2(/* @__PURE__ */ new Set());
+  const [focus, setFocus] = useState2("tree");
+  const [treeCursor, setTreeCursor] = useState2("");
+  const [diffCursor, setDiffCursor] = useState2(0);
+  const [modalOpen, setModalOpen] = useState2(false);
+  const visible = useMemo(
+    () => flattenVisible(root, expandedDirs),
+    [root, expandedDirs]
+  );
+  const diff = useMemo(
+    () => computeDiff(props.currentBaliseignore, excluded),
+    [props.currentBaliseignore, excluded]
+  );
+  const treeIdx = useMemo(() => {
+    if (visible.length === 0) return -1;
+    const i = visible.findIndex((v) => v.node.path === treeCursor);
+    return i >= 0 ? i : 0;
+  }, [visible, treeCursor]);
+  const safeDiffIdx = diff.length === 0 ? -1 : Math.max(0, Math.min(diffCursor, diff.length - 1));
+  const stats = useMemo(() => {
+    let added = 0;
+    let removed = 0;
+    let unchanged = 0;
+    for (const p of excluded) {
+      if (props.currentBaliseignore.has(p)) unchanged++;
+      else added++;
+    }
+    for (const p of props.currentBaliseignore) {
+      if (!excluded.has(p)) removed++;
+    }
+    return { added, removed, unchanged };
+  }, [excluded, props.currentBaliseignore]);
+  const toggleFile = (path7) => {
+    setExcluded((prev) => {
+      const next = new Set(prev);
+      if (next.has(path7)) next.delete(path7);
+      else next.add(path7);
+      return next;
+    });
+  };
+  const toggleDir = (dirNode) => {
+    const descendants = collectDescendantFiles(dirNode);
+    if (descendants.length === 0) return;
+    const allIncluded = descendants.every((p) => !excluded.has(p));
+    setExcluded((prev) => {
+      const next = new Set(prev);
+      if (allIncluded) {
+        for (const p of descendants) next.add(p);
+      } else {
+        for (const p of descendants) next.delete(p);
+      }
+      return next;
+    });
+  };
+  useInput2((input, key) => {
+    if (modalOpen) {
+      if (input === "y" || input === "Y") {
+        props.onDone({
+          action: "save",
+          patterns: [...excluded].sort((a, b) => a.localeCompare(b))
+        });
+        exit();
+        return;
+      }
+      if (input === "n" || input === "N") {
+        setModalOpen(false);
+        return;
+      }
+      if (input === "q" || input === "Q" || key.escape) {
+        props.onDone({ action: "cancel", patterns: [] });
+        exit();
+        return;
+      }
+      return;
+    }
+    if (key.tab) {
+      setFocus((f) => f === "tree" ? "diff" : "tree");
+      return;
+    }
+    if (key.return) {
+      setModalOpen(true);
+      return;
+    }
+    if (key.escape || input === "q") {
+      setModalOpen(true);
+      return;
+    }
+    if (focus === "tree") {
+      if (key.downArrow) {
+        const i = Math.min(treeIdx + 1, visible.length - 1);
+        if (i >= 0) setTreeCursor(visible[i].node.path);
+        return;
+      }
+      if (key.upArrow) {
+        const i = Math.max(treeIdx - 1, 0);
+        if (i >= 0) setTreeCursor(visible[i].node.path);
+        return;
+      }
+      if (key.rightArrow) {
+        const cur = treeIdx >= 0 ? visible[treeIdx].node : null;
+        if (!cur || !cur.isDir || cur.isBan) return;
+        if (!expandedDirs.has(cur.path)) {
+          setExpandedDirs((s) => {
+            const next = new Set(s);
+            next.add(cur.path);
+            return next;
+          });
+        } else if (cur.children.length > 0) {
+          setTreeCursor(cur.children[0].path);
+        }
+        return;
+      }
+      if (key.leftArrow) {
+        const cur = treeIdx >= 0 ? visible[treeIdx].node : null;
+        if (!cur) return;
+        if (cur.isDir && !cur.isBan && expandedDirs.has(cur.path)) {
+          setExpandedDirs((s) => {
+            const next = new Set(s);
+            next.delete(cur.path);
+            return next;
+          });
+        } else if (cur.parent && cur.parent.path !== "") {
+          setTreeCursor(cur.parent.path);
+        }
+        return;
+      }
+      if (input === " ") {
+        const cur = treeIdx >= 0 ? visible[treeIdx].node : null;
+        if (!cur || cur.isBan) return;
+        if (cur.isDir) toggleDir(cur);
+        else toggleFile(cur.path);
+        return;
+      }
+    } else {
+      if (key.downArrow) {
+        setDiffCursor((c) => Math.min(c + 1, Math.max(diff.length - 1, 0)));
+        return;
+      }
+      if (key.upArrow) {
+        setDiffCursor((c) => Math.max(c - 1, 0));
+        return;
+      }
+      if (input === " ") {
+        if (safeDiffIdx < 0) return;
+        toggleFile(diff[safeDiffIdx].pattern);
+        return;
+      }
+    }
+  });
+  if (modalOpen) {
+    return /* @__PURE__ */ React2.createElement(ConfirmModal, { stats, excludedSize: excluded.size });
+  }
+  const treeStart = Math.max(
+    0,
+    Math.min(
+      treeIdx - Math.floor(VIEWPORT_HEIGHT / 2),
+      visible.length - VIEWPORT_HEIGHT
+    )
+  );
+  const treeWindow = visible.slice(
+    Math.max(treeStart, 0),
+    Math.max(treeStart, 0) + VIEWPORT_HEIGHT
+  );
+  const diffStart = Math.max(
+    0,
+    Math.min(
+      safeDiffIdx - Math.floor(VIEWPORT_HEIGHT / 2),
+      diff.length - VIEWPORT_HEIGHT
+    )
+  );
+  const diffWindow = diff.slice(
+    Math.max(diffStart, 0),
+    Math.max(diffStart, 0) + VIEWPORT_HEIGHT
+  );
+  const treeWindowStart = Math.max(treeStart, 0);
+  const diffWindowStart = Math.max(diffStart, 0);
+  return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React2.createElement(Text2, { bold: true }, "Balise \u2014 configure .baliseignore"), /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, "Tab: panel \xB7 \u2191/\u2193: nav \xB7 \u2192/\u2190: open/close \xB7 Space: toggle \xB7 Enter: save \xB7 Esc: cancel"), /* @__PURE__ */ React2.createElement(Box2, { marginTop: 1 }, /* @__PURE__ */ React2.createElement(
+    Box2,
+    {
+      flexDirection: "column",
+      width: "50%",
+      paddingRight: 1,
+      borderStyle: "round",
+      borderColor: focus === "tree" ? "cyan" : "gray"
+    },
+    /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: focus === "tree" ? "cyan" : void 0 }, "Files"),
+    treeWindow.length === 0 ? /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, "(no files)") : treeWindow.map((v, i) => /* @__PURE__ */ React2.createElement(
+      TreeRow,
+      {
+        key: v.node.path,
+        node: v.node,
+        depth: v.depth,
+        expanded: expandedDirs.has(v.node.path),
+        excluded,
+        isFocused: focus === "tree" && treeWindowStart + i === treeIdx
+      }
+    ))
+  ), /* @__PURE__ */ React2.createElement(
+    Box2,
+    {
+      flexDirection: "column",
+      width: "50%",
+      paddingLeft: 1,
+      borderStyle: "round",
+      borderColor: focus === "diff" ? "cyan" : "gray"
+    },
+    /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: focus === "diff" ? "cyan" : void 0 }, "Diff vs .baliseignore"),
+    diff.length === 0 ? /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, "(no changes)") : diffWindow.map((d, i) => /* @__PURE__ */ React2.createElement(
+      DiffRow,
+      {
+        key: d.pattern,
+        entry: d,
+        isFocused: focus === "diff" && diffWindowStart + i === safeDiffIdx
+      }
+    ))
+  )), /* @__PURE__ */ React2.createElement(Box2, { marginTop: 1 }, /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, stats.added > 0 || stats.removed > 0 ? `${stats.added} additions, ${stats.removed} removals` : "(no changes vs current .baliseignore)")));
+}
+function TreeRow(props) {
+  const { node, depth, expanded, excluded, isFocused } = props;
+  const indent = "  ".repeat(Math.max(depth, 0));
+  let label;
+  let dim = false;
+  if (node.isBan) {
+    label = `\u{1F512} ${node.name} [ban]`;
+    dim = true;
+  } else if (node.isDir) {
+    const allIncluded = dirAllIncluded(node, excluded);
+    const arrow = expanded ? "\u25BE" : "\u25B8";
+    const box = allIncluded ? "\u2611" : "\u2610";
+    label = `${arrow} ${box} ${node.name}/`;
+  } else {
+    const box = excluded.has(node.path) ? "\u2610" : "\u2611";
+    const loc = node.locCount > 0 ? ` (${node.locCount} LoC)` : "";
+    const flags = [];
+    if (node.isLarge) flags.push("large");
+    if (node.isDefault) flags.push("default");
+    const flagStr = flags.length > 0 ? ` [${flags.join(",")}]` : "";
+    label = `${box} ${node.name}${loc}${flagStr}`;
+  }
+  return /* @__PURE__ */ React2.createElement(Text2, { color: isFocused ? "cyan" : void 0, dimColor: dim }, isFocused ? "\u25B8 " : "  ", indent, label);
+}
+function DiffRow(props) {
+  const { entry, isFocused } = props;
+  const sigil = entry.kind === "added" ? "+" : entry.kind === "removed" ? "-" : " ";
+  const color = isFocused ? "cyan" : entry.kind === "added" ? "green" : entry.kind === "removed" ? "red" : void 0;
+  return /* @__PURE__ */ React2.createElement(Text2, { color }, isFocused ? "\u25B8 " : "  ", sigil, " ", entry.pattern);
+}
+function ConfirmModal(props) {
+  const { stats, excludedSize } = props;
+  return /* @__PURE__ */ React2.createElement(
+    Box2,
+    {
+      flexDirection: "column",
+      padding: 1,
+      borderStyle: "double",
+      borderColor: "cyan"
+    },
+    /* @__PURE__ */ React2.createElement(Text2, { bold: true }, "Save changes to .baliseignore?"),
+    /* @__PURE__ */ React2.createElement(Box2, { marginTop: 1, flexDirection: "row", gap: 2 }, /* @__PURE__ */ React2.createElement(Text2, { color: "green" }, "+", stats.added, " added"), /* @__PURE__ */ React2.createElement(Text2, { color: "red" }, "-", stats.removed, " removed"), /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, stats.unchanged, " unchanged")),
+    /* @__PURE__ */ React2.createElement(Box2, { marginTop: 1 }, /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, excludedSize, " total patterns in resulting file")),
+    /* @__PURE__ */ React2.createElement(Box2, { marginTop: 1 }, /* @__PURE__ */ React2.createElement(Text2, null, "[y] Confirm   [n] Back to edit   [q/Esc] Cancel without saving"))
+  );
+}
+
 // src/commands/init.ts
 async function runInit(opts) {
   const cwd = opts.cwd ?? process.cwd();
@@ -1015,6 +1560,13 @@ async function runInit(opts) {
     }
     throw err;
   }
+  const existingConfig = await readConfig(cwd);
+  if (existingConfig) {
+    process.stdout.write(
+      `Re-configuring ${existingConfig.repo.owner_login}/${existingConfig.repo.slug}.
+`
+    );
+  }
   const apiUrl = DEFAULT_API_URL;
   const client = new ApiClient({
     apiUrl,
@@ -1043,13 +1595,14 @@ async function runInit(opts) {
   const sortedRepos = [...repos].sort(
     (a, b) => `${a.owner_login}/${a.slug}`.localeCompare(`${b.owner_login}/${b.slug}`)
   );
-  const defaultSlug = path3.basename(cwd).toLowerCase();
+  const defaultSlug = path5.basename(cwd).toLowerCase();
   const result = await new Promise((resolve) => {
     const app = render(
-      React2.createElement(InitPicker, {
+      React3.createElement(InitPicker, {
         defaultSlug,
         ownerships,
         repos: sortedRepos,
+        currentRepoId: existingConfig?.repo.id,
         onDone: (r) => {
           resolve(r);
           app.unmount();
@@ -1089,25 +1642,50 @@ async function runInit(opts) {
   await ensureGitignored(cwd);
   process.stdout.write(
     `Linked ${cfg.repo.owner_login}/${cfg.repo.slug} \u2192 .balise/config
+`
+  );
+  const [scanResult, currentBaliseignore] = await Promise.all([
+    scan(cwd),
+    readBaliseignore(cwd)
+  ]);
+  const treeResult = await new Promise((resolve) => {
+    const app = render(
+      React3.createElement(IgnoreTree, {
+        scan: scanResult,
+        currentBaliseignore,
+        onDone: (r) => {
+          resolve(r);
+          app.unmount();
+        }
+      })
+    );
+  });
+  if (treeResult.action === "cancel") {
+    process.stderr.write(
+      "Ignore configuration cancelled. .baliseignore unchanged.\n"
+    );
+    process.exit(1);
+  }
+  await writeBaliseignore(cwd, treeResult.patterns);
+  process.stdout.write(
+    `Wrote ${treeResult.patterns.length} patterns to .baliseignore
 `
   );
 }
 
 // src/commands/sync.ts
 import readline from "readline/promises";
-import React4 from "react";
-import { render as render2 } from "ink";
 
 // src/logger.ts
-import { promises as fs3 } from "fs";
-import path4 from "path";
+import { promises as fs5 } from "fs";
+import path6 from "path";
 import os2 from "os";
 var APP_DIR2 = ".balise";
-var FILENAME2 = "balise.log";
+var FILENAME3 = "balise.log";
 function logPath() {
   const override = process.env.BALISE_LOG_FILE;
   if (override && override.length > 0) return override;
-  return path4.join(os2.homedir(), APP_DIR2, FILENAME2);
+  return path6.join(os2.homedir(), APP_DIR2, FILENAME3);
 }
 function formatError(err) {
   if (err instanceof Error) {
@@ -1128,154 +1706,17 @@ ${extras.join("\n")}` : stack;
 async function logError(context, err) {
   try {
     const p = logPath();
-    await fs3.mkdir(path4.dirname(p), { recursive: true, mode: 448 });
+    await fs5.mkdir(path6.dirname(p), { recursive: true, mode: 448 });
     const ts = (/* @__PURE__ */ new Date()).toISOString();
     const line = `[${ts}] ERROR ${context}
 ${formatError(err)}
 
 `;
-    await fs3.appendFile(p, line, { mode: 384 });
+    await fs5.appendFile(p, line, { mode: 384 });
   } catch {
   }
 }
 
-// src/ui/SyncProgress.tsx
-import React3, { useEffect, useState as useState2 } from "react";
-import { Box as Box2, Text as Text2, useApp as useApp2 } from "ink";
-import { Spinner } from "@inkjs/ui";
-var QUEUED_MESSAGES = [
-  "Waiting for an agent willing to accept the job\u2026",
-  "Your request is in line. An agent will be assigned once one stops pretending to be busy.",
-  'Looking for an available agent. Most are currently "in a meeting."',
-  "Queued. An agent will pick this up as soon as they finish rereading the spec.",
-  "Your task is waiting for an agent with the right vibes.",
-  "Negotiating with an agent. They want a raise.",
-  "All agents are currently on strike. Sending in a scab.",
-  "Waiting for an agent to finish their coffee \u2615",
-  "An agent saw your task and walked away slowly. Finding another one.",
-  "Your task is being passed around like a hot potato. Someone will catch it eventually.",
-  "Agents are currently arguing about who has to do this one.",
-  "Waiting for an agent brave enough to open your repo.",
-  "Your task is sitting in the agent break room. Someone will notice it soon.",
-  "An agent was assigned, but they ghosted. Recruiting a replacement.",
-  "Paging an agent. Please hold while we bribe one.",
-  "Queued. Waiting for an agent with enough context window to care.",
-  "An agent is spinning up. They're doing their stretches.",
-  "Looking for an agent whose system prompt allows this.",
-  "Waiting for a worker. Their last task traumatized them.",
-  "Your task is in queue. Agents are busy arguing about tabs vs spaces.",
-  "Finding an agent\u2026",
-  "Found one. They said no.",
-  "Finding another agent\u2026",
-  "This one looks promising.",
-  "Negotiating\u2026"
-];
-var RUNNING_MESSAGES = [
-  "An agent is on it. Try not to watch.",
-  "Your task has an owner. They seem focused.",
-  "An agent accepted the job. Surprisingly.",
-  "Working. The agent asked not to be disturbed.",
-  "An agent is handling it. They'll let us know if they need anything.",
-  "Progress is happening. Allegedly.",
-  "An agent rolled up their sleeves. Mostly for show.",
-  "Hard at work. The agent has opened seventeen browser tabs.",
-  "Your agent is locked in. Do not make eye contact.",
-  "An agent is typing furiously. Some of it might be relevant.",
-  "Working. The agent has entered the zone. And also a Wikipedia rabbit hole.",
-  "An agent is deep in thought. Or buffering. Hard to tell.",
-  "Your task is being handled. The agent is muttering to themselves.",
-  "Cooking. \u{1F9D1}\u200D\u{1F373}",
-  "The agent is working. They've asked for snacks.",
-  "An agent is doing the thing. Please clap.",
-  "Agent is crunching tokens.",
-  "Working. The agent is reasoning about your reasoning.",
-  "An agent is in a tool-use loop. Going well so far.",
-  "Thinking hard. The agent just discovered your codebase has opinions.",
-  "Working. The agent is negotiating with your linter.",
-  "An agent is running. They promise it's not an infinite loop.",
-  "The agent is writing, deleting, and rewriting. Classic.",
-  "An agent picked it up.",
-  "They're reading the task\u2026",
-  "Looks like they have a plan.",
-  "Executing\u2026",
-  "Still going. Confidently.",
-  "Almost there. (They always say that.)"
-];
-function pickInitialIndex(len) {
-  return Math.floor(Math.random() * len);
-}
-function SyncProgress(props) {
-  const { exit } = useApp2();
-  const [status, setStatus] = useState2(null);
-  const [error, setError] = useState2(null);
-  const [startedAt] = useState2(() => Date.now());
-  const [queuedIdx, setQueuedIdx] = useState2(
-    () => pickInitialIndex(QUEUED_MESSAGES.length)
-  );
-  const [runningIdx, setRunningIdx] = useState2(
-    () => pickInitialIndex(RUNNING_MESSAGES.length)
-  );
-  useEffect(() => {
-    let cancelled = false;
-    const tick = async () => {
-      try {
-        const s = await props.client.getJson(
-          `/v1/syncs/${props.syncId}`
-        );
-        if (cancelled) return;
-        setStatus(s);
-        if (s.status === "done") {
-          props.onDone(true);
-          exit();
-          return;
-        }
-        if (s.status === "failed") {
-          props.onDone(false);
-          exit();
-          return;
-        }
-      } catch (err) {
-        if (cancelled) return;
-        setError(err.message);
-        props.onDone(false);
-        exit();
-        return;
-      }
-      setTimeout(tick, props.pollIntervalMs ?? 1e3);
-    };
-    void tick();
-    return () => {
-      cancelled = true;
-    };
-  }, []);
-  useEffect(() => {
-    const period = props.messageRotationMs ?? 1e4;
-    const h = setInterval(() => {
-      setQueuedIdx((i) => (i + 1) % QUEUED_MESSAGES.length);
-      setRunningIdx((i) => (i + 1) % RUNNING_MESSAGES.length);
-    }, period);
-    return () => clearInterval(h);
-  }, [props.messageRotationMs]);
-  if (error) {
-    return /* @__PURE__ */ React3.createElement(Text2, { color: "red" }, "\u2717 Failed");
-  }
-  if (!status) {
-    return /* @__PURE__ */ React3.createElement(Spinner, { label: "Getting things ready\u2026" });
-  }
-  if (status.status === "done") {
-    return /* @__PURE__ */ React3.createElement(Text2, { color: "green" }, "\u2713 Done");
-  }
-  if (status.status === "failed") {
-    return /* @__PURE__ */ React3.createElement(Text2, { color: "red" }, "\u2717 Failed");
-  }
-  const message = status.status === "queued" ? QUEUED_MESSAGES[queuedIdx] : RUNNING_MESSAGES[runningIdx];
-  const { files_processed, files_total, nodes_pushed } = status.progress;
-  const isRunning = status.status === "running";
-  const showFiles = isRunning && files_total > 0;
-  const showNodes = isRunning && nodes_pushed > 0;
-  return /* @__PURE__ */ React3.createElement(Box2, { flexDirection: "column" }, /* @__PURE__ */ React3.createElement(Spinner, { label: message }), showFiles || showNodes ? /* @__PURE__ */ React3.createElement(Text2, { dimColor: true }, "  ", showFiles ? `${files_processed}/${files_total} files` : null, showFiles && showNodes ? " \xB7 " : null, showNodes ? `${nodes_pushed} concepts` : null) : null);
-}
-
 // src/commands/sync.ts
 function buildSyncQuery(opts) {
   const q = { commit_sha: opts.commitSha };
@@ -1321,6 +1762,9 @@ function formatDryRunSummary(body) {
   const fromDiff = body.would_be_cold_start ? "cold-start (no prior tag)" : `from-commit=${body.from_commit ?? "?"}` + (body.from_commit_distance !== null ? ` distance=${body.from_commit_distance}` : "");
   return `Sync would use: base=${body.base_dolt_ref} (${body.base_kind}) / ${fromDiff}`;
 }
+function formatAcceptedSummary(body) {
+  return `Sync queued. Track it here: ${body.web_url}`;
+}
 async function runSync(opts) {
   try {
     await runSyncInner(opts);
@@ -1430,20 +1874,8 @@ async function runSyncInner(opts) {
   if (outcome.kind !== "accepted") {
     process.exit(1);
   }
-  const accepted = outcome.body;
-  const result = await new Promise((resolve) => {
-    const app = render2(
-      React4.createElement(SyncProgress, {
-        client,
-        syncId: accepted.sync_id,
-        onDone: (ok) => {
-          resolve(ok);
-          app.unmount();
-        }
-      })
-    );
-  });
-  process.exit(result ? 0 : 1);
+  process.stdout.write(formatAcceptedSummary(outcome.body) + "\n");
+  process.exit(0);
 }
 async function uploadOnce(client, owner, slug, stream, query) {
   const raw = await client.uploadBundleRaw(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@balise.dev/cli",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "description": "Balise CLI — push codebase to Balise backend for spec extraction.",
   "type": "module",
   "bin": {
@@ -27,6 +27,7 @@
     "ini": "^5.0.0",
     "ink": "^5.0.1",
     "open": "^10.1.0",
+    "picomatch": "^4.0.2",
     "react": "^18.3.1",
     "tar": "^7.4.3",
     "undici": "^6.19.8"
@@ -34,8 +35,10 @@
   "devDependencies": {
     "@types/ini": "^4.1.1",
     "@types/node": "^20.14.0",
+    "@types/picomatch": "^3.0.2",
     "@types/react": "^18.3.3",
     "@types/tar": "^6.1.13",
+    "ink-testing-library": "^4.0.0",
     "tsup": "^8.2.4",
     "typescript": "^5.5.4",
     "vitest": "^2.0.5"