@balise.dev/cli 0.1.3 → 0.3.0

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
@@ -913,83 +913,837 @@ ${credentialsHelpMessage()}
 }
 
 // src/ui/InitPicker.tsx
-import React, { useState } from "react";
+import React, { useMemo, useState } from "react";
 import { Box, Text, useApp, useInput } from "ink";
-import { Select, TextInput } from "@inkjs/ui";
+var ACCENT = "#E8A947";
+var OK = "#9db89a";
+var WIDTH = 56;
+var RESERVED_SLUGS = /* @__PURE__ */ new Set(["settings"]);
 function normalizeSlug(raw) {
-  return raw.toLowerCase().replace(/[^a-z0-9-]/g, "");
+  return raw.toLowerCase().replace(/[^a-z0-9_-]/g, "");
+}
+function slugStatus(slug, ownerId, repos) {
+  if (slug.length === 0) return "empty";
+  if (slug.length < 2) return "too-short";
+  if (slug.length > 40) return "too-long";
+  if (RESERVED_SLUGS.has(slug)) return "reserved";
+  if (ownerId && repos.some((r) => r.owner_id === ownerId && r.slug === slug)) {
+    return "taken";
+  }
+  return "ok";
 }
+var FILTER_CHAR = /^[\w./-]$/;
 function InitPicker(props) {
   const { exit } = useApp();
-  const [field, setField] = useState("slug");
-  const [slug, setSlug] = useState(normalizeSlug(props.defaultSlug));
-  const [ownerId, setOwnerId] = useState(
-    props.ownerships[0]?.id
-  );
-  const [repoId, setRepoId] = useState(
-    props.repos[0]?.id
-  );
-  const submit = () => {
-    if (field === "link") {
-      const repo = props.repos.find((r) => r.id === repoId);
-      if (!repo) return;
-      props.onDone({ action: "link", repo });
-    } else {
-      const owner = props.ownerships.find((o) => o.id === ownerId);
-      if (!owner || !slug) return;
-      props.onDone({ action: "create", slug, owner });
+  const { repos, ownerships } = props;
+  const initialCursor = useMemo(() => {
+    if (props.currentRepoId) {
+      const i = repos.findIndex((r) => r.id === props.currentRepoId);
+      if (i >= 0) return i + 1;
+    }
+    return 0;
+  }, [repos, props.currentRepoId]);
+  const [mode, setMode] = useState("list");
+  const [filter, setFilter] = useState("");
+  const [listCursor, setListCursor] = useState(initialCursor);
+  const [ownerCursor, setOwnerCursor] = useState(0);
+  const [owner, setOwner] = useState(void 0);
+  const [name, setName] = useState(() => normalizeSlug(props.defaultSlug));
+  const [visibility, setVisibility] = useState("private");
+  const [field, setField] = useState("name");
+  const visibleRepos = useMemo(() => {
+    const f = filter.toLowerCase();
+    if (!f) return repos;
+    return repos.filter(
+      (r) => `${r.owner_login}/${r.slug}`.toLowerCase().includes(f)
+    );
+  }, [repos, filter]);
+  const maxListIdx = visibleRepos.length;
+  const safeCursor = Math.max(0, Math.min(listCursor, maxListIdx));
+  const status = slugStatus(name, owner?.id, repos);
+  useInput((input, key) => {
+    if (mode === "list") {
+      if (key.upArrow) {
+        setListCursor((c) => Math.max(0, Math.min(c, maxListIdx) - 1));
+        return;
+      }
+      if (key.downArrow) {
+        setListCursor((c) => Math.min(maxListIdx, c + 1));
+        return;
+      }
+      if (key.return) {
+        if (safeCursor === 0) {
+          setMode("owner");
+          setOwnerCursor(0);
+        } else {
+          const repo = visibleRepos[safeCursor - 1];
+          if (repo) {
+            props.onDone({ action: "link", repo });
+            exit();
+          }
+        }
+        return;
+      }
+      if (key.escape) {
+        if (filter) {
+          setFilter("");
+          setListCursor(0);
+        } else {
+          props.onDone({ action: "cancel" });
+          exit();
+        }
+        return;
+      }
+      if ((key.backspace || key.delete) && filter) {
+        setFilter((f) => f.slice(0, -1));
+        setListCursor(0);
+        return;
+      }
+      if (!key.ctrl && !key.meta && input && FILTER_CHAR.test(input)) {
+        setFilter((f) => f + input);
+        setListCursor(0);
+      }
+      return;
+    }
+    if (mode === "owner") {
+      if (key.upArrow) {
+        setOwnerCursor((c) => Math.max(0, c - 1));
+        return;
+      }
+      if (key.downArrow) {
+        setOwnerCursor((c) => Math.min(ownerships.length - 1, c + 1));
+        return;
+      }
+      if (key.return) {
+        const chosen = ownerships[ownerCursor];
+        if (chosen) {
+          setOwner(chosen);
+          setField("name");
+          setMode("detail");
+        }
+        return;
+      }
+      if (key.escape) {
+        setMode("list");
+      }
+      return;
     }
-    exit();
-  };
-  useInput((_input, key) => {
     if (key.escape) {
-      props.onDone({ action: "cancel" });
-      exit();
+      if (field === "visibility") setField("name");
+      else setMode("owner");
       return;
     }
-    if (key.tab) {
-      setField((f) => {
-        if (f === "slug") return "owner";
-        if (f === "owner") return props.repos.length > 0 ? "link" : "slug";
-        return "slug";
-      });
+    if (field === "name") {
+      if (key.return) {
+        if (status === "ok") setField("visibility");
+        return;
+      }
+      if (key.backspace || key.delete) {
+        setName((n) => n.slice(0, -1));
+        return;
+      }
+      if (!key.ctrl && !key.meta && input) {
+        const accepted = input.replace(/[^a-z0-9_-]/g, "");
+        if (accepted) setName((n) => n + accepted);
+      }
+      return;
+    }
+    if (key.leftArrow || key.rightArrow || input === " ") {
+      setVisibility((v) => v === "private" ? "public" : "private");
+      return;
+    }
+    if (key.upArrow) {
+      setField("name");
       return;
     }
     if (key.return) {
-      submit();
+      if (status !== "ok") {
+        setField("name");
+        return;
+      }
+      props.onDone({
+        action: "create",
+        slug: name,
+        owner,
+        visibility
+      });
+      exit();
     }
   });
-  const ownerOptions = props.ownerships.map((o) => ({
-    label: `${o.login} (${o.type})`,
-    value: o.id
-  }));
-  const repoOptions = props.repos.map((r) => ({
-    label: `${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(
-    TextInput,
+  if (mode === "owner") {
+    return /* @__PURE__ */ React.createElement(OwnerStep, { ownerships, cursor: ownerCursor });
+  }
+  if (mode === "detail" && owner) {
+    return /* @__PURE__ */ React.createElement(
+      DetailStep,
+      {
+        owner,
+        name,
+        visibility,
+        field,
+        status
+      }
+    );
+  }
+  return /* @__PURE__ */ React.createElement(
+    ListStep,
     {
-      defaultValue: slug,
-      placeholder: "repo-slug",
-      isDisabled: field !== "slug",
-      onChange: (v) => setSlug(normalizeSlug(v))
+      repos: visibleRepos,
+      total: repos.length,
+      filter,
+      cursor: safeCursor,
+      currentRepoId: props.currentRepoId
     }
-  ))), /* @__PURE__ */ React.createElement(Box, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React.createElement(Text, { color: field === "owner" ? "cyan" : "gray" }, field === "owner" ? "\u25B8 " : "  ", "Owner"), /* @__PURE__ */ React.createElement(Box, { marginLeft: 2 }, field === "owner" ? /* @__PURE__ */ React.createElement(
-    Select,
+  );
+}
+function ListStep(props) {
+  const { repos, total, filter, cursor } = props;
+  const sub = filter ? `${repos.length}/${total} repos \xB7 filter: ${filter}` : `${total} repos \xB7 type to filter`;
+  return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", width: WIDTH, paddingX: 1 }, /* @__PURE__ */ React.createElement(Text, { bold: true }, "Select a repository"), /* @__PURE__ */ React.createElement(Text, { dimColor: true }, sub), /* @__PURE__ */ React.createElement(
+    Row,
+    {
+      selected: cursor === 0,
+      label: "+ Initialize new repository",
+      labelColor: "white",
+      kind: "here"
+    }
+  ), repos.length > 0 ? /* @__PURE__ */ React.createElement(Text, { color: "gray" }, "\u2500".repeat(WIDTH - 4)) : null, repos.map((r, i) => /* @__PURE__ */ React.createElement(
+    Row,
     {
-      options: ownerOptions,
-      defaultValue: ownerId,
-      onChange: setOwnerId
+      key: r.id,
+      selected: cursor === i + 1,
+      label: `${r.owner_login}/${r.slug}`,
+      suffix: r.id === props.currentRepoId ? " (current)" : void 0,
+      vis: r.visibility,
+      kind: r.owner_type
     }
-  ) : /* @__PURE__ */ React.createElement(Text, { dimColor: true }, ownerOptions.find((o) => o.value === ownerId)?.label ?? "\u2014"))), props.repos.length > 0 && /* @__PURE__ */ React.createElement(Box, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React.createElement(Text, { color: field === "link" ? "cyan" : "gray" }, field === "link" ? "\u25B8 " : "  ", "Link existing (", props.repos.length, ")"), /* @__PURE__ */ React.createElement(Box, { marginLeft: 2 }, field === "link" ? /* @__PURE__ */ React.createElement(
-    Select,
+  )), /* @__PURE__ */ React.createElement(Box, { marginTop: 1 }, /* @__PURE__ */ React.createElement(Text, { dimColor: true }, "\u2191\u2193 move \xB7 \u23CE select \xB7 type to filter \xB7 esc ", filter ? "clear" : "quit")));
+}
+function OwnerStep(props) {
+  return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", width: WIDTH, paddingX: 1 }, /* @__PURE__ */ React.createElement(Text, { bold: true }, "New repository \xB7 choose an owner"), /* @__PURE__ */ React.createElement(Text, { dimColor: true }, "step 1 of 3 \xB7 owner \u2192 name \u2192 visibility"), /* @__PURE__ */ React.createElement(
+    Box,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: ACCENT,
+      paddingX: 1,
+      marginTop: 1
+    },
+    props.ownerships.length === 0 ? /* @__PURE__ */ React.createElement(Text, { dimColor: true }, "(no owners available)") : props.ownerships.map((o, i) => /* @__PURE__ */ React.createElement(
+      Row,
+      {
+        key: o.id,
+        selected: props.cursor === i,
+        label: o.login,
+        kind: o.type
+      }
+    ))
+  ), /* @__PURE__ */ React.createElement(Box, { marginTop: 1 }, /* @__PURE__ */ React.createElement(Text, { dimColor: true }, "\u2191\u2193 owner \xB7 \u23CE confirm & continue \xB7 esc back to list")));
+}
+function DetailStep(props) {
+  const { owner, name, visibility, field, status } = props;
+  const nameActive = field === "name";
+  const taken = status === "taken";
+  return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", width: WIDTH, paddingX: 1 }, /* @__PURE__ */ React.createElement(Text, { bold: true }, "New repository"), /* @__PURE__ */ React.createElement(Text, { dimColor: true }, owner.login, " \xB7 ", owner.type), /* @__PURE__ */ React.createElement(
+    Box,
     {
-      options: repoOptions,
-      defaultValue: repoId,
-      onChange: setRepoId
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: ACCENT,
+      paddingX: 1,
+      marginTop: 1
+    },
+    /* @__PURE__ */ React.createElement(FieldRow, { state: "done", label: "owner" }, /* @__PURE__ */ React.createElement(Text, null, owner.login, " ", /* @__PURE__ */ React.createElement(Text, { dimColor: true }, "\xB7 ", owner.type))),
+    /* @__PURE__ */ React.createElement(FieldRow, { state: nameActive ? "active" : "done", label: "name" }, /* @__PURE__ */ React.createElement(Text, null, name, nameActive ? /* @__PURE__ */ React.createElement(Text, { color: ACCENT }, "\u2588") : null, nameActive && taken ? /* @__PURE__ */ React.createElement(Text, { color: ACCENT }, " \u26A0 existe d\xE9j\xE0") : null)),
+    /* @__PURE__ */ React.createElement(
+      FieldRow,
+      {
+        state: field === "visibility" ? "active" : "pending",
+        label: "visibility"
+      },
+      /* @__PURE__ */ React.createElement(VisibilityPick, { value: visibility, dim: field !== "visibility" })
+    )
+  ), /* @__PURE__ */ React.createElement(
+    StatusLine,
+    {
+      owner: owner.login,
+      name,
+      visibility,
+      status
+    }
+  ), /* @__PURE__ */ React.createElement(Box, { marginTop: 1 }, /* @__PURE__ */ React.createElement(Text, { dimColor: true }, "\u23CE next field \xB7 on visibility \u2190/\u2192 toggle \xB7 last \u23CE create \xB7 esc back")));
+}
+function Row(props) {
+  const { selected } = props;
+  return /* @__PURE__ */ React.createElement(Box, null, /* @__PURE__ */ React.createElement(Box, { width: 2, flexShrink: 0 }, /* @__PURE__ */ React.createElement(Text, { color: selected ? ACCENT : void 0 }, selected ? "\u276F " : "  ")), /* @__PURE__ */ React.createElement(Box, { flexGrow: 1 }, /* @__PURE__ */ React.createElement(Text, { color: selected ? ACCENT : props.labelColor, wrap: "truncate-end" }, props.label, props.suffix ? /* @__PURE__ */ React.createElement(Text, { dimColor: true }, props.suffix) : null)), /* @__PURE__ */ React.createElement(Box, { width: 9, flexShrink: 0, justifyContent: "flex-end" }, /* @__PURE__ */ React.createElement(Text, { dimColor: true }, props.vis ?? "")), /* @__PURE__ */ React.createElement(Box, { width: 5, flexShrink: 0, justifyContent: "flex-end" }, /* @__PURE__ */ React.createElement(Text, { dimColor: true }, props.kind ?? "")));
+}
+function FieldRow(props) {
+  const { state } = props;
+  const marker = state === "done" ? "\u2713" : state === "active" ? "\u276F" : "\xB7";
+  const markerColor = state === "done" ? OK : state === "active" ? ACCENT : "gray";
+  return /* @__PURE__ */ React.createElement(Box, null, /* @__PURE__ */ React.createElement(Box, { width: 2, flexShrink: 0 }, /* @__PURE__ */ React.createElement(Text, { color: markerColor }, marker, " ")), /* @__PURE__ */ React.createElement(Box, { width: 11, flexShrink: 0 }, /* @__PURE__ */ React.createElement(Text, { dimColor: true }, props.label)), /* @__PURE__ */ React.createElement(Box, { flexGrow: 1 }, props.children));
+}
+function VisibilityPick(props) {
+  const opt = (v, label) => {
+    const on = props.value === v;
+    const color = props.dim ? void 0 : on ? ACCENT : "gray";
+    return /* @__PURE__ */ React.createElement(Text, { color, dimColor: props.dim }, on ? "(\u2022)" : "( )", " ", label);
+  };
+  return /* @__PURE__ */ React.createElement(Box, null, opt("private", "private"), /* @__PURE__ */ React.createElement(Text, null, " "), opt("public", "public"));
+}
+function StatusLine(props) {
+  const { owner, name, visibility, status } = props;
+  if (status === "ok") {
+    return /* @__PURE__ */ React.createElement(Text, { color: OK }, "\u2192 ", owner, "/", name, " \xB7 ", visibility, " \xB7 disponible");
+  }
+  if (status === "taken") {
+    return /* @__PURE__ */ React.createElement(Text, { color: ACCENT }, "\u26A0 ", owner, "/", name, " existe d\xE9j\xE0 \u2014 change le nom pour continuer");
+  }
+  if (status === "reserved") {
+    return /* @__PURE__ */ React.createElement(Text, { color: ACCENT }, "\u26A0 \xAB ", name, " \xBB est un nom r\xE9serv\xE9");
+  }
+  const hint = status === "empty" ? "saisis un nom de repo" : status === "too-short" ? "2 caract\xE8res minimum" : "40 caract\xE8res maximum";
+  return /* @__PURE__ */ React.createElement(Text, { dimColor: true }, hint);
+}
+
+// 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";
+
+// src/policy.ts
+var LOC_THRESHOLD = 2500;
+
+// src/scan.ts
+var execFile = promisify(execFileCb);
+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 buf;
+  try {
+    buf = await fs3.readFile(absPath);
+  } catch {
+    return null;
+  }
+  if (!isUtf8(buf)) return 0;
+  return countLines(buf);
+}
+function toEntry(rel, locCount) {
+  return { path: rel, locCount, isLarge: locCount > LOC_THRESHOLD };
+}
+async function listTrackedFiles(cwd) {
+  try {
+    const { stdout } = await execFile("git", ["ls-files", "-z"], {
+      cwd,
+      maxBuffer: 50 * 1024 * 1024
+    });
+    return stdout.split("\0").filter((l) => l.length > 0);
+  } catch {
+    return null;
+  }
+}
+async function walkAll(absDir, relDir, out) {
+  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 (d.name === ".git") continue;
+      await walkAll(absPath, relPath, out);
+    } else if (d.isFile()) {
+      const loc = await scanFile(absPath);
+      if (loc !== null) out.push(toEntry(relPath, loc));
+    }
+  }
+}
+async function scan(cwd) {
+  const tracked = await listTrackedFiles(cwd);
+  if (tracked !== null) {
+    const out2 = [];
+    for (const rel of tracked) {
+      const loc = await scanFile(path3.join(cwd, rel));
+      if (loc !== null) out2.push(toEntry(rel, loc));
+    }
+    return out2;
+  }
+  const out = [];
+  await walkAll(cwd, "", out);
+  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 as useMemo2, 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,
+    locCount: 0,
+    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,
+      locCount: 0,
+      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: false,
+      locCount: e.locCount,
+      isLarge: e.isLarge,
+      children: [],
+      parent
+    };
+    parent.children.push(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) 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 && 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 buildFileList(entries) {
+  return [...entries].sort(
+    (a, b) => b.locCount - a.locCount || a.path.localeCompare(b.path)
+  );
+}
+function computeInitialExcluded(scan2, current) {
+  const out = /* @__PURE__ */ new Set();
+  const scanPaths = /* @__PURE__ */ new Set();
+  for (const e of scan2) {
+    scanPaths.add(e.path);
+    if (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 = useMemo2(() => buildTree(props.scan), [props.scan]);
+  const fileList = useMemo2(() => buildFileList(props.scan), [props.scan]);
+  const [excluded, setExcluded] = useState2(
+    () => computeInitialExcluded(props.scan, props.currentBaliseignore)
+  );
+  const [expandedDirs, setExpandedDirs] = useState2(/* @__PURE__ */ new Set());
+  const [leftView, setLeftView] = useState2("list");
+  const [focus, setFocus] = useState2("left");
+  const [treeCursor, setTreeCursor] = useState2("");
+  const [listCursor, setListCursor] = useState2(0);
+  const [diffCursor, setDiffCursor] = useState2(0);
+  const [modalOpen, setModalOpen] = useState2(false);
+  const visible = useMemo2(
+    () => flattenVisible(root, expandedDirs),
+    [root, expandedDirs]
+  );
+  const diff = useMemo2(
+    () => computeDiff(props.currentBaliseignore, excluded),
+    [props.currentBaliseignore, excluded]
+  );
+  const treeIdx = useMemo2(() => {
+    if (visible.length === 0) return -1;
+    const i = visible.findIndex((v) => v.node.path === treeCursor);
+    return i >= 0 ? i : 0;
+  }, [visible, treeCursor]);
+  const safeListIdx = fileList.length === 0 ? -1 : Math.max(0, Math.min(listCursor, fileList.length - 1));
+  const safeDiffIdx = diff.length === 0 ? -1 : Math.max(0, Math.min(diffCursor, diff.length - 1));
+  const stats = useMemo2(() => {
+    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 === "left" ? "diff" : "left");
+      return;
+    }
+    if ((input === "v" || input === "V") && focus === "left") {
+      setLeftView((vw) => vw === "list" ? "tree" : "list");
+      return;
+    }
+    if (key.return) {
+      setModalOpen(true);
+      return;
+    }
+    if (key.escape || input === "q") {
+      setModalOpen(true);
+      return;
+    }
+    if (focus === "left" && leftView === "list") {
+      if (key.downArrow) {
+        setListCursor((c) => Math.min(c + 1, Math.max(fileList.length - 1, 0)));
+        return;
+      }
+      if (key.upArrow) {
+        setListCursor((c) => Math.max(c - 1, 0));
+        return;
+      }
+      if (input === " ") {
+        if (safeListIdx < 0) return;
+        toggleFile(fileList[safeListIdx].path);
+        return;
+      }
+    } else if (focus === "left") {
+      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) 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 && 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) 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;
+      }
     }
-  ) : /* @__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")));
+  });
+  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 treeWindowStart = Math.max(treeStart, 0);
+  const listStart = Math.max(
+    0,
+    Math.min(
+      safeListIdx - Math.floor(VIEWPORT_HEIGHT / 2),
+      fileList.length - VIEWPORT_HEIGHT
+    )
+  );
+  const listWindow = fileList.slice(
+    Math.max(listStart, 0),
+    Math.max(listStart, 0) + VIEWPORT_HEIGHT
+  );
+  const listWindowStart = Math.max(listStart, 0);
+  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 diffWindowStart = Math.max(diffStart, 0);
+  const leftTitle = leftView === "list" ? "Files \u2014 by LoC" : "Files \u2014 tree";
+  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 v: list/tree \xB7 \u2191/\u2193: nav", leftView === "tree" ? " \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 === "left" ? "cyan" : "gray"
+    },
+    /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: focus === "left" ? "cyan" : void 0 }, leftTitle),
+    leftView === "list" ? listWindow.length === 0 ? /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, "(no files)") : listWindow.map((e, i) => /* @__PURE__ */ React2.createElement(
+      ListRow,
+      {
+        key: e.path,
+        entry: e,
+        excluded: excluded.has(e.path),
+        isFocused: focus === "left" && listWindowStart + i === safeListIdx
+      }
+    )) : 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 === "left" && 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 ListRow(props) {
+  const { entry, excluded, isFocused } = props;
+  const box = excluded ? "\u2610" : "\u2611";
+  const loc = entry.locCount > 0 ? ` (${entry.locCount} LoC)` : "";
+  const large = entry.isLarge ? " [large]" : "";
+  return /* @__PURE__ */ React2.createElement(Text2, { color: isFocused ? "cyan" : void 0 }, isFocused ? "\u25B8 " : "  ", box, " ", entry.path, loc, large);
+}
+function TreeRow(props) {
+  const { node, depth, expanded, excluded, isFocused } = props;
+  const indent = "  ".repeat(Math.max(depth, 0));
+  let label;
+  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 large = node.isLarge ? " [large]" : "";
+    label = `${box} ${node.name}${loc}${large}`;
+  }
+  return /* @__PURE__ */ React2.createElement(Text2, { color: isFocused ? "cyan" : void 0 }, 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
@@ -1015,6 +1769,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 +1804,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();
@@ -1065,7 +1827,8 @@ async function runInit(opts) {
   if (result.action === "create") {
     const created = await client.postJson("/v1/repos", {
       owner_id: result.owner.id,
-      slug: result.slug
+      slug: result.slug,
+      visibility: result.visibility
     });
     cfg = {
       repo: {
@@ -1091,23 +1854,51 @@ async function runInit(opts) {
     `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
+`
+  );
+  process.stdout.write(
+    '\n\u26A0  .baliseignore takes effect only once committed (it\'s read per commit\n   server-side). Commit it before your next `balise sync`:\n     git add .baliseignore && git commit -m "chore: update .baliseignore"\n'
+  );
 }
 
 // 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,152 +1919,76 @@ ${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;
+// src/ui/SyncDashboard.tsx
+import React4 from "react";
+import { Box as Box3, render as render2, Text as Text3, useApp as useApp3, useInput as useInput3 } from "ink";
+
+// src/format.ts
+function fmtLoc(n) {
+  return n >= 1e3 ? `${(n / 1e3).toFixed(1).replace(/\.0$/, "")}k` : String(n);
+}
+var CREDIT_FMT = new Intl.NumberFormat("en-US", { maximumFractionDigits: 0 });
+function fmtCredits(micro) {
+  return CREDIT_FMT.format(Math.floor(micro / 1e6));
+}
+function fmtEstimate(micro) {
+  if (micro > 0 && micro < 1e6) return "<1";
+  return fmtCredits(micro);
+}
+
+// src/ui/SyncDashboard.tsx
+function Row2(props) {
+  return /* @__PURE__ */ React4.createElement(Box3, { flexDirection: "row" }, /* @__PURE__ */ React4.createElement(Box3, { width: 8, flexShrink: 0 }, /* @__PURE__ */ React4.createElement(Text3, { dimColor: true }, props.label)), /* @__PURE__ */ React4.createElement(Text3, null, props.children));
+}
+function describeBase(body) {
+  if (body.would_be_cold_start) {
+    return `${body.base_dolt_ref} \xB7 cold-start (no prior sync)`;
+  }
+  const dist = body.from_commit_distance !== null ? ` \xB7 ${body.from_commit_distance} commit${body.from_commit_distance === 1 ? "" : "s"} ahead` : "";
+  return `${body.base_dolt_ref} \xB7 ${body.base_kind}${dist}`;
+}
+function SyncDashboard(props) {
+  const { exit } = useApp3();
+  const { body } = props;
+  useInput3((input, key) => {
+    if (key.return) {
+      props.onDone(true);
+      exit();
+      return;
+    }
+    if (key.escape || input === "q" || input === "Q" || key.ctrl && input === "c") {
+      props.onDone(false);
+      exit();
+      return;
+    }
+  });
+  const loc = body.loc !== null ? `${fmtLoc(body.loc)} LOC` : "n/a";
+  const cost = `~${fmtEstimate(body.estimate)} cr`;
+  return /* @__PURE__ */ React4.createElement(Box3, { flexDirection: "column", paddingX: 1, borderStyle: "round", borderColor: "cyan" }, /* @__PURE__ */ React4.createElement(Text3, { bold: true }, "balise sync \xB7 ", props.owner, "/", props.slug), /* @__PURE__ */ React4.createElement(Box3, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React4.createElement(Row2, { label: "commit" }, props.commitSha.slice(0, 7), props.branch ? /* @__PURE__ */ React4.createElement(Text3, { dimColor: true }, " \xB7 ", props.branch) : null), /* @__PURE__ */ React4.createElement(Row2, { label: "base" }, describeBase(body)), /* @__PURE__ */ React4.createElement(Row2, { label: "diff" }, /* @__PURE__ */ React4.createElement(Text3, { bold: true }, loc)), /* @__PURE__ */ React4.createElement(Row2, { label: "cost" }, /* @__PURE__ */ React4.createElement(Text3, { bold: true }, cost))), props.dirty ? /* @__PURE__ */ React4.createElement(Box3, { marginTop: 1 }, /* @__PURE__ */ React4.createElement(Text3, { color: "yellow" }, "\u26A0 working tree dirty \u2014 syncing HEAD")) : null, /* @__PURE__ */ React4.createElement(Box3, { marginTop: 1 }, /* @__PURE__ */ React4.createElement(Text3, { dimColor: true }, "[Enter] sync   \xB7   [Esc] cancel")));
+}
+function runSyncDashboard(props) {
+  return new Promise((resolve) => {
+    const app = render2(
+      React4.createElement(SyncDashboard, {
+        ...props,
+        onDone: (confirmed) => {
+          resolve(confirmed);
+          app.unmount();
         }
-      } 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
@@ -1293,6 +2008,9 @@ function drainStdinBuffer(stdin) {
   while (s.read() !== null) {
   }
 }
+function isInteractive2() {
+  return Boolean(process.stdin.isTTY);
+}
 async function confirmRetryWithForce(opts) {
   const stderr = opts.stderr ?? process.stderr;
   const synced = opts.body.synced_at ?? "unknown time";
@@ -1319,7 +2037,18 @@ async function confirmRetryWithForce(opts) {
 }
 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}`;
+  const loc = body.loc !== null ? `${body.loc} LOC` : "LOC n/a";
+  return `Sync would use: base=${body.base_dolt_ref} (${body.base_kind}) / ${fromDiff} \xB7 ${loc} \xB7 ~${fmtEstimate(body.estimate)} cr`;
+}
+function resolveWebUrl(webUrl, frontUrl) {
+  try {
+    return new URL(webUrl, frontUrl).toString();
+  } catch {
+    return webUrl;
+  }
+}
+function formatAcceptedSummary(body, frontUrl) {
+  return `Sync queued. Track it here: ${resolveWebUrl(body.web_url, frontUrl)}`;
 }
 async function runSync(opts) {
   try {
@@ -1372,11 +2101,7 @@ async function runSyncInner(opts) {
       process.exit(1);
     }
   }
-  if (await isDirty({ cwd })) {
-    process.stderr.write(
-      "Warning: working tree has uncommitted changes \u2014 syncing HEAD anyway.\n"
-    );
-  }
+  const dirty = await isDirty({ cwd });
   const client = new ApiClient({
     apiUrl: cfg.api.url,
     supabaseUrl: opts.supabaseUrl
@@ -1385,65 +2110,117 @@ async function runSyncInner(opts) {
     `Packing ${cfg.repo.owner_login}/${cfg.repo.slug} at HEAD\u2026
 `
   );
-  const submit = async (force) => {
+  const submit = async (force, dryRun) => {
     const { stream, commitSha, branch } = await gitBundle({ cwd });
-    const query = buildSyncQuery({
-      commitSha,
-      branch,
-      force,
-      base: opts.base,
-      dryRun: opts.dryRun ?? false
-    });
-    return uploadOnce(client, cfg.repo.owner_login, cfg.repo.slug, stream, query);
+    const query = buildSyncQuery({ commitSha, branch, force, base: opts.base, dryRun });
+    const outcome = await uploadOnce(
+      client,
+      cfg.repo.owner_login,
+      cfg.repo.slug,
+      stream,
+      query
+    );
+    return { outcome, commitSha, branch };
   };
-  let outcome;
+  const finishReal = (outcome) => {
+    if (outcome.kind === "invalid_base") {
+      process.stderr.write(`invalid base ref: ${opts.base}
+`);
+      process.exit(1);
+    }
+    if (outcome.kind === "accepted") {
+      process.stdout.write(
+        formatAcceptedSummary(outcome.body, opts.frontUrl) + "\n"
+      );
+      process.exit(0);
+    }
+    process.exit(1);
+  };
+  if (opts.autoConfirm) {
+    if (dirty) {
+      process.stderr.write(
+        "Warning: working tree has uncommitted changes \u2014 syncing HEAD anyway.\n"
+      );
+    }
+    let outcome;
+    try {
+      outcome = (await submit(opts.force ?? false, false)).outcome;
+    } catch (err) {
+      handleUploadError(err);
+      process.exit(1);
+    }
+    if (outcome.kind === "conflict") {
+      const proceed = await confirmRetryWithForce({
+        body: outcome.body,
+        autoConfirm: true
+      });
+      if (!proceed) process.exit(1);
+      try {
+        outcome = (await submit(true, false)).outcome;
+      } catch (err) {
+        handleUploadError(err);
+        process.exit(1);
+      }
+    }
+    finishReal(outcome);
+  }
+  let dry;
   try {
-    outcome = await submit(opts.force ?? false);
+    dry = await submit(opts.force ?? false, true);
   } catch (err) {
     handleUploadError(err);
     process.exit(1);
   }
-  if (outcome.kind === "conflict") {
-    const proceedForce = await confirmRetryWithForce({
-      body: outcome.body,
-      autoConfirm: opts.autoConfirm ?? false
+  if (dry.outcome.kind === "conflict") {
+    const proceed = await confirmRetryWithForce({
+      body: dry.outcome.body,
+      autoConfirm: false
     });
-    if (!proceedForce) {
-      process.exit(1);
-    }
+    if (!proceed) process.exit(1);
+    let forced;
     try {
-      outcome = await submit(true);
+      forced = (await submit(true, false)).outcome;
     } catch (err) {
       handleUploadError(err);
       process.exit(1);
     }
+    finishReal(forced);
   }
-  if (outcome.kind === "invalid_base") {
+  if (dry.outcome.kind === "invalid_base") {
     process.stderr.write(`invalid base ref: ${opts.base}
 `);
     process.exit(1);
   }
-  if (outcome.kind === "dry_run") {
-    process.stdout.write(formatDryRunSummary(outcome.body) + "\n");
-    process.exit(0);
-  }
-  if (outcome.kind !== "accepted") {
+  if (dry.outcome.kind !== "dry_run") {
     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();
-        }
-      })
+  if (!isInteractive2()) {
+    process.stdout.write(formatDryRunSummary(dry.outcome.body) + "\n");
+    process.stderr.write(
+      "Non-interactive terminal \u2014 re-run with -y to confirm and sync.\n"
     );
+    process.exit(1);
+  }
+  const confirmed = await runSyncDashboard({
+    owner: cfg.repo.owner_login,
+    slug: cfg.repo.slug,
+    commitSha: dry.commitSha,
+    branch: dry.branch,
+    dirty,
+    body: dry.outcome.body
   });
-  process.exit(result ? 0 : 1);
+  if (!confirmed) {
+    process.stderr.write("Sync cancelled.\n");
+    process.exit(0);
+  }
+  let real;
+  try {
+    real = (await submit(opts.force ?? false, false)).outcome;
+  } catch (err) {
+    handleUploadError(err);
+    process.exit(1);
+  }
+  finishReal(real);
 }
 async function uploadOnce(client, owner, slug, stream, query) {
   const raw = await client.uploadBundleRaw(
@@ -1506,6 +2283,7 @@ async function withLog(name, fn) {
   }
 }
 var SUPABASE_URL = process.env.BALISE_SUPABASE_URL ?? "https://api.balise.dev";
+var FRONT_URL = process.env.BALISE_FRONT_URL ?? "https://balise.dev";
 var loginCmd = defineCommand({
   meta: { name: "login", description: "Authenticate via OAuth (PKCE loopback)." },
   async run() {
@@ -1542,7 +2320,7 @@ var syncCmd = defineCommand({
     yes: {
       type: "boolean",
       alias: "y",
-      description: "Skip sync confirmations (warning prompt + future 409 retry).",
+      description: "Auto-validate: skip the pre-run dashboard and sync directly.",
       default: false
     },
     force: {
@@ -1553,20 +2331,15 @@ var syncCmd = defineCommand({
     base: {
       type: "string",
       description: "Explicit base balise ref (branch/tag/commit) to start from. Validated server-side."
-    },
-    "dry-run": {
-      type: "boolean",
-      description: "Preview the resolution without uploading the bundle or enqueuing the worker.",
-      default: false
     }
   },
   async run({ args }) {
     await runSync({
       supabaseUrl: SUPABASE_URL,
+      frontUrl: FRONT_URL,
       autoConfirm: Boolean(args.yes),
       force: Boolean(args.force),
-      base: typeof args.base === "string" && args.base.length > 0 ? args.base : void 0,
-      dryRun: Boolean(args["dry-run"])
+      base: typeof args.base === "string" && args.base.length > 0 ? args.base : void 0
     });
   }
 });