@kabmo-labs/kabmo 0.0.0-stage → 0.1.0

package/src/shared/lib/fs/repo-label.ts

@@ -0,0 +1,55 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * How a repository is NAMED on screen.
+ *
+ * A repo is a path relative to the workspace root — `projects/jns6_5/token`
+ * only means something next to `~/JatisMobile/Workspace` — so every surface
+ * that shows one has to answer two questions the same way: what the root itself
+ * is called (`.`, which has no name of its own) and how much of the path fits.
+ *
+ * Three call sites needed this and two of them had written it out separately
+ * (the shared repo dropdown and the git panel's header), which is how a picker
+ * comes to label one repo two ways. The root's name comes from its path's last
+ * segment, which is the one word a user recognizes: `~/JatisMobile/Workspace`
+ * is "Workspace".
+ */
+
+/**
+ * The workspace root's own name: its last path segment.
+ *
+ * `~/JatisMobile/Workspace` → `Workspace`. Trailing separators are dropped
+ * first, so `…/Workspace/` names the same thing, and a path that is nothing but
+ * separators (`/`) has no name — the literal "workspace root" is the honest
+ * answer there rather than an empty label.
+ */
+export function workspaceFolderName(rootPath: string | undefined): string {
+  if (!rootPath) return 'workspace root';
+  const parts = rootPath.replace(/\\/g, '/').split('/').filter(Boolean);
+  return parts.length > 0 ? parts[parts.length - 1] : 'workspace root';
+}
+
+/**
+ * The full label of a repo in a list: `.` reads as the workspace root's name,
+ * anything else as its own root-relative path.
+ *
+ * The path is kept whole (not truncated to its basename) because the list is
+ * where the difference between `jns6_5/token` and `jns7/token` has to be
+ * visible — the same reason the branch modal lists whole branch names.
+ */
+export function repoLabel(repo: string, rootPath: string | undefined): string {
+  return repo === '.' ? workspaceFolderName(rootPath) : repo;
+}
+
+/**
+ * The label for a trigger button, where the space is a few characters wide: a
+ * nested repo is named by its last segment only (`projects/jns6_5/token` →
+ * `token`), and the root by the root's own name.
+ */
+export function repoShortLabel(repo: string, rootPath: string | undefined): string {
+  if (repo === '.') return workspaceFolderName(rootPath);
+  return repo.split('/').pop() || repo;
+}

package/src/shared/lib/fs/search-list.test.ts

@@ -0,0 +1,139 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The search result list's layout arithmetic.
+ *
+ * The panel paints only the rows a viewport can show, so the row sequence has
+ * to be addressable by index and its geometry has to be exact — an estimated
+ * height makes the scrollbar drift and a jump land on the wrong line. These are
+ * the cases that would break silently on screen: a group boundary, the gap
+ * after the last hit of a file, a scroll past either end, and a range that is
+ * entirely between two rows.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import {
+  DEFAULT_SEARCH_ROW_METRICS,
+  SEARCH_ROW_GAPS,
+  buildSearchRows,
+  layoutSearchRows,
+  searchRowHeight,
+  searchWindow,
+} from '@/shared/lib/fs/search-list';
+
+const metrics = { headerBox: 16, hitBox: 20 };
+const H = metrics.headerBox + SEARCH_ROW_GAPS.header; // 20
+const HIT = metrics.hitBox + SEARCH_ROW_GAPS.hit; // 24
+const HIT_LAST = metrics.hitBox + SEARCH_ROW_GAPS.group; // 36
+
+function group(file: string, lines: number[]) {
+  return { file, results: lines.map((line) => ({ file, line, content: `line ${line}` })) };
+}
+
+describe('buildSearchRows', () => {
+  test('a file header precedes its hits, in stream order', () => {
+    const rows = buildSearchRows([group('a.ts', [1, 2])]);
+
+    expect(rows.map((r) => r.kind)).toEqual(['group', 'hit', 'hit']);
+    expect(rows[1]).toMatchObject({ kind: 'hit', file: 'a.ts', last: false });
+    expect(rows[2]).toMatchObject({ kind: 'hit', file: 'a.ts', last: true });
+  });
+
+  test('only the last hit of a file is marked, across several files', () => {
+    const rows = buildSearchRows([group('a.ts', [1]), group('b.ts', [7, 8])]);
+
+    expect(rows.map((r) => (r.kind === 'hit' ? r.last : null))).toEqual([null, true, null, false, true]);
+  });
+
+  test('an empty list flattens to nothing', () => {
+    expect(buildSearchRows([])).toEqual([]);
+  });
+});
+
+describe('searchRowHeight', () => {
+  test('a header carries the gap below it', () => {
+    expect(searchRowHeight({ kind: 'group', file: 'a', count: 1 }, metrics)).toBe(H);
+  });
+
+  test('a mid-file hit carries the small gap, the last one the file gap', () => {
+    const result = { file: 'a', line: 1, content: 'x' };
+
+    expect(searchRowHeight({ kind: 'hit', file: 'a', result, last: false }, metrics)).toBe(HIT);
+    expect(searchRowHeight({ kind: 'hit', file: 'a', result, last: true }, metrics)).toBe(HIT_LAST);
+  });
+});
+
+describe('layoutSearchRows', () => {
+  test('offsets are cumulative and total is the last row end', () => {
+    const rows = buildSearchRows([group('a.ts', [1, 2])]);
+    const { offsets, heights, total } = layoutSearchRows(rows, metrics);
+
+    expect(offsets).toEqual([0, H, H + HIT]);
+    expect(heights).toEqual([H, HIT, HIT_LAST]);
+    expect(total).toBe(H + HIT + HIT_LAST);
+  });
+
+  test('the total matches the sum of the heights for a multi-file list', () => {
+    const rows = buildSearchRows([group('a.ts', [1]), group('b.ts', [2, 3])]);
+    const { heights, total } = layoutSearchRows(rows, metrics);
+
+    expect(total).toBe(heights.reduce((sum, h) => sum + h, 0));
+  });
+});
+
+describe('searchWindow', () => {
+  const rows = buildSearchRows([group('a.ts', [1, 2, 3]), group('b.ts', [4])]);
+  const { offsets, heights } = layoutSearchRows(rows, metrics);
+
+  test('an empty list yields an empty window', () => {
+    expect(searchWindow([], [], 0, 500)).toEqual({ start: 0, end: 0 });
+  });
+
+  test('without overscan the window is exactly the visible rows', () => {
+    // Rows: [0,20) header, [20,44) hit, [44,68) hit, [68,104) last hit, [104,124) header, [124,160) hit.
+    expect(searchWindow(offsets, heights, 0, 20, 0)).toEqual({ start: 0, end: 1 });
+    expect(searchWindow(offsets, heights, 20, 24, 0)).toEqual({ start: 1, end: 2 });
+    // A viewport starting mid-row still mounts the row it covers.
+    expect(searchWindow(offsets, heights, 30, 20, 0)).toEqual({ start: 1, end: 3 });
+  });
+
+  test('a scroll past the end clamps to the last row', () => {
+    const window = searchWindow(offsets, heights, 100000, 500, 0);
+
+    expect(window.start).toBe(rows.length - 1);
+    expect(window.end).toBe(rows.length);
+  });
+
+  test('a negative scrollTop still starts at the first row', () => {
+    expect(searchWindow(offsets, heights, -500, 100, 0).start).toBe(0);
+  });
+
+  test('overscan widens the range on both sides', () => {
+    const tight = searchWindow(offsets, heights, 44, 24, 0);
+    const wide = searchWindow(offsets, heights, 44, 24, 20);
+
+    expect(wide.start).toBeLessThanOrEqual(tight.start);
+    expect(wide.end).toBeGreaterThanOrEqual(tight.end);
+  });
+
+  test('the whole list is covered by scrolling through it', () => {
+    const seen = new Set<number>();
+    for (let top = 0; top < 160; top += 24) {
+      const { start, end } = searchWindow(offsets, heights, top, 24, 0);
+      for (let i = start; i < end; i++) seen.add(i);
+    }
+
+    expect([...seen].sort((a, b) => a - b)).toEqual([0, 1, 2, 3, 4, 5]);
+  });
+});
+
+describe('DEFAULT_SEARCH_ROW_METRICS', () => {
+  test('is a usable non-zero layout before measurement', () => {
+    expect(DEFAULT_SEARCH_ROW_METRICS.headerBox).toBeGreaterThan(0);
+    expect(DEFAULT_SEARCH_ROW_METRICS.hitBox).toBeGreaterThan(0);
+  });
+});

package/src/shared/lib/fs/search-list.ts

@@ -0,0 +1,187 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The search result list as a FLAT, measurable sequence — the arithmetic the
+ * panel needs to paint only the rows on screen.
+ *
+ * A search for a common word returns tens of thousands of hits, and every one
+ * of them used to become a DOM node with its own syntax-highlighted markup
+ * (measured on this repo: 19,376 rows, 385,706 nodes, 34 s of blocked main
+ * thread for one scroll gesture). The rows are therefore laid out here, away
+ * from the DOM, so the renderer can ask "which indices are visible?" and mount
+ * only those.
+ *
+ * Two properties make the layout EXACT rather than estimated, and both come
+ * from the row markup:
+ *
+ * - Every row is a single line. A hit is `truncate`d and a group header is one
+ *   flex line, so all rows of a kind are the same height.
+ * - The heights themselves are measured once from the real DOM
+ *   (`Results.tsx`) and passed in, so a font or zoom change is picked up
+ *   instead of being frozen into a constant.
+ *
+ * Gaps live here too, as part of each row's own height, because the virtualized
+ * list cannot use `space-y-*`: a CSS margin between siblings only applies to
+ * siblings that exist, and a windowed list has a different set of siblings on
+ * every scroll.
+ */
+
+import type { SearchResultItem } from '@/shared/types/fs';
+
+/** One rendered line of the result list. */
+export type SearchListEntry =
+  | { kind: 'group'; file: string; count: number }
+  | { kind: 'hit'; file: string; result: SearchResultItem; /** Last hit of its file. */ last: boolean };
+
+/** A file and its hits, in the order the server streamed them. */
+export interface SearchGroup {
+  file: string;
+  results: readonly SearchResultItem[];
+}
+
+/** The measured content height of each row kind, in px. */
+export interface SearchRowMetrics {
+  headerBox: number;
+  hitBox: number;
+}
+
+/**
+ * The gaps the rows used to get from `space-y-1` / `space-y-4` / `mb-1`, now
+ * folded into each row's height. They are layout, not measurement, so they stay
+ * constants — only the text boxes are measured.
+ */
+export const SEARCH_ROW_GAPS = {
+  /** Below a group header (`mb-1`). */
+  header: 4,
+  /** Between two hits of the same file (`space-y-1`). */
+  hit: 4,
+  /** Between two files (`space-y-4`). */
+  group: 16,
+} as const;
+
+/** Row heights that are correct before the first measurement lands. */
+export const DEFAULT_SEARCH_ROW_METRICS: SearchRowMetrics = { headerBox: 16, hitBox: 20 };
+
+/**
+ * The most matches one run will deliver.
+ *
+ * A common word matches tens of thousands of lines in a real workspace —
+ * measured on this repo, `const` produced 19,376 hits and a 3 MB SSE payload,
+ * which is memory and bandwidth spent on results nobody reads past the first
+ * screenful. The server stops the run here and says so, and the panel prints
+ * the same number, so the cap cannot be described differently in two places.
+ */
+export const MAX_SEARCH_RESULTS = 5000;
+
+/**
+ * Group hits by file, keeping the order the server streamed them in.
+ *
+ * Streaming order is the order ripgrep walked the tree, so a group appears the
+ * moment its first hit does and the list stays stable as more frames land —
+ * re-sorting by path would make every arriving frame move the rows already on
+ * screen.
+ */
+export function groupSearchResults(results: readonly SearchResultItem[]): SearchGroup[] {
+  const groups: SearchGroup[] = [];
+  let current: { file: string; results: SearchResultItem[] } | null = null;
+  for (const result of results) {
+    if (!current || current.file !== result.file) {
+      current = { file: result.file, results: [] };
+      groups.push(current);
+    }
+    current.results.push(result);
+  }
+  return groups;
+}
+
+/** Flatten `[file, hits][]` into the exact sequence the list renders. */
+export function buildSearchRows(groups: readonly SearchGroup[]): SearchListEntry[] {
+  const rows: SearchListEntry[] = [];
+  for (const group of groups) {
+    rows.push({ kind: 'group', file: group.file, count: group.results.length });
+    for (let i = 0; i < group.results.length; i++) {
+      rows.push({ kind: 'hit', file: group.file, result: group.results[i], last: i === group.results.length - 1 });
+    }
+  }
+  return rows;
+}
+
+/** One row's height, including the gap that follows it. */
+export function searchRowHeight(entry: SearchListEntry, metrics: SearchRowMetrics): number {
+  if (entry.kind === 'group') return metrics.headerBox + SEARCH_ROW_GAPS.header;
+  return metrics.hitBox + (entry.last ? SEARCH_ROW_GAPS.group : SEARCH_ROW_GAPS.hit);
+}
+
+/**
+ * The top offset of every row, plus the total content height.
+ *
+ * `offsets[i]` is the row's own top; `total` is the last row's offset plus its
+ * height, which is what the spacer is sized to so the scrollbar reflects the
+ * whole result set rather than the mounted window.
+ */
+export function layoutSearchRows(
+  rows: readonly SearchListEntry[],
+  metrics: SearchRowMetrics,
+): { offsets: number[]; heights: number[]; total: number } {
+  const offsets = new Array<number>(rows.length);
+  const heights = new Array<number>(rows.length);
+  let cursor = 0;
+  for (let i = 0; i < rows.length; i++) {
+    const height = searchRowHeight(rows[i], metrics);
+    offsets[i] = cursor;
+    heights[i] = height;
+    cursor += height;
+  }
+  return { offsets, heights, total: cursor };
+}
+
+/**
+ * The half-open index range to mount for a viewport.
+ *
+ * `scrollTop` is measured in the SPACER's coordinates (the caller subtracts the
+ * container's own padding), so the range is independent of how the scroller is
+ * decorated. `overscan` extends the range on both sides so a fast flick does
+ * not outrun the mount and show a blank band.
+ *
+ * The search is a binary search on the prefix sums, so the cost is
+ * O(log n) regardless of how many hits the query produced.
+ */
+export function searchWindow(
+  offsets: readonly number[],
+  heights: readonly number[],
+  scrollTop: number,
+  viewport: number,
+  overscan = 240,
+): { start: number; end: number } {
+  if (offsets.length === 0) return { start: 0, end: 0 };
+  // A rubber-band scroll can report a negative offset; the content has nothing
+  // above its first row, so the window is measured from the top.
+  const top = Math.max(0, scrollTop);
+  const from = top - overscan;
+  const to = top + viewport + overscan;
+
+  // First row whose bottom edge is past `from`.
+  let lo = 0;
+  let hi = offsets.length - 1;
+  while (lo < hi) {
+    const mid = (lo + hi) >> 1;
+    if (offsets[mid] + heights[mid] > from) hi = mid;
+    else lo = mid + 1;
+  }
+  const start = lo;
+
+  // First row that starts at or past the window's bottom edge — it and
+  // everything after it is outside. A row beginning exactly at the edge has no
+  // overlap with the viewport, so the bound is inclusive of the offset.
+  lo = start;
+  hi = offsets.length;
+  while (lo < hi) {
+    const mid = (lo + hi) >> 1;
+    if (offsets[mid] >= to) hi = mid;
+    else lo = mid + 1;
+  }
+  return { start, end: lo };
+}

package/src/shared/lib/fs/search-row.test.ts

@@ -0,0 +1,66 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The search row's replace preview split.
+ *
+ * The row shows the line struck through and rewritten, so the segment list IS
+ * what the user reads. The cases that matter are the ones a naive splice gets
+ * wrong: a match in the middle of a line (plain runs either side), two matches
+ * on one line (each gets its own insertion), and a malformed range that must be
+ * skipped rather than allowed to duplicate text.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import { replacePreviewSegments } from '@/shared/lib/fs/search-row';
+
+describe('replacePreviewSegments', () => {
+  test('splits a single mid-line match into plain, removed and inserted', () => {
+    expect(replacePreviewSegments('const alpha = 1;', [{ start: 6, end: 11 }], 'beta')).toEqual([
+      { text: 'const ', kind: 'plain' },
+      { text: 'alpha', kind: 'removed' },
+      { text: 'beta', kind: 'inserted' },
+      { text: ' = 1;', kind: 'plain' },
+    ]);
+  });
+
+  test('gives every match on a line its own insertion', () => {
+    expect(replacePreviewSegments('a a', [{ start: 0, end: 1 }, { start: 2, end: 3 }], 'b')).toEqual([
+      { text: 'a', kind: 'removed' },
+      { text: 'b', kind: 'inserted' },
+      { text: ' ', kind: 'plain' },
+      { text: 'a', kind: 'removed' },
+      { text: 'b', kind: 'inserted' },
+    ]);
+  });
+
+  test('an empty replacement removes without inserting', () => {
+    expect(replacePreviewSegments('alpha', [{ start: 0, end: 5 }], '')).toEqual([
+      { text: 'alpha', kind: 'removed' },
+    ]);
+  });
+
+  test('skips a range that overlaps the previous one', () => {
+    // A malformed list must not make the row render a line that is not the file's.
+    const segments = replacePreviewSegments('alpha', [{ start: 0, end: 3 }, { start: 2, end: 5 }], 'x');
+
+    expect(segments).toEqual([
+      { text: 'alp', kind: 'removed' },
+      { text: 'x', kind: 'inserted' },
+      { text: 'ha', kind: 'plain' },
+    ]);
+  });
+
+  test('skips a range past the end of the text', () => {
+    expect(replacePreviewSegments('alpha', [{ start: 3, end: 99 }], 'x')).toEqual([
+      { text: 'alpha', kind: 'plain' },
+    ]);
+  });
+
+  test('no ranges is one plain run', () => {
+    expect(replacePreviewSegments('alpha', [], 'x')).toEqual([{ text: 'alpha', kind: 'plain' }]);
+  });
+});

package/src/shared/lib/fs/search-row.ts

@@ -0,0 +1,55 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * How a search hit is split for rendering when a replacement is being typed.
+ *
+ * The search row shows the match, and once the replace field holds text it
+ * shows what the line would become — the old text struck through and the new
+ * text beside it, the way VS Code's search view does. The split lives here, as
+ * pure arithmetic, because the row must not re-derive the ranges the server
+ * already computed: a preview that disagrees with the offsets the editor is
+ * pointed at is the failure this exists to prevent.
+ *
+ * The replacement is taken VERBATIM, not expanded: it is the template the user
+ * typed, and showing `$1` in the preview while the write path expands it would
+ * promise a line the file never receives. VS Code's own preview does the same.
+ */
+
+export type SearchRowSegmentKind = 'plain' | 'removed' | 'inserted';
+
+export interface SearchRowSegment {
+  text: string;
+  kind: SearchRowSegmentKind;
+}
+
+/**
+ * `content` split into plain runs, removed match runs and the inserted text
+ * that follows each one.
+ *
+ * Ranges are assumed to be in document order and non-overlapping — the route
+ * emits them that way — but an out-of-order or overlapping pair is skipped
+ * rather than allowed to duplicate text: a malformed list must not make the row
+ * render a line that is not the file's.
+ */
+export function replacePreviewSegments(
+  content: string,
+  ranges: readonly { start: number; end: number }[],
+  replacement: string,
+): SearchRowSegment[] {
+  const segments: SearchRowSegment[] = [];
+  let cursor = 0;
+  for (const range of ranges) {
+    if (range.start < cursor || range.end <= range.start || range.end > content.length) continue;
+    if (range.start > cursor) segments.push({ text: content.slice(cursor, range.start), kind: 'plain' });
+    segments.push({ text: content.slice(range.start, range.end), kind: 'removed' });
+    // An empty replacement inserts nothing: an empty `<ins>` would only add a
+    // DOM node with no text for the row to show.
+    if (replacement) segments.push({ text: replacement, kind: 'inserted' });
+    cursor = range.end;
+  }
+  if (cursor < content.length) segments.push({ text: content.slice(cursor), kind: 'plain' });
+  return segments;
+}

package/src/shared/lib/git/url.test.ts

@@ -0,0 +1,69 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * `isGitUrl` / `repoSlug` moved here from `lib/panels/install.server.ts` when
+ * the New Workspace modal's Clone button began sharing them — the button's
+ * enabled state and the server's refusal read the same predicate or they can
+ * disagree. The URL forms are the ones `git clone` accepts, verified against
+ * git itself rather than assumed.
+ */
+
+import { describe, expect, test } from 'bun:test';
+import { isGitUrl, repoSlug } from '@/shared/lib/git/url';
+
+describe('isGitUrl', () => {
+  test('accepts the three forms git clone understands', () => {
+    expect(isGitUrl('https://github.com/a/b.git')).toBe(true);
+    expect(isGitUrl('ssh://git@host/a/b.git')).toBe(true);
+    expect(isGitUrl('git@github.com:a/b.git')).toBe(true);
+  });
+
+  test('accepts a local path and a file:// URL, which git clone also accepts', () => {
+    expect(isGitUrl('/tmp/repo')).toBe(true);
+    expect(isGitUrl('~/repos/panel')).toBe(true);
+    expect(isGitUrl('file:///tmp/repo')).toBe(true);
+  });
+
+  test('accepts a Windows local path, drive-rooted and UNC', () => {
+    // A local clone from disk is the documented behaviour, and on Windows the
+    // spelling of "a path on disk" is a drive letter. Without this the Clone
+    // button could never enable there and the route refused a repository the
+    // user had just browsed to (measured: all four clone cases failed with 400).
+    expect(isGitUrl('C:\\Users\\x\\repo')).toBe(true);
+    expect(isGitUrl('C:/Users/x/repo')).toBe(true);
+    expect(isGitUrl('d:\\repo')).toBe(true);
+    expect(isGitUrl('\\\\server\\share\\repo')).toBe(true);
+  });
+
+  test('refuses a drive-RELATIVE path, which is not a location on disk', () => {
+    // `C:repo` means "the current directory on drive C", not `C:\repo` — the
+    // same distinction `isAbsolutePath` makes in the CLI's path helpers.
+    expect(isGitUrl('C:repo')).toBe(false);
+  });
+
+  test('refuses a bare name, an empty string and one with whitespace', () => {
+    expect(isGitUrl('some-plugin')).toBe(false);
+    expect(isGitUrl('   ')).toBe(false);
+    expect(isGitUrl('https://a b/c')).toBe(false);
+  });
+});
+
+describe('repoSlug', () => {
+  test('takes the last segment, which is what git clone names the directory', () => {
+    expect(repoSlug('https://github.com/kabmo-labs/kabmo.git')).toBe('kabmo');
+    expect(repoSlug('git@github.com:kabmo-labs/kabmo.git')).toBe('kabmo');
+    expect(repoSlug('https://github.com/a/b/')).toBe('b');
+  });
+
+  test('strips the .git suffix and keeps a scp-form path readable', () => {
+    expect(repoSlug('/tmp/repo.git')).toBe('repo');
+    expect(repoSlug('ssh://git@host:2222/a/b.git')).toBe('b');
+  });
+
+  test('returns an empty string when the URL names no segment', () => {
+    expect(repoSlug('https://')).toBe('');
+  });
+});

package/src/shared/lib/git/url.ts

@@ -0,0 +1,76 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * What `git clone` accepts, and the slug to name the clone's directory after.
+ *
+ * Two callers, one rule: the panel-plugin installer validates a URL before it
+ * stages a clone, and the New Workspace modal disables its Clone button on the
+ * same predicate — so the button's enabled state and the server's refusal can
+ * never disagree. A per-caller copy is what that costs.
+ *
+ * The local forms (`/path`, `~/path`, `file://`) are allowed deliberately.
+ * `git clone` treats them as first-class, and Kabmo already gives the
+ * user a real shell in the terminal panel — a local clone grants nothing that
+ * was not already reachable, while making an offline clone and a test
+ * repository work.
+ */
+
+/** True for a source `git clone` accepts. */
+export function isGitUrl(value: string): boolean {
+  const trimmed = value.trim();
+  if (!trimmed || /\s/.test(trimmed)) return false;
+  if (/^https?:\/\/\S+$/i.test(trimmed)) return true;
+  if (/^ssh:\/\/\S+$/i.test(trimmed)) return true;
+  if (/^git@[^:/\s]+:\S+$/.test(trimmed)) return true;
+  if (/^file:\/\/\S+$/i.test(trimmed)) return true;
+  if (trimmed.startsWith('/') || trimmed.startsWith('~')) return true;
+  // A drive-rooted Windows path is a local source too, and the whole point of
+  // allowing local paths is that a clone from disk works. Without this the
+  // New Workspace modal's Clone button could never enable on Windows and
+  // `POST /api/folders/clone` answered `invalid_url` for a path the user had
+  // just browsed to — measured on the first Windows run, where all four clone
+  // route cases failed with 400 for a real repository in a temp directory.
+  //
+  // `C:relative` is drive-RELATIVE on Windows, not absolute, so a colon with no
+  // separator after it is refused — the same distinction `isAbsolutePath` in the
+  // CLI's own path helpers makes.
+  if (/^[a-z]:[\\/]/i.test(trimmed)) return true;
+  if (/^\\\\[^\\]+\\/.test(trimmed)) return true; // UNC: \\server\share
+  return false;
+}
+
+/**
+ * The directory name a clone of `url` should take: the last path segment with
+ * a `.git` suffix and any trailing slash stripped.
+ *
+ * This is what `git clone` itself would choose, so a clone into the active
+ * directory lands where the user expects, and a plugin staged to a temp
+ * directory reads as the repository it came from.
+ *
+ * The drive letter is stripped FIRST, and that is not cosmetic: splitting on
+ * `:` alone treats `C:` as a separator, so a Windows path's "last segment" was
+ * the WHOLE path with every separator dashed — a clone of
+ * `C:\…\omc-clone-test\origin` landed in `…/projects/-Users-RUNNER-1-…-origin`
+ * instead of `…/projects/origin`. The `git@host:path` scp form keeps its colon,
+ * which is why this is a prefix strip rather than dropping `:` from the split.
+ */
+export function repoSlug(url: string): string {
+  const withoutDrive = url.replace(/^[a-z]:/i, '');
+  // Normalise every separator to `/` before splitting. A Windows path arrives
+  // with `\` (and, when it came from an escaped config value, with `\\`), so a
+  // split on `[/:]` would treat the whole tail as one segment and the "last
+  // segment" would be the entire path — the slug then became
+  // `-Users-x-repo` instead of `repo`.
+  const normalised = withoutDrive.replace(/\\/g, '/').replace(/\/+$/, '');
+  // A URL with no path segment at all (`https://`) names nothing to clone into,
+  // so it keeps the empty answer rather than a dashed scheme. `git@host:path`
+  // is handled by the same rule because the colon is a separator only when a
+  // path follows it.
+  const segments = normalised.split(/[/:]/).filter(Boolean);
+  const tail = segments.length === 0 ? '' : segments[segments.length - 1];
+  if (tail === '' || /^[a-z]+:$/i.test(tail) || /^https?:?$/i.test(tail)) return '';
+  return tail.replace(/\.git$/i, '').replace(/[^a-z0-9._-]/gi, '-');
+}