ompchamber 1.2.1 → 2.0.1

package/src/client/hooks/workspace/repo-scope/store.ts

@@ -0,0 +1,201 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Nested-repo discovery store, keyed by workspace root.
+ *
+ * The leak this module exists to prevent: a repo is a path RELATIVE to a root
+ * (`projects/jns6_5/token` only names a directory under `~/JatisMobile/Workspace`),
+ * so a list discovered for one workspace is meaningless under another. Keying
+ * every entry by the root it was discovered for makes that structural — a new
+ * root has no entry and starts from {@link UNKNOWN_LIST} instead of inheriting
+ * the previous list.
+ *
+ * A store rather than a fetch per hook: the right-panel views ask the same
+ * question about the same root, and independent copies meant one request per
+ * panel per poll interval plus lists that could disagree.
+ *
+ * Both platform dependencies are injected — `fetch` and the retry scheduler —
+ * so the invalidation rules are testable without a DOM and without wall-clock
+ * timers.
+ */
+
+import { REPO_DISCOVERY_POLL_MS } from '@/shared/lib/workspace/refresh-cadence';
+import { isRecord } from '@/shared/lib/util/guards';
+
+export interface RepoListSnapshot {
+  repos: string[];
+  /** Discovery is still running server-side, or a forced rescan is. */
+  scanning: boolean;
+}
+
+/** The list before discovery has answered: the workspace root alone. */
+export const UNKNOWN_LIST: RepoListSnapshot = { repos: ['.'], scanning: false };
+
+/** `fetch` seam: resolves the parsed `?reposOnly=1` payload, rejects on error. */
+export type RepoFetch = (url: string) => Promise<unknown>;
+
+/**
+ * Retry seam. Runs `run` once after `delayMs` and returns a cancel; the default
+ * is a one-shot timer, and the caller re-arms it per attempt.
+ */
+export type RepoScheduler = (run: () => void, delayMs: number) => () => void;
+
+interface RootEntry {
+  snapshot: RepoListSnapshot;
+  /** True once a discovery response was accepted for this root. Drives the
+   *  "start discovery on first subscriber" decision — object identity of
+   *  `snapshot` cannot, because clearing the spinner mints a new one. */
+  loaded: boolean;
+  listeners: Set<() => void>;
+  controller: AbortController | null;
+  cancelRetry: (() => void) | null;
+  /** The discovery currently in flight, so a caller can await its settlement. */
+  pending: Promise<void> | null;
+}
+
+export interface RepoStore {
+  /** Repos discovered for `root`; {@link UNKNOWN_LIST} until one is. */
+  snapshot: (root: string) => RepoListSnapshot;
+  /** Await the discovery in flight for `root` (a no-op when there is none). */
+  settled: (root: string) => Promise<void>;
+  /** Observe `root`; the first subscriber starts discovery. Returns a cancel. */
+  subscribe: (root: string, listener: () => void) => () => void;
+  /** Re-run discovery for `root` from scratch, ignoring any cached result. */
+  rescan: (root: string) => void;
+}
+
+export interface RepoStoreOptions {
+  fetch: RepoFetch;
+  scheduler?: RepoScheduler;
+}
+
+const defaultScheduler: RepoScheduler = (run, delayMs) => {
+  const id = setTimeout(run, delayMs);
+  return () => clearTimeout(id);
+};
+
+export function createRepoStore({ fetch: fetchImpl, scheduler = defaultScheduler }: RepoStoreOptions): RepoStore {
+  // Per-store, not module-level: two stores must not share state, and a test
+  // store must not see the app store's roots.
+  const entries = new Map<string, RootEntry>();
+
+  function entryFor(root: string): RootEntry {
+    let entry = entries.get(root);
+    if (!entry) {
+      entry = {
+        snapshot: UNKNOWN_LIST,
+        loaded: false,
+        listeners: new Set(),
+        controller: null,
+        cancelRetry: null,
+        pending: null,
+      };
+      entries.set(root, entry);
+    }
+    return entry;
+  }
+
+  function publish(root: string, patch: Partial<RepoListSnapshot>): void {
+    const entry = entries.get(root);
+    if (!entry) return;
+    const next = { ...entry.snapshot, ...patch };
+    if (next.repos === entry.snapshot.repos && next.scanning === entry.snapshot.scanning) return;
+    entry.snapshot = next;
+    for (const listener of entry.listeners) listener();
+  }
+
+  function cancelRetry(entry: RootEntry): void {
+    entry.cancelRetry?.();
+    entry.cancelRetry = null;
+  }
+
+  function load(root: string, rescan: boolean): Promise<void> {
+    const entry = entryFor(root);
+    // A newer load supersedes this one: its response must not overwrite what
+    // the newer request is already about to replace.
+    entry.controller?.abort();
+    const controller = new AbortController();
+    entry.controller = controller;
+    publish(root, { scanning: true });
+
+    const params = new URLSearchParams({ reposOnly: '1' });
+    if (root) params.set('root', root);
+    if (rescan) params.set('rescan', '1');
+    params.set('t', String(Date.now()));
+
+    const pending = (async () => {
+      const data = await fetchImpl(`/api/fs/git?${params.toString()}`).catch(() => null);
+      if (entry.controller !== controller) return;
+      entry.controller = null;
+
+      const repos = isRecord(data) && Array.isArray(data.repos) ? data.repos : null;
+      if (!repos) {
+        // A failed read leaves the snapshot as it was — for a root nobody has
+        // successfully listed yet that is still `UNKNOWN_LIST`, so the next
+        // subscriber retries instead of sitting on an empty list.
+        publish(root, { scanning: false });
+        return;
+      }
+      const scanning = isRecord(data) && data.reposPending === true;
+      entry.loaded = true;
+      publish(root, { repos: repos.filter((r): r is string => typeof r === 'string'), scanning });
+
+      // Discovery runs in the background server-side — the loader returns at
+      // once with `reposPending` — so retry until it settles.
+      if (scanning) {
+        cancelRetry(entry);
+        entry.cancelRetry = scheduler(() => {
+          entry.cancelRetry = null;
+          if (entry.listeners.size === 0) return;
+          void load(root, false);
+        }, REPO_DISCOVERY_POLL_MS);
+      } else {
+        cancelRetry(entry);
+      }
+    })();
+
+    entry.pending = pending;
+    return pending;
+  }
+
+  function subscribe(root: string, listener: () => void): () => void {
+    const entry = entryFor(root);
+    entry.listeners.add(listener);
+    // First subscriber for this root — or the first since everyone left —
+    // starts (or resumes) discovery, unless a settled list is already known for
+    // this same root: a right-panel view switch must not re-run the server's
+    // `find`.
+    if (entry.controller === null && entry.cancelRetry === null && (!entry.loaded || entry.snapshot.scanning)) {
+      void load(root, false);
+    }
+    return () => {
+      entry.listeners.delete(listener);
+      if (entry.listeners.size > 0) return;
+      // Nobody is showing this root's list any more: abandon the read in flight
+      // and drop the retry. The snapshot keeps its `scanning` flag, so the next
+      // subscriber resumes discovery rather than inheriting a spinner that
+      // nothing is driving.
+      entry.controller?.abort();
+      entry.controller = null;
+      cancelRetry(entry);
+    };
+  }
+
+  return {
+    snapshot: (root) => entries.get(root)?.snapshot ?? UNKNOWN_LIST,
+    settled: (root) => entries.get(root)?.pending ?? Promise.resolve(),
+    subscribe,
+    rescan: (root) => void load(root, true),
+  };
+}
+
+/** The app's single store, over the browser's `fetch` and real timers. */
+export const repoStore = createRepoStore({
+  fetch: async (url) => {
+    const response = await fetch(url);
+    return response.json();
+  },
+});

