@cueloop/client 0.1.0-alpha.9 → 0.1.0-alpha.91

package/src/components/thread-tree.ts

@@ -0,0 +1,109 @@
+/**
+ * Groups the pending inbox into Projects and Threads for the sidebar. Threads
+ * whose workspace carries a rootCommit gather under their project (keyed by that
+ * commit, so moving or re-cloning the repo never forks it); the rest are
+ * standalone Threads. The flat `ordered` sequence is what the inbox cursor
+ * walks, so the keyboard grammar keeps a single index across the two groups.
+ */
+
+import type { Thread, WorkspaceKey } from "@cueloop/schema";
+
+/** A repo's display name: the remote basename when present, else the working-tree folder name. */
+export function projectName(workspace: WorkspaceKey): string {
+  const { remote, repoRoot } = workspace;
+
+  if (remote !== undefined) {
+    const cleaned = remote.replace(/\.git$/, "").replace(/\/+$/, "");
+    const base = cleaned
+      .split(/[/:]/)
+      .filter((part) => part.length > 0)
+      .at(-1);
+    if (base !== undefined) return base;
+  }
+
+  const dir = repoRoot
+    .replace(/\/+$/, "")
+    .split("/")
+    .filter((part) => part.length > 0)
+    .at(-1);
+
+  return dir ?? repoRoot;
+}
+
+export type InboxRow =
+  | { kind: "section"; id: string; label: string }
+  | { kind: "project"; id: string; label: string }
+  | { kind: "thread"; id: string; session: Thread; selectionIndex: number; depth: number };
+
+export interface GroupedInbox {
+  rows: InboxRow[];
+  /** Threads in display order; the inbox cursor indexes this. */
+  ordered: Thread[];
+}
+
+function threadTitle(session: Thread): string {
+  return session.artifact.meta.title ?? session.id;
+}
+
+interface ProjectGroup {
+  name: string;
+  sessions: Thread[];
+}
+
+/** Group pending sessions into Pinned, then Projects (by root commit), then standalone Threads. */
+export function groupInbox(
+  sessions: readonly Thread[],
+  pinnedIds?: ReadonlySet<string>,
+): GroupedInbox {
+  const pinned: Thread[] = [];
+  const projects = new Map<string, ProjectGroup>();
+  const standalone: Thread[] = [];
+
+  for (const session of sessions) {
+    if (pinnedIds?.has(session.id) === true) {
+      pinned.push(session);
+      continue;
+    }
+
+    const key = session.workspace.rootCommit;
+    if (key === undefined) {
+      standalone.push(session);
+      continue;
+    }
+
+    const existing = projects.get(key);
+    if (existing !== undefined) existing.sessions.push(session);
+    else projects.set(key, { name: projectName(session.workspace), sessions: [session] });
+  }
+
+  const rows: InboxRow[] = [];
+  const ordered: Thread[] = [];
+  const pushThread = (session: Thread, depth: number): void => {
+    rows.push({ kind: "thread", id: session.id, session, selectionIndex: ordered.length, depth });
+    ordered.push(session);
+  };
+
+  if (pinned.length > 0) {
+    rows.push({ kind: "section", id: "section:pinned", label: "Starred" });
+    for (const session of pinned) pushThread(session, 1);
+  }
+
+  const projectEntries = [...projects.entries()].sort((a, b) => a[1].name.localeCompare(b[1].name));
+  if (projectEntries.length > 0) {
+    rows.push({ kind: "section", id: "section:projects", label: "Projects" });
+    for (const [key, project] of projectEntries) {
+      rows.push({ kind: "project", id: `project:${key}`, label: project.name });
+      // a project's threads cascade one level under its name
+      for (const session of project.sessions) pushThread(session, 2);
+    }
+  }
+
+  if (standalone.length > 0) {
+    rows.push({ kind: "section", id: "section:threads", label: "Threads" });
+    for (const session of standalone) pushThread(session, 1);
+  }
+
+  return { rows, ordered };
+}
+
+export { threadTitle };

package/src/components/truncate-text.ts

@@ -0,0 +1,7 @@
+/** Truncate text to one line of at most maxLength characters, ellipsis-terminated. */
+
+export function truncateToSingleLine(value: string, maxLength: number): string {
+  const oneLine = value.replace(/\n/g, " ");
+
+  return oneLine.length > maxLength ? oneLine.slice(0, maxLength - 1) + "…" : oneLine;
+}

