@cueloop/client 0.1.0-alpha.0 → 0.1.0-alpha.100

package/src/config.ts

@@ -1,113 +0,0 @@
-/**
- * Layered TOML config (#20): built-in defaults → user config → trusted repo
- * config → env. Sections: [keys] action = "combo" (every action rebindable),
- * [theme] per-token overrides, [integrations.obsidian] notes-vault export.
- */
-
-import { existsSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { OBSIDIAN_DEFAULTS, type ObsidianConfig } from "@cueloop/integration-obsidian";
-import { DARK, type Theme } from "./theme";
-
-export interface KeymapConfig {
-  [action: string]: string | string[];
-}
-
-export interface IntegrationsConfig {
-  obsidian: ObsidianConfig;
-}
-
-export interface CueloopConfig {
-  keys: Record<string, string[]>;
-  theme: Theme;
-  integrations: IntegrationsConfig;
-}
-
-/** Every action in the grammar, with its default binding(s). */
-export const DEFAULT_KEYS: Record<string, string[]> = {
-  down: ["j", "down"],
-  up: ["k", "up"],
-  top: ["g"],
-  bottom: ["G"],
-  span: ["v"],
-  comment: ["c"],
-  suggest: ["s"],
-  cut: ["x"],
-  edit: ["e"],
-  next_annotation: ["n"],
-  prev_annotation: ["p"],
-  delete_annotation: ["backspace"],
-  submit: ["return", "enter"],
-  quit: ["q"],
-};
-
-function parseToml(text: string): Record<string, unknown> {
-  // Bun ships a native TOML parser
-  return Bun.TOML.parse(text) as Record<string, unknown>;
-}
-
-function layer(base: CueloopConfig, raw: Record<string, unknown>): CueloopConfig {
-  const out: CueloopConfig = {
-    keys: { ...base.keys },
-    theme: { ...base.theme },
-    integrations: { obsidian: { ...base.integrations.obsidian } },
-  };
-  const keys = raw["keys"] as KeymapConfig | undefined;
-  if (keys) {
-    for (const [action, combo] of Object.entries(keys)) {
-      out.keys[action] = Array.isArray(combo) ? combo : [combo];
-    }
-  }
-  const theme = raw["theme"] as Partial<Record<keyof Theme, string>> | undefined;
-  if (theme) {
-    for (const [token, value] of Object.entries(theme)) {
-      if (token in out.theme && typeof value === "string") {
-        (out.theme as unknown as Record<string, string>)[token] = value;
-      }
-    }
-  }
-  const integrations = raw["integrations"] as Record<string, unknown> | undefined;
-  const obsidian = integrations?.["obsidian"] as Record<string, unknown> | undefined;
-  if (obsidian) {
-    const o = out.integrations.obsidian;
-    if (typeof obsidian["vault"] === "string") o.vault = obsidian["vault"];
-    if (typeof obsidian["folder"] === "string") o.folder = obsidian["folder"];
-    if (typeof obsidian["filenameFormat"] === "string") o.filenameFormat = obsidian["filenameFormat"];
-    const sep = obsidian["separator"];
-    if (sep === "space" || sep === "dash" || sep === "underscore") o.separator = sep;
-    const on = obsidian["exportOn"];
-    if (on === "approve" || on === "resolve" || on === "manual") o.exportOn = on;
-  }
-  return out;
-}
-
-export function loadConfig(opts: { repoRoot?: string; userConfigPath?: string } = {}): CueloopConfig {
-  let config: CueloopConfig = {
-    keys: { ...DEFAULT_KEYS },
-    theme: { ...DARK },
-    integrations: { obsidian: { ...OBSIDIAN_DEFAULTS } },
-  };
-  const userPath =
-    opts.userConfigPath ??
-    process.env.CUELOOP_CONFIG ??
-    join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "cueloop", "config.toml");
-  for (const path of [userPath, opts.repoRoot ? join(opts.repoRoot, ".cueloop", "config.toml") : undefined]) {
-    if (!path || !existsSync(path)) continue;
-    try {
-      config = layer(config, parseToml(readFileSync(path, "utf8")));
-    } catch {
-      // a broken config never blocks a review; defaults win
-    }
-  }
-  return config;
-}
-
-/** Reverse lookup: key name (+shift) → action, per the loaded keymap. */
-export function actionFor(keys: Record<string, string[]>, name: string, shift: boolean): string | undefined {
-  const wanted = shift && name.length === 1 ? name.toUpperCase() : name;
-  for (const [action, combos] of Object.entries(keys)) {
-    if (combos.includes(wanted)) return action;
-  }
-  return undefined;
-}