package/src/client/hooks/workspace/search-stream.ts

@@ -16,14 +16,21 @@ interface SearchStreamState {
  * encoding the old `useFetcher.submit` used) and the response is consumed
  * incrementally via the shared SSE reader. A new `start` call aborts the
  * previous run — matching the fetcher semantics the panel relied on.
+ *
+ * Results carry the `scope` they were searched under (the workspace root plus
+ * the selected repo). A workspace switch therefore shows no hits at all rather
+ * than the previous workspace's — a match's path is relative to the root it was
+ * found under, so the same string names a different file, or none, here.
  */
-export function useSearchStream(): SearchStreamState & {
+export function useSearchStream(scope: string): SearchStreamState & {
   start: (body: Record<string, string>) => Promise<void>;
 } {
-  const [results, setResults] = useState<SearchResultItem[]>([]);
+  const [state, setState] = useState<{ scope: string; results: SearchResultItem[] }>({ scope, results: [] });
   const [isSearching, setIsSearching] = useState(false);
   const abortRef = useRef<AbortController | null>(null);
   const aliveRef = useRef(true);
+  const scopeRef = useRef(scope);
+  scopeRef.current = scope;
 
   useEffect(() => {
     aliveRef.current = true;
@@ -38,8 +45,9 @@ export function useSearchStream(): SearchStreamState & {
     abortRef.current?.abort();
     const controller = new AbortController();
     abortRef.current = controller;
+    const requested = scopeRef.current;
 
-    setResults([]);
+    setState({ scope: requested, results: [] });
     setIsSearching(true);
     try {
       const response = await fetch('/api/fs/search', {
@@ -53,9 +61,15 @@ export function useSearchStream(): SearchStreamState & {
         response,
         (event, data) => {
           if (event !== 'matches') return;
+          // A run superseded by a workspace switch is no longer this panel's.
+          if (scopeRef.current !== requested) return;
           try {
             const parsed = JSON.parse(data);
-            if (Array.isArray(parsed)) setResults(prev => [...prev, ...parsed]);
+            if (Array.isArray(parsed)) {
+              setState(prev => prev.scope === requested
+                ? { scope: requested, results: [...prev.results, ...parsed] }
+                : prev);
+            }
           } catch {
             // Malformed frame — skip; the next frame carries its own payload.
           }
@@ -72,5 +86,10 @@ export function useSearchStream(): SearchStreamState & {
     }
   }, []);
 
-  return { results, isSearching, start };
+  return {
+    results: state.scope === scope ? state.results : [],
+    // A run in flight for another scope is not searching THIS one.
+    isSearching: isSearching && state.scope === scope,
+    start,
+  };
 }

package/src/client/main.tsx

@@ -2,6 +2,7 @@ import { hydrate } from 'preact';
 import { App } from '@/client/App';
 import { bootSyntax } from '@/shared/lib/code/highlighter';
 import { primeChamberSettings } from '@/shared/lib/settings/client';
+import { initDocumentTheme } from '@/client/hooks/ui/theme';
 
 import '@/client/tailwind.css';
 import '@/shared/lib/markdown/katex-fonts.css';
@@ -12,6 +13,11 @@ const bootstrap = window.__OMP_BOOTSTRAP__;
 
 primeChamberSettings(bootstrap?.appSettings);
 
+// The catalog stylesheet and both theme attributes, before the first render:
+// the server writes them into the shell, so this only repairs a document served
+// by an older build.
+initDocumentTheme();
+
 // Fire-and-forget: warms the Shiki highlighter in parallel with hydration.
 bootSyntax();
 

package/src/client/tailwind.css

@@ -1,6 +1,5 @@
 @import "tailwindcss";
 @import "@xterm/xterm/css/xterm.css";
-@plugin "@tailwindcss/typography";
 
 @theme {
   --color-ink: var(--theme-ink);
@@ -8,8 +7,6 @@
   --color-canvas: var(--theme-canvas);
   --color-error: var(--theme-error);
   --color-success: var(--theme-success);
-  --color-success-bg: var(--theme-success-bg);
-  --color-success-border: var(--theme-success-border);
   --color-meta: var(--theme-meta);
   --color-info: var(--theme-info);
   --color-info-hover: var(--theme-info-hover);
@@ -18,19 +15,23 @@
 }
 
 @layer base {
+  /* The default palette. Every other theme's block is generated from the
+   * catalog in `src/shared/lib/theme/palettes/` and injected as
+   * `html[data-theme=…]` by the SSR shell (see `shared/lib/theme/css.ts`) —
+   * hand-writing them here would duplicate the same eight values the appearance
+   * cards render as chips. */
   :root {
     --theme-paper: #faf8f3;
     --theme-canvas: #f4f1ea;
     --theme-ink: #141310;
     --theme-error: #c8321e;
     --theme-success: #047857;
-    --theme-success-bg: #ecfdf5;
-    --theme-success-border: #a7f3d0;
     --theme-meta: #4f46e5;
     --theme-info: #0284c7;
-    --theme-info-hover: #0369a1;
+    --theme-info-hover: color-mix(in srgb, var(--theme-info) 85%, var(--theme-ink));
     --theme-warning: #c2410c;
-    --theme-warning-hover: #9a3412;
+    --theme-warning-hover: color-mix(in srgb, var(--theme-warning) 85%, var(--theme-ink));
+    color-scheme: light;
 
     --paper-bg: var(--theme-canvas);
     --paper-raised: var(--theme-paper);
@@ -42,51 +43,6 @@
     --signal-red: var(--theme-error);
   }
 
-  [data-theme="contrast"] {
-    --theme-paper: #ffffff;
-    --theme-canvas: #f4f4f4;
-    --theme-ink: #111111;
-    --theme-error: #b42318;
-    --theme-success: #067647;
-    --theme-success-bg: #ecfdf3;
-    --theme-success-border: #abefc6;
-    --theme-meta: #4338ca;
-    --theme-info: #0369a1;
-    --theme-info-hover: #075985;
-    --theme-warning: #b54708;
-    --theme-warning-hover: #93370d;
-  }
-
-  [data-theme="noir"] {
-    --theme-paper: #282c34;
-    --theme-canvas: #21252b;
-    --theme-ink: #abb2bf;
-    --theme-error: #e06c75;
-    --theme-success: #34d399;
-    --theme-success-bg: rgba(5, 150, 105, 0.15);
-    --theme-success-border: rgba(16, 185, 129, 0.2);
-    --theme-meta: #818cf8;
-    --theme-info: #61afef;
-    --theme-info-hover: #8ec7ff;
-    --theme-warning: #fb923c;
-    --theme-warning-hover: #fdba74;
-  }
-
-  [data-theme="one-dark-pro-soft"] {
-    --theme-paper: #282c34;
-    --theme-canvas: #21252b;
-    --theme-ink: #abb2bf;
-    --theme-error: #e06c75;
-    --theme-success: #34d399;
-    --theme-success-bg: rgba(5, 150, 105, 0.15);
-    --theme-success-border: rgba(16, 185, 129, 0.2);
-    --theme-meta: #818cf8;
-    --theme-info: #61afef;
-    --theme-info-hover: #8ec7ff;
-    --theme-warning: #fb923c;
-    --theme-warning-hover: #fdba74;
-  }
-
   body {
     font-family: 'IBM Plex Sans', -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
     background-color: var(--theme-canvas);
@@ -235,6 +191,13 @@
 .prose-content li { line-height: inherit; position: relative; }
 .prose-content li + li { margin-top: 0.375rem; }
 .prose-content li p { margin: 0.25rem 0; }
+/* Tailwind's preflight makes every `img` block-level. Markdown images are
+ * inline content: a README badge row is one `<p align="center">` of
+ * `<a><img></a>` links, and a block image stacks it one badge per line (and
+ * pushes an image off the text line it was written on). `inline-block` restores
+ * the line box GitHub renders; the preflight's `max-width: 100%` still applies,
+ * and `vertical-align: middle` keeps badges of different heights aligned. */
+.prose-content img { display: inline-block; vertical-align: middle; }
 .prose-content ul > li::before { content: ''; display: block; position: absolute; left: -1.25em; top: 0; }
 .prose-content blockquote {
   border-left: 2px solid color-mix(in srgb, var(--theme-ink) 30%, transparent);
@@ -276,13 +239,13 @@
 .prose-content .code-block pre { margin: 0; padding: 0.75rem; overflow-x: auto; line-height: var(--markdown-code-block-line-height); }
 .prose-content .code-block code { font-family: 'Fira Code', monospace; font-size: 0.75rem; line-height: var(--markdown-code-block-line-height); }
 .prose-content .code-block pre code { background: transparent; text-shadow: none; }
-/* Shiki dual-theme tokens: the highlighter emits BOTH palettes (min-light for
+/* Shiki dual-theme tokens: the highlighter emits BOTH palettes (one-light for
  * light themes, one-dark-pro for dark themes) as CSS variables on every token
  * span and no inline `color`, so the active [data-theme] selects the palette.
- * Switching themes recolors code blocks with zero JS and no re-highlight. */
+ * Switching themes recolors code blocks with zero JS and no re-highlight.
+ * The selector keys off the variant attribute, not a list of theme ids. */
 .shiki span { color: var(--shiki-light); }
-[data-theme="noir"] .shiki span,
-[data-theme="one-dark-pro-soft"] .shiki span { color: var(--shiki-dark); }
+html[data-theme-variant="dark"] .shiki span { color: var(--shiki-dark); }
 .prose-content .katex-display { overflow-x: auto; overflow-y: hidden; }
 
 /* Math placeholder: `marked.ts` emits a `.math-pending` span and KaTeX is

package/src/server/lib/btw/child.server.ts

@@ -0,0 +1,41 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Spawn arguments for a topic's side child.
+ *
+ * The side child is an ordinary `omp --mode rpc-ui` that resumes the topic's
+ * transcript. It runs WITH tools (unlike the TUI's `/btw`, which passes
+ * `--no-tools`): the panel exposes a real access-control dropdown, and an
+ * approval mode that governs nothing is a lie in the UI. What the child may
+ * actually do is therefore the `--approval-mode` flag's business, exactly as it
+ * is for a chat session.
+ *
+ * `--no-title` stays: auto-titling would spend a model call on a transcript
+ * nobody lists in the sidebar.
+ */
+
+import type { ApprovalMode } from '@/shared/lib/omp/config/access-mode';
+import type { BtwModel } from '@/shared/types';
+
+export interface BtwSpawnSettings {
+  model?: BtwModel;
+  /** omp's own default when absent (`auto`). */
+  thinkingLevel?: string;
+  /** Spawn-time only: omp exposes no RPC to change the approval mode. */
+  approvalMode?: ApprovalMode;
+}
+
+export function buildBtwSpawnArgs(sessionFile: string, settings: BtwSpawnSettings): string[] {
+  const args = ['--resume', sessionFile, '--no-title'];
+  if (settings.model) args.push('--model', `${settings.model.provider}/${settings.model.id}`);
+  // 'auto' means "leave omp's level alone" — the same rule the composer applies,
+  // so it is omitted rather than translated into a concrete level.
+  if (settings.thinkingLevel && settings.thinkingLevel !== 'auto') {
+    args.push('--thinking', settings.thinkingLevel);
+  }
+  if (settings.approvalMode) args.push('--approval-mode', settings.approvalMode);
+  return args;
+}