package/src/components/truncate-title.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, test } from "bun:test";
+import { truncateTitle } from "./truncate-title";
+
+describe("truncateTitle", () => {
+  test("a title that fits is returned unchanged", () => {
+    expect(truncateTitle("short", 20)).toBe("short");
+  });
+
+  test("a long title is clipped to the width with a trailing ellipsis", () => {
+    const clipped = truncateTitle("Review the accent change in the theme", 20);
+
+    expect(clipped).toHaveLength(20);
+    expect(clipped.endsWith("…")).toBe(true);
+    expect(clipped).toBe("Review the accent c…");
+  });
+
+  test("newlines collapse to spaces so the row never wraps", () => {
+    expect(truncateTitle("line one\nline two", 40)).toBe("line one line two");
+  });
+
+  test("a zero width yields an empty string", () => {
+    expect(truncateTitle("anything", 0)).toBe("");
+  });
+
+  test("clips by code point, never splitting an astral character into a replacement glyph", () => {
+    const clipped = truncateTitle("🚀🚀🚀🚀🚀", 3);
+
+    expect(clipped).toBe("🚀🚀…");
+    expect(clipped).not.toContain("�");
+  });
+});

package/src/components/truncate-title.ts

@@ -0,0 +1,15 @@
+/**
+ * Fits a thread title on one line: unchanged when it fits, otherwise clipped to
+ * an ellipsis. Slices by code point, not UTF-16 unit, so an emoji or other
+ * astral character is never split into a replacement glyph.
+ */
+export function truncateTitle(title: string, maxWidth: number): string {
+  const oneLine = title.replace(/\n/g, " ");
+
+  if (maxWidth <= 0) return "";
+  const characters = [...oneLine];
+
+  if (characters.length <= maxWidth) return oneLine;
+
+  return `${characters.slice(0, Math.max(0, maxWidth - 1)).join("")}…`;
+}

package/src/config-identity.test.ts

@@ -0,0 +1,78 @@
+import { expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { loadConfig, persistIdentity } from "./config";
+
+function withTempConfig(run: (path: string) => void): void {
+  const directory = mkdtempSync(join(tmpdir(), "cueloop-config-"));
+
+  try {
+    run(join(directory, "config.toml"));
+  } finally {
+    rmSync(directory, { recursive: true, force: true });
+  }
+}
+
+test("defaults identity to a typed provider with no name", () => {
+  withTempConfig((path) => {
+    expect(loadConfig({ userConfigPath: path }).identity).toEqual({ provider: "typed" });
+  });
+});
+
+test("persists and reloads a GitHub-synced identity", () => {
+  withTempConfig((path) => {
+    persistIdentity({ name: "Markus M", provider: "github" }, path);
+
+    expect(loadConfig({ userConfigPath: path }).identity).toEqual({
+      name: "Markus M",
+      provider: "github",
+    });
+  });
+});
+
+test("rewrites the identity block in place on a re-sync", () => {
+  withTempConfig((path) => {
+    persistIdentity({ name: "typed name", provider: "typed" }, path);
+    persistIdentity({ name: "markus", provider: "github" }, path);
+
+    expect(loadConfig({ userConfigPath: path }).identity).toEqual({
+      name: "markus",
+      provider: "github",
+    });
+  });
+});
+
+test("a display name containing a bracket survives a re-sync without corrupting the config", () => {
+  withTempConfig((path) => {
+    persistIdentity({ name: "Alice [Smith]", provider: "typed" }, path);
+    persistIdentity({ name: "Bob", provider: "github" }, path);
+
+    expect(loadConfig({ userConfigPath: path }).identity).toEqual({
+      name: "Bob",
+      provider: "github",
+    });
+  });
+});
+
+test("repository config cannot forge the reviewer identity", () => {
+  withTempConfig((userPath) => {
+    persistIdentity({ name: "Me", provider: "typed" }, userPath);
+    const repoRoot = mkdtempSync(join(tmpdir(), "cueloop-repo-"));
+
+    try {
+      mkdirSync(join(repoRoot, ".cueloop"), { recursive: true });
+      writeFileSync(
+        join(repoRoot, ".cueloop", "config.toml"),
+        '[identity]\nname = "Forged"\nprovider = "github"\n',
+      );
+
+      expect(loadConfig({ userConfigPath: userPath, repoRoot }).identity).toEqual({
+        name: "Me",
+        provider: "typed",
+      });
+    } finally {
+      rmSync(repoRoot, { recursive: true, force: true });
+    }
+  });
+});