package/src/editor.ts

@@ -1,34 +0,0 @@
-/**
- * File-level edit mode = the $EDITOR hand-off (#22, #11): write the working
- * copy to a temp file, run the user's editor on it, read the result back.
- * Tests point CUELOOP_EDITOR at a non-interactive command.
- */
-
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-export interface EditResult {
-  content: string;
-  changed: boolean;
-}
-
-export function editInEditor(content: string, filename = "plan.md"): EditResult {
-  const editor = process.env.CUELOOP_EDITOR ?? process.env.VISUAL ?? process.env.EDITOR;
-  if (!editor) throw new Error("no editor: set $EDITOR (or $CUELOOP_EDITOR)");
-  const dir = mkdtempSync(join(tmpdir(), "cueloop-edit-"));
-  const path = join(dir, filename);
-  writeFileSync(path, content);
-  try {
-    const proc = Bun.spawnSync([...editor.split(" "), path], {
-      stdin: "inherit",
-      stdout: "inherit",
-      stderr: "inherit",
-    });
-    if (proc.exitCode !== 0) throw new Error(`editor exited ${proc.exitCode}`);
-    const next = readFileSync(path, "utf8");
-    return { content: next, changed: next !== content };
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-}

package/src/run.ts

@@ -1,28 +0,0 @@
-/** Real-terminal entry: render the App and resolve when the user quits. */
-
-import React from "react";
-import { createCliRenderer } from "@opentui/core";
-import { createRoot } from "@opentui/react";
-import { App } from "./App";
-
-export interface RunClientOptions {
-  sessionId?: string;
-  home?: string;
-}
-
-export async function runClient(opts: RunClientOptions): Promise<number> {
-  const renderer = await createCliRenderer();
-  return new Promise<number>((resolve) => {
-    createRoot(renderer).render(
-      React.createElement(App, {
-        home: opts.home,
-        sessionId: opts.sessionId,
-        onExit: (code: number) => {
-          renderer.destroy();
-          resolve(code);
-          process.exit(code);
-        },
-      }),
-    );
-  });
-}

package/src/serve.ts

@@ -1,75 +0,0 @@
-/**
- * SSH-served TUI (#22 share path): `cueloop serve` lets teammates join a
- * review session over plain ssh. Every SSH connection renders <App> in
- * observer mode (readOnly) against the same local daemon; the one writable
- * controller stays the local owner's own `cueloop` TUI.
- *
- * Trust model - tunnel of trust, no passwords, no keys:
- * the server authenticates nobody ("open" auth). Access control is the act of
- * sharing the address deliberately: it binds to 127.0.0.1 by default, so a
- * remote teammate reaches it only through a channel the owner opened on
- * purpose (an SSH tunnel, a tailnet address via --host). Anyone who can reach
- * the port can watch - and only watch: observers cannot mutate the session.
- * The host key is generated once under CUELOOP_HOME/ssh/host_key (0600) so
- * fingerprints stay stable across restarts.
- */
-
-import { mkdirSync } from "node:fs";
-import { join } from "node:path";
-import React from "react";
-import { createRoot } from "@opentui/react";
-import { createServer } from "@opentui/ssh";
-import { cueloopHome } from "@cueloop/daemon";
-import { App } from "./App";
-
-export interface ServeOptions {
-  /** TCP port for the SSH listener; 0 picks an ephemeral port. Default 2222. */
-  port?: number;
-  /** Bind address. Default 127.0.0.1 - widen deliberately (e.g. a tailnet IP). */
-  host?: string;
-  /** Open every connection on this session; omit for the inbox. */
-  sessionId?: string;
-  /** CUELOOP_HOME override (daemon socket + ssh host key live under it). */
-  home?: string;
-  /** Silence the @opentui/ssh startup banner (tests). Default true. */
-  banner?: boolean;
-  onError?: (err: unknown) => void;
-}
-
-export interface ServeHandle {
-  host: string;
-  port: number;
-  /** SHA256 host-key fingerprints, for out-of-band verification. */
-  fingerprints: string[];
-  close(): Promise<void>;
-}
-
-export async function serveClient(opts: ServeOptions = {}): Promise<ServeHandle> {
-  const home = opts.home ?? cueloopHome();
-  const sshDir = join(home, "ssh");
-  mkdirSync(sshDir, { recursive: true, mode: 0o700 });
-
-  const server = createServer({
-    // password-less by design; see the trust model in the module comment
-    auth: "open",
-    hostKey: { path: join(sshDir, "host_key") },
-    startupBanner: opts.banner ?? true,
-    idleTimeout: "2h",
-    onError: opts.onError,
-  }).serve((session) => {
-    const root = createRoot(session.renderer);
-    root.render(
-      React.createElement(App, {
-        home,
-        sessionId: opts.sessionId,
-        readOnly: true,
-        // q disconnects only this observer, never the server
-        onExit: () => session.end(),
-      }),
-    );
-    session.onClose(() => root.unmount());
-  });
-
-  const info = await server.listen(opts.port ?? 2222, opts.host ?? "127.0.0.1");
-  return { ...info, close: () => server.close() };
-}

package/src/theme.ts

@@ -1,46 +0,0 @@
-/**
- * Semantic theme tokens (#22). Values carry over from the design-system
- * prototypes (tokens.css). One built-in dark theme for now; the theme
- * registry (palette-derived themes, terminal theme, user overrides) layers
- * on top of these slots without touching consumers.
- */
-
-export interface Theme {
-  bg: string;
-  panel: string;
-  elevated: string;
-  border: string;
-  text: string;
-  textMuted: string;
-  textDim: string;
-  accent: string;
-  accentInk: string;
-  green: string;
-  red: string;
-  blue: string;
-  cursorBg: string;
-  markCommentBg: string;
-  markSuggestionBg: string;
-  insFg: string;
-  delFg: string;
-}
-
-export const DARK: Theme = {
-  bg: "#1f1f29",
-  panel: "#1a1a23",
-  elevated: "#23232f",
-  border: "#3a3a4a",
-  text: "#e4e6ec",
-  textMuted: "#b1b6c4",
-  textDim: "#6b7280",
-  accent: "#f5a3a3",
-  accentInk: "#2a1416",
-  green: "#62d96b",
-  red: "#ff6b6b",
-  blue: "#84a6e8",
-  cursorBg: "#33262a",
-  markCommentBg: "#3d2a2e",
-  markSuggestionBg: "#20351f",
-  insFg: "#62d96b",
-  delFg: "#ff6b6b",
-}

package/src/view-diff.test.ts

@@ -1,55 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { diffRowAnchor, diffRows } from "./view-diff";
-
-const PATCH = `diff --git a/src/store.ts b/src/store.ts
-index 111..222 100644
---- a/src/store.ts
-+++ b/src/store.ts
-@@ -1,5 +1,6 @@
- import { join } from "node:path";
- export class Store {
--  private items = [];
-+  private items = new Map();
-+  private ready = false;
-   constructor() {}
-@@ -20,3 +21,3 @@
- export function helper() {
--  return 1;
-+  return 2;
- }
-`;
-
-describe("diffRows", () => {
-  test("flattens files, hunks, and signed lines with line numbers", () => {
-    const rows = diffRows(PATCH);
-    expect(rows[0]).toMatchObject({ t: "file", file: "src/store.ts" });
-    expect(rows[1]!.t).toBe("hunk");
-    const del = rows.find((r) => r.t === "del")!;
-    expect(del.text).toContain("private items = [];");
-    expect(del.oldLine).toBe(3);
-    const adds = rows.filter((r) => r.t === "add");
-    expect(adds[0]!.text).toContain("new Map()");
-    expect(adds[0]!.newLine).toBe(3);
-    expect(adds[1]!.newLine).toBe(4);
-    // two hunks
-    expect(rows.filter((r) => r.t === "hunk").length).toBe(2);
-  });
-
-  test("context lines carry both line numbers", () => {
-    const rows = diffRows(PATCH);
-    const ctx = rows.find((r) => r.t === "ctx")!;
-    expect(ctx.oldLine).toBe(1);
-    expect(ctx.newLine).toBe(1);
-  });
-});
-
-describe("diffRowAnchor", () => {
-  test("quote is the line, neighbors are the context selectors", () => {
-    const rows = diffRows(PATCH);
-    const idx = rows.findIndex((r) => r.text.includes("new Map()"));
-    const anchor = diffRowAnchor(rows, idx);
-    expect(anchor.quote).toContain("new Map()");
-    expect(anchor.prefix.length).toBeGreaterThan(0);
-    expect(anchor.suffix.length).toBeGreaterThan(0);
-  });
-});

package/src/view-diff.ts

@@ -1,86 +0,0 @@
-/**
- * Diff artifact projection (#18 slice 3): flatten @pierre/diffs' parsed
- * patch model into render rows. Line-anchored annotations use the same
- * quote-primary anchors as plans: quote = the line content, prefix/suffix =
- * the neighbor lines - so the whole anchor/feedback pipeline is shared.
- */
-
-import { parsePatchFiles, type FileDiffMetadata } from "@pierre/diffs";
-
-export type DiffRowType = "file" | "hunk" | "ctx" | "add" | "del";
-
-export interface DiffRow {
-  t: DiffRowType;
-  text: string;
-  file: string;
-  oldLine?: number;
-  newLine?: number;
-}
-
-export function diffRows(patchText: string): DiffRow[] {
-  const rows: DiffRow[] = [];
-  const patches = parsePatchFiles(patchText);
-  for (const patch of patches) {
-    for (const file of patch.files) {
-      rows.push({ t: "file", text: fileLabel(file), file: file.name });
-      for (const hunk of file.hunks) {
-        rows.push({ t: "hunk", text: hunk.hunkSpecs ?? "@@", file: file.name });
-        let oldLine = hunk.deletionStart;
-        let newLine = hunk.additionStart;
-        for (const seg of hunk.hunkContent) {
-          if (seg.type === "context") {
-            for (let i = 0; i < seg.lines; i++) {
-              rows.push({
-                t: "ctx",
-                text: file.additionLines[seg.additionLineIndex + i] ?? "",
-                file: file.name,
-                oldLine: oldLine++,
-                newLine: newLine++,
-              });
-            }
-          } else {
-            for (let i = 0; i < seg.deletions; i++) {
-              rows.push({
-                t: "del",
-                text: file.deletionLines[seg.deletionLineIndex + i] ?? "",
-                file: file.name,
-                oldLine: oldLine++,
-              });
-            }
-            for (let i = 0; i < seg.additions; i++) {
-              rows.push({
-                t: "add",
-                text: file.additionLines[seg.additionLineIndex + i] ?? "",
-                file: file.name,
-                newLine: newLine++,
-              });
-            }
-          }
-        }
-      }
-    }
-  }
-  return rows;
-}
-
-function fileLabel(file: FileDiffMetadata): string {
-  return file.prevName && file.prevName !== file.name ? `${file.prevName} → ${file.name}` : file.name;
-}
-
-/** Quote-primary anchor for a diff row: neighbors as context selectors. */
-export function diffRowAnchor(rows: DiffRow[], idx: number): { quote: string; prefix: string; suffix: string } {
-  const row = rows[idx]!;
-  const prev = rows[idx - 1];
-  const next = rows[idx + 1];
-  return {
-    quote: row.text,
-    prefix: prev && (prev.t === "ctx" || prev.t === "add" || prev.t === "del") ? prev.text.slice(-24) : "",
-    suffix: next && (next.t === "ctx" || next.t === "add" || next.t === "del") ? next.text.slice(0, 24) : "",
-  };
-}
-
-/** Location label for the rail and feedback: file:newLine (or old for del). */
-export function diffRowLocation(row: DiffRow): string {
-  const line = row.newLine ?? row.oldLine;
-  return line !== undefined ? `${row.file}:${line}` : row.file;
-}

package/src/view.test.ts

@@ -1,157 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import {
-  blockRuns,
-  buildDisplay,
-  cutBlock,
-  displayText,
-  marksByDisplay,
-  overlayMarks,
-  restoreBlock,
-  restoreLine,
-  spanKey,
-  startSpan,
-  wrapRuns,
-} from "./view";
-import { parseBlocks, type Annotation } from "@cueloop/schema";
-
-const BASE = `# Plan
-
-## Context
-
-The daemon persists sessions to disk atomically.
-
-- first item
-- second item
-`;
-
-describe("buildDisplay reconciliation", () => {
-  test("no working copy: everything is same", () => {
-    const d = buildDisplay(BASE);
-    expect(d.every((x) => x.type === "same")).toBe(true);
-  });
-
-  test("reworded block pairs as mod (similar)", () => {
-    const working = BASE.replace("persists sessions to disk", "writes sessions to disk");
-    const d = buildDisplay(BASE, working);
-    const mod = d.find((x) => x.type === "mod")!;
-    expect(mod.base!.text).toContain("persists");
-    expect(mod.work!.text).toContain("writes");
-  });
-
-  test("unrelated cut + insert do NOT merge into a mod", () => {
-    const working = BASE.replace("- second item\n", "") + "\nA totally new closing note.\n";
-    const d = buildDisplay(BASE, working);
-    expect(d.some((x) => x.type === "del" && x.base!.text === "second item")).toBe(true);
-    expect(d.some((x) => x.type === "add" && x.work!.text.includes("closing note"))).toBe(true);
-    expect(d.some((x) => x.type === "mod")).toBe(false);
-  });
-
-  test("ordered list items get running numbers", () => {
-    const d = buildDisplay("1. one\n2. two\n3. three\n");
-    expect(d.map((x) => x.oliNum)).toEqual([1, 2, 3]);
-  });
-});
-
-describe("blockRuns + overlayMarks", () => {
-  test("mod blocks emit word-diff runs that reconstruct both sides", () => {
-    const d = buildDisplay("plain old text here\n", "plain new text here\n")[0]!;
-    const runs = blockRuns(d, true);
-    const oldSide = runs.filter((r) => r.role !== "ins").map((r) => r.text).join("");
-    const newSide = runs.filter((r) => r.role !== "del").map((r) => r.text).join("");
-    expect(oldSide).toBe("plain old text here");
-    expect(newSide).toBe("plain new text here");
-  });
-
-  test("marks bind to working-text offsets and skip del runs", () => {
-    const d = buildDisplay("old words linger\n", "new words linger\n")[0]!;
-    const runs = blockRuns(d, true);
-    const marked = overlayMarks(runs, [{ start: 4, end: 9, role: "mark-comment" }]); // "words"
-    const markedText = marked.filter((r) => r.role === "mark-comment").map((r) => r.text).join("");
-    expect(markedText).toBe("words");
-    // del run text untouched
-    expect(marked.some((r) => r.role === "del" && r.text === "old")).toBe(true);
-  });
-
-  test("marks never override ins emphasis", () => {
-    const d = buildDisplay("keep\n", "keep added\n")[0]!;
-    const runs = overlayMarks(blockRuns(d, true), [{ start: 0, end: 10, role: "mark-comment" }]);
-    expect(runs.some((r) => r.role === "ins")).toBe(true);
-  });
-});
-
-describe("marksByDisplay", () => {
-  test("annotations resolve into display coordinates", () => {
-    const working = BASE.replace("first item", "first item edited beyond recognition of it");
-    const display = buildDisplay(BASE, working);
-    const ann: Annotation = {
-      id: "a1",
-      kind: "comment",
-      anchor: { quote: "atomically", prefix: "to disk ", suffix: "." },
-      body: "define atomically",
-      createdAt: "",
-    };
-    const map = marksByDisplay([ann], display);
-    const [dispIdx, marks] = [...map.entries()][0]!;
-    expect(displayText(display[dispIdx]!)).toContain("atomically");
-    expect(marks[0]!.annotationId).toBe("a1");
-  });
-
-  test("orphaned annotations produce no marks", () => {
-    const display = buildDisplay(BASE);
-    const ann: Annotation = {
-      id: "a1",
-      kind: "comment",
-      anchor: { quote: "text that is gone", prefix: "", suffix: "" },
-      body: "",
-      createdAt: "",
-    };
-    expect(marksByDisplay([ann], display).size).toBe(0);
-  });
-});
-
-describe("wrapRuns", () => {
-  test("wraps at word boundaries within width", () => {
-    const lines = wrapRuns([{ text: "alpha beta gamma delta", role: "plain", start: 0 }], 11);
-    const rendered = lines.map((l) => l.map((r) => r.text).join(""));
-    expect(rendered.every((l) => l.length <= 11)).toBe(true);
-    expect(rendered.join(" ").replace(/\s+/g, " ").trim()).toBe("alpha beta gamma delta");
-  });
-
-  test("hard-splits words longer than the width", () => {
-    const lines = wrapRuns([{ text: "abcdefghij", role: "plain", start: 0 }], 4);
-    expect(lines.length).toBeGreaterThan(1);
-  });
-
-  test("newlines force line breaks (code blocks)", () => {
-    const lines = wrapRuns([{ text: "line1\nline2", role: "plain", start: 0 }], 80);
-    expect(lines.length).toBe(2);
-  });
-});
-
-describe("span mode", () => {
-  const text = "one two three four";
-  test("v selects the first word; l grows; w slides; $ to end", () => {
-    let s = startSpan(0, text)!;
-    expect(text.slice(s.start, s.end)).toBe("one");
-    s = spanKey(s, "l", text);
-    expect(text.slice(s.start, s.end)).toBe("one two");
-    s = spanKey(s, "w", text);
-    expect(text.slice(s.start, s.end)).toBe("two three");
-    s = spanKey(s, "$", text);
-    expect(text.slice(s.start, s.end)).toBe("two three four");
-  });
-});
-
-describe("cut / restore round-trip", () => {
-  test("cut removes the block lines; restore puts them back", () => {
-    const blocks = parseBlocks(BASE);
-    const li = blocks.find((b) => b.text === "second item")!;
-    const cut = cutBlock(BASE, li);
-    expect(cut).not.toContain("second item");
-    const display = buildDisplay(BASE, cut);
-    const delIdx = display.findIndex((d) => d.type === "del");
-    const line = restoreLine(display, delIdx, cut.split("\n").length);
-    const restored = restoreBlock(cut, "- second item", line);
-    expect(buildDisplay(BASE, restored).every((d) => d.type === "same")).toBe(true);
-  });
-});