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

package/src/syntax.test.ts

@@ -1,41 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { filetypeFor, highlightCode } from "./syntax";
-
-const TS = `export function gate(full: number) {
-  // threshold
-  return full < 0.6 ? "blocked" : "clear";
-}`;
-
-describe("highlightCode", () => {
-  test("token text concatenates back to the exact source (verbatim rendering)", async () => {
-    const lines = await highlightCode(TS, "ts");
-    expect(lines).not.toBeNull();
-    const rebuilt = lines!.map((l) => l.map((t) => t.content).join("")).join("\n");
-    expect(rebuilt).toBe(TS);
-  });
-
-  test("keywords, strings, and comments get distinct colors", async () => {
-    const lines = await highlightCode(TS, "ts");
-    const colorOf = (needle: string) => {
-      for (const line of lines!) for (const t of line) if (t.content.includes(needle)) return t.color;
-      return undefined;
-    };
-    const kw = colorOf("export");
-    const str = colorOf("blocked");
-    const comment = colorOf("threshold");
-    expect(kw).toBeDefined();
-    expect(str).toBeDefined();
-    expect(comment).toBeDefined();
-    expect(new Set([kw, str, comment]).size).toBe(3);
-  });
-
-  test("unknown languages return null and render unstyled", async () => {
-    expect(await highlightCode("whatever", "brainfog")).toBeNull();
-    expect(await highlightCode("plain", undefined)).toBeNull();
-  });
-
-  test("fence aliases map to real grammars", async () => {
-    expect(await highlightCode("x = 1", "py")).not.toBeNull();
-    expect(await highlightCode('echo "hi"', "sh")).not.toBeNull();
-  });
-});

package/src/syntax.ts

@@ -1,88 +0,0 @@
-/**
- * Code-block syntax highlighting via Shiki (#67): TextMate-grammar tokens
- * colored by a theme built from cueloop's tokens. The highlighter loads
- * lazily on the first code block; unknown languages render unstyled.
- */
-
-import { DARK as T } from "./theme";
-
-export interface CodeToken {
-  content: string;
-  color?: string;
-}
-
-type Highlighter = {
-  codeToTokensBase(code: string, opts: { lang: string; theme: string }): { content: string; color?: string }[][];
-  getLoadedLanguages(): string[];
-};
-
-const LANGS = ["typescript", "tsx", "javascript", "jsx", "json", "bash", "python", "rust", "go", "yaml", "diff", "markdown", "toml", "sql", "html", "css"];
-
-/** Markdown fence info → Shiki language id. */
-export function filetypeFor(lang?: string): string {
-  const l = (lang ?? "").toLowerCase();
-  const map: Record<string, string> = {
-    ts: "typescript",
-    js: "javascript",
-    py: "python",
-    rb: "ruby",
-    rs: "rust",
-    sh: "bash",
-    shell: "bash",
-    zsh: "bash",
-    yml: "yaml",
-  };
-  return map[l] ?? l;
-}
-
-function cueloopTheme() {
-  const scope = (scopes: string, foreground: string, fontStyle?: string) => ({
-    scope: scopes.split(", "),
-    settings: fontStyle ? { foreground, fontStyle } : { foreground },
-  });
-  return {
-    name: "cueloop",
-    type: "dark" as const,
-    colors: { "editor.background": T.elevated, "editor.foreground": T.textMuted },
-    settings: [
-      { settings: { foreground: T.textMuted } },
-      scope("comment, punctuation.definition.comment", T.textDim, "italic"),
-      scope("string, string.quoted, punctuation.definition.string", T.green),
-      scope("constant.numeric, constant.language, constant.character", T.blue),
-      scope("keyword, storage, storage.type, storage.modifier, keyword.control", T.accent),
-      scope("entity.name.function, support.function, meta.function-call", T.text),
-      scope("entity.name.type, entity.name.class, support.type, support.class", T.blue),
-      scope("variable, variable.other, variable.parameter", T.textMuted),
-      scope("entity.name.tag", T.accent),
-      scope("entity.other.attribute-name", T.blue),
-      scope("punctuation, meta.brace", T.textDim),
-      scope("keyword.operator", T.textDim),
-    ],
-  };
-}
-
-let highlighterPromise: Promise<Highlighter | null> | null = null;
-
-function getHighlighter(): Promise<Highlighter | null> {
-  highlighterPromise ??= import("shiki")
-    .then((shiki) => shiki.createHighlighter({ themes: [cueloopTheme()], langs: LANGS }) as Promise<Highlighter>)
-    .catch(() => null); // highlighting is an enhancement, never a blocker
-  return highlighterPromise;
-}
-
-/**
- * Tokenize code into styled lines. Token text concatenates back to the exact
- * source line, so verbatim rendering (indentation, no wrap) is preserved.
- * Returns null when the language is unknown or the highlighter is unavailable.
- */
-export async function highlightCode(content: string, lang?: string): Promise<CodeToken[][] | null> {
-  const language = filetypeFor(lang);
-  if (!language) return null;
-  const highlighter = await getHighlighter();
-  if (!highlighter || !highlighter.getLoadedLanguages().includes(language)) return null;
-  try {
-    return highlighter.codeToTokensBase(content, { lang: language, theme: "cueloop" });
-  } catch {
-    return null;
-  }
-}

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,
-  displayText,
-  marksByDisplay,
-  nextWorkBlock,
-  overlayMarks,
-  spanKey,
-  startSpan,
-  wrapRuns,
-} from "./view";
-import { cutBlock, parseBlocks, restoreBlock, restoreLine, 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(nextWorkBlock(display, delIdx), cut.split("\n").length);
-    // undefined = the working copy round-tripped back to the submitted revision
-    const restored = restoreBlock(BASE, cut, li, line);
-    expect(restored).toBeUndefined();
-    expect(buildDisplay(BASE, restored).every((d) => d.type === "same")).toBe(true);
-  });
-});