gitspace 0.2.0-rc.20 → 0.2.0-rc.21

package/src/utils/bun-socket-writer.ts

@@ -1,80 +0,0 @@
-import type { Socket } from "bun";
-
-type WritableData = Buffer | Uint8Array | ArrayBuffer;
-
-/**
- * Bun sockets are unbuffered. `socket.write()` can write fewer bytes than provided
- * under backpressure. For framed protocols, partial writes will desync the reader.
- *
- * This helper buffers pending bytes and flushes them when the socket drains.
- */
-export function createBufferedSocketWriter(socket: Socket<any>) {
-  const queue: Buffer[] = [];
-  let headOffset = 0;
-
-  const flush = () => {
-    while (queue.length > 0) {
-      const head = queue[0]!;
-      const remaining = head.length - headOffset;
-
-      if (remaining <= 0) {
-        queue.shift();
-        headOffset = 0;
-        continue;
-      }
-
-      const written = socket.write(head, headOffset, remaining);
-
-      // -1: closed/shutting down. 0: backpressure.
-      if (written <= 0) return;
-
-      headOffset += written;
-      if (headOffset >= head.length) {
-        queue.shift();
-        headOffset = 0;
-      }
-    }
-  };
-
-  const write = (data: WritableData) => {
-    // Copy into a stable Buffer (avoids subarray lifetime issues and ensures queue owns bytes)
-    const buf = Buffer.from(data as any);
-
-    // Fast-path if nothing queued.
-    if (queue.length === 0) {
-      const written = socket.write(buf);
-
-      if (written <= 0) {
-        queue.push(buf);
-        headOffset = 0;
-        return;
-      }
-
-      if (written >= buf.length) return;
-
-      queue.push(buf);
-      headOffset = written;
-      return;
-    }
-
-    queue.push(buf);
-    flush();
-  };
-
-  const clear = () => {
-    queue.length = 0;
-    headOffset = 0;
-  };
-
-  const pendingBytes = () => {
-    let total = 0;
-    for (let i = 0; i < queue.length; i++) total += queue[i]!.length;
-    return Math.max(0, total - headOffset);
-  };
-
-  return { write, flush, clear, pendingBytes };
-}
-
-
-
-

package/src/utils/clipboard.ts

@@ -1,53 +0,0 @@
-/**
- * Clipboard utilities for cross-platform clipboard operations.
- * 
- * Uses a multi-layered approach:
- * 1. OSC52 escape sequence - works over SSH, in tmux, remote terminals
- * 2. clipboardy - handles platform-specific clipboard (pbcopy, xclip, etc.)
- */
-
-import clipboard from 'clipboardy';
-
-/**
- * Copy text to clipboard using OSC52 + system clipboard fallback.
- * 
- * OSC52 is written first because it works in remote/SSH sessions where
- * the system clipboard wouldn't be accessible.
- * 
- * @param text - The text to copy to clipboard
- */
-export async function copyToClipboard(text: string): Promise<void> {
-  // 1. OSC52 escape sequence - works over SSH/remote sessions
-  // Format: ESC ] 52 ; c ; <base64-encoded-text> BEL
-  const base64 = Buffer.from(text).toString('base64');
-  const osc52 = `\x1b]52;c;${base64}\x07`;
-  
-  // Wrap for tmux compatibility - tmux requires DCS wrapper
-  const finalOsc52 = process.env['TMUX']
-    ? `\x1bPtmux;\x1b${osc52}\x1b\\`
-    : osc52;
-  
-  process.stdout.write(finalOsc52);
-
-  // 2. Also use clipboardy for local system clipboard
-  // This handles pbcopy (macOS), xclip/xsel (Linux), clip.exe (Windows)
-  try {
-    await clipboard.write(text);
-  } catch {
-    // OSC52 should have worked for terminal-based copying
-    // Silently ignore clipboardy failures (e.g., headless environment)
-  }
-}
-
-/**
- * Read text from clipboard.
- * 
- * @returns The clipboard text, or undefined if unavailable
- */
-export async function readFromClipboard(): Promise<string | undefined> {
-  try {
-    return await clipboard.read();
-  } catch {
-    return undefined;
-  }
-}

package/src/utils/deps.test.ts

@@ -1,31 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-import { checkCommandExists } from './deps.js';
-
-describe('checkCommandExists', () => {
-  test('returns true for commands that exist', async () => {
-    // These should exist on any system running this test
-    expect(await checkCommandExists('ls')).toBe(true);
-    expect(await checkCommandExists('which')).toBe(true);
-  });
-
-  test('returns false for commands that do not exist', async () => {
-    expect(await checkCommandExists('nonexistent-command-xyz-123')).toBe(false);
-  });
-
-  test('returns false for invalid command names (injection prevention)', async () => {
-    expect(await checkCommandExists('ls; echo hacked')).toBe(false);
-    expect(await checkCommandExists('ls && rm -rf /')).toBe(false);
-    expect(await checkCommandExists('$(whoami)')).toBe(false);
-    expect(await checkCommandExists('ls | cat')).toBe(false);
-    expect(await checkCommandExists('')).toBe(false);
-    expect(await checkCommandExists('cmd with spaces')).toBe(false);
-  });
-
-  test('allows valid command name characters', async () => {
-    // These are valid command name formats (alphanumeric, dash, underscore)
-    // They may not exist, but should pass validation
-    expect(await checkCommandExists('my-command')).toBe(false); // valid format, doesn't exist
-    expect(await checkCommandExists('my_command')).toBe(false); // valid format, doesn't exist
-    expect(await checkCommandExists('command123')).toBe(false); // valid format, doesn't exist
-  });
-});

package/src/utils/deps.ts

@@ -1,145 +0,0 @@
-/**
- * Dependency checking utilities
- */
-
-import { exec, execFile } from 'child_process';
-import { promisify } from 'util';
-import type { Dependency } from '../types/workspace.js';
-import { DependencyError, GitHubAuthError } from '../types/errors.js';
-import { logger } from './logger.js';
-
-const execAsync = promisify(exec);
-const execFileAsync = promisify(execFile);
-
-/**
- * Required system dependencies
- */
-export const REQUIRED_DEPS: Dependency[] = [
-  {
-    name: 'GitHub CLI',
-    command: 'gh',
-    checkArgs: ['--version'],
-    installUrl: 'https://cli.github.com/',
-    authCheck: async () => {
-      try {
-        await execAsync('gh auth status');
-        return true;
-      } catch {
-        return false;
-      }
-    },
-  },
-  {
-    name: 'Git',
-    command: 'git',
-    checkArgs: ['--version'],
-    installUrl: 'https://git-scm.com/',
-  },
-  {
-    name: 'jq',
-    command: 'jq',
-    checkArgs: ['--version'],
-    installUrl: 'https://stedolan.github.io/jq/',
-  },
-];
-
-/**
- * Check if a command exists by running it with args
- */
-async function commandExists(command: string, checkArgs: string[]): Promise<boolean> {
-  try {
-    await execAsync(`${command} ${checkArgs.join(' ')}`);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Check if a command exists in PATH using `which`
- * Validates command name to prevent injection
- */
-export async function checkCommandExists(command: string): Promise<boolean> {
-  if (!/^[a-zA-Z0-9_-]+$/.test(command)) {
-    return false;
-  }
-
-  try {
-    await execFileAsync('which', [command]);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Check all required dependencies
- */
-export async function checkDependencies(deps: Dependency[] = REQUIRED_DEPS): Promise<{
-  missing: Dependency[];
-  allPresent: boolean;
-}> {
-  const missing: Dependency[] = [];
-
-  for (const dep of deps) {
-    const exists = await commandExists(dep.command, dep.checkArgs);
-    if (!exists) {
-      missing.push(dep);
-    }
-  }
-
-  return {
-    missing,
-    allPresent: missing.length === 0,
-  };
-}
-
-/**
- * Check GitHub CLI authentication
- */
-export async function checkGitHubAuth(): Promise<void> {
-  const ghDep = REQUIRED_DEPS.find((d) => d.command === 'gh');
-  if (!ghDep?.authCheck) {
-    return;
-  }
-
-  const isAuthenticated = await ghDep.authCheck();
-  if (!isAuthenticated) {
-    throw new GitHubAuthError();
-  }
-}
-
-/**
- * Display missing dependencies and exit
- */
-export function displayMissingDependencies(missing: Dependency[]): never {
-  logger.error('Missing required dependencies:\n');
-
-  for (const dep of missing) {
-    logger.log(`  ${dep.name} (${dep.command})`);
-    logger.dim(`    Install: ${dep.installUrl}\n`);
-  }
-
-  throw new DependencyError(
-    'Please install the missing dependencies and try again.'
-  );
-}
-
-/**
- * Check dependencies and throw if any are missing
- */
-export async function ensureDependencies(deps?: Dependency[]): Promise<void> {
-  const { missing, allPresent } = await checkDependencies(deps);
-
-  if (!allPresent) {
-    displayMissingDependencies(missing);
-  }
-}
-
-/**
- * Check specific dependencies (subset of all required)
- */
-export async function checkSpecificDeps(commands: string[]): Promise<void> {
-  const depsToCheck = REQUIRED_DEPS.filter((d) => commands.includes(d.command));
-  await ensureDependencies(depsToCheck);
-}

package/src/utils/device.web.ts

@@ -1,163 +0,0 @@
-/**
- * Device detection utilities for mobile-specific behavior.
- * Comprehensive detection for iOS, Safari, PWA, and touch devices.
- */
-
-/**
- * Detect iOS devices (iPhone, iPad, iPod).
- * Includes detection for iPadOS 13+ which reports as MacIntel but has touch.
- */
-export function isIOSDevice(): boolean {
-  if (typeof navigator === 'undefined') return false;
-
-  const ua = navigator.userAgent;
-  const iOS = /iPad|iPhone|iPod/.test(ua);
-
-  // iPadOS 13+ reports as MacIntel but has touch support
-  const iPadOS =
-    navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 1;
-
-  return iOS || iPadOS;
-}
-
-/**
- * Detect if running as an installed PWA on iOS (standalone mode).
- */
-export function isIOSPWA(): boolean {
-  if (!isIOSDevice()) return false;
-  return (navigator as { standalone?: boolean }).standalone === true;
-}
-
-/**
- * Detect Safari browser (but not Chrome which includes "Safari" in UA).
- */
-export function isSafari(): boolean {
-  if (typeof navigator === 'undefined') return false;
-
-  const ua = navigator.userAgent;
-  return (
-    /Safari/.test(ua) && !/Chrome/.test(ua) && !/Chromium/.test(ua)
-  );
-}
-
-/**
- * Detect Android devices.
- */
-export function isAndroidDevice(): boolean {
-  if (typeof navigator === 'undefined') return false;
-  return /Android/.test(navigator.userAgent);
-}
-
-/**
- * Detect any mobile device (iOS or Android).
- */
-export function isMobileDevice(): boolean {
-  return isIOSDevice() || isAndroidDevice();
-}
-
-/**
- * Detect touch-capable device.
- * More reliable than checking for mobile OS since laptops can have touch.
- */
-export function isTouchDevice(): boolean {
-  if (typeof window === 'undefined') return false;
-
-  return (
-    'ontouchstart' in window ||
-    navigator.maxTouchPoints > 0 ||
-    // @ts-expect-error - msMaxTouchPoints is IE-specific
-    navigator.msMaxTouchPoints > 0
-  );
-}
-
-/**
- * Detect if device has a coarse pointer (finger/stylus vs mouse).
- * Uses CSS media query for reliable detection.
- */
-export function hasCoarsePointer(): boolean {
-  if (typeof window === 'undefined' || !window.matchMedia) return false;
-  return window.matchMedia('(pointer: coarse)').matches;
-}
-
-/**
- * Detect if device cannot hover (touch-only, no mouse).
- */
-export function cannotHover(): boolean {
-  if (typeof window === 'undefined' || !window.matchMedia) return false;
-  return window.matchMedia('(hover: none)').matches;
-}
-
-/**
- * Detect mobile layout based on viewport width.
- * Uses the same breakpoint as Tailwind's sm: (640px) or custom.
- */
-export function isMobileLayout(breakpoint = 768): boolean {
-  if (typeof window === 'undefined' || !window.matchMedia) return false;
-  return window.matchMedia(`(max-width: ${breakpoint - 1}px)`).matches;
-}
-
-/**
- * Get platform-specific modifier key name.
- * Returns 'Cmd' on Mac/iOS, 'Ctrl' on others.
- */
-export function getPlatformModifier(): 'Cmd' | 'Ctrl' {
-  if (typeof navigator === 'undefined') return 'Ctrl';
-
-  const isMac =
-    navigator.platform?.startsWith('Mac') ||
-    isIOSDevice();
-
-  return isMac ? 'Cmd' : 'Ctrl';
-}
-
-/**
- * Trigger haptic feedback if supported.
- * @param duration - Vibration duration in milliseconds (default: 10)
- */
-export function triggerHaptic(duration = 10): void {
-  if (typeof navigator === 'undefined') return;
-
-  if ('vibrate' in navigator) {
-    try {
-      navigator.vibrate(duration);
-    } catch (err) {
-      // Log in development for debugging
-      if (import.meta.env.DEV) {
-        console.debug('Haptic feedback not available:', err);
-      }
-    }
-  }
-}
-
-/**
- * Apply device-specific CSS classes to document element.
- * Call once on app initialization.
- */
-export function applyDeviceClasses(): void {
-  if (typeof document === 'undefined') return;
-
-  const root = document.documentElement;
-
-  if (isIOSDevice()) {
-    root.classList.add('ios-device');
-    if (isIOSPWA()) {
-      root.classList.add('ios-pwa');
-    }
-  }
-
-  if (isSafari()) {
-    root.classList.add('safari');
-  }
-
-  if (isAndroidDevice()) {
-    root.classList.add('android-device');
-  }
-
-  if (isTouchDevice()) {
-    root.classList.add('touch-device');
-  }
-
-  if (hasCoarsePointer()) {
-    root.classList.add('coarse-pointer');
-  }
-}

package/src/utils/fuzzy-match.ts

@@ -1,125 +0,0 @@
-/**
- * Fuzzy matching algorithm
- * Matches query against candidates and returns scored results
- */
-
-import type { FuzzyMatch, WorkspaceCandidate } from '../types/workspace-fuzzy.js';
-
-/**
- * Perform fuzzy matching on workspace candidates
- *
- * Algorithm:
- * 1. For each candidate, calculate match score
- * 2. Filter out scores below threshold (30)
- * 3. Sort by score descending
- *
- * @param query Search string
- * @param candidates List of workspace candidates
- * @returns Sorted array of matches with scores
- */
-export function fuzzyMatch(
-  query: string,
-  candidates: WorkspaceCandidate[]
-): FuzzyMatch[] {
-  const matches: FuzzyMatch[] = [];
-
-  for (const candidate of candidates) {
-    const result = calculateMatchScore(query, candidate.name);
-
-    if (result.score >= 30) {  // Minimum threshold
-      matches.push({
-        item: candidate,
-        score: result.score,
-        matchedIndices: result.matchedIndices,
-      });
-    }
-  }
-
-  // Sort by score descending
-  matches.sort((a, b) => b.score - a.score);
-
-  return matches;
-}
-
-/**
- * Calculate fuzzy match score between query and candidate
- *
- * Scoring rules:
- * - All query characters must exist in order: otherwise score = 0
- * - Consecutive character matches: +10 points per consecutive char
- * - Word boundary matches: +5 points (e.g., "fb" matches "feature-branch")
- * - Exact case match: +2 points per char
- * - Start of string match: +15 points
- * - Character proximity: -1 point per gap
- * - Base score: 50 points if all chars match
- *
- * @param query Search string
- * @param candidate String to match against
- * @returns Object with score and matched character indices
- */
-function calculateMatchScore(
-  query: string,
-  candidate: string
-): { score: number; matchedIndices: number[] } {
-  if (!query || !candidate) {
-    return { score: 0, matchedIndices: [] };
-  }
-
-  const queryLower = query.toLowerCase();
-  const candidateLower = candidate.toLowerCase();
-
-  // Find all query characters in candidate
-  const matchedIndices: number[] = [];
-  let candidateIndex = 0;
-
-  for (let i = 0; i < queryLower.length; i++) {
-    const queryChar = queryLower[i];
-    const foundIndex = candidateLower.indexOf(queryChar, candidateIndex);
-
-    if (foundIndex === -1) {
-      // Character not found - no match
-      return { score: 0, matchedIndices: [] };
-    }
-
-    matchedIndices.push(foundIndex);
-    candidateIndex = foundIndex + 1;
-  }
-
-  // All characters matched - start with base score
-  let score = 50;
-
-  // Bonus: Start of string match
-  if (matchedIndices[0] === 0) {
-    score += 15;
-  }
-
-  // Calculate bonuses for consecutive matches, word boundaries, and case
-  for (let i = 0; i < matchedIndices.length; i++) {
-    const index = matchedIndices[i];
-    const queryChar = query[i];
-    const candidateChar = candidate[index];
-
-    // Consecutive match bonus
-    if (i > 0 && matchedIndices[i] === matchedIndices[i - 1] + 1) {
-      score += 10;
-    }
-
-    // Word boundary bonus (after -, _, /, or at start)
-    if (index === 0 || ['-', '_', '/'].includes(candidate[index - 1])) {
-      score += 5;
-    }
-
-    // Exact case match bonus
-    if (queryChar === candidateChar) {
-      score += 2;
-    }
-
-    // Proximity penalty (gap between matched characters)
-    if (i > 0) {
-      const gap = matchedIndices[i] - matchedIndices[i - 1] - 1;
-      score -= gap;  // -1 point per character gap
-    }
-  }
-
-  return { score, matchedIndices };
-}

package/src/utils/hostnames.ts

@@ -1,43 +0,0 @@
-const MAX_LABEL_LENGTH = 63;
-const MAX_HOSTNAME_LENGTH = 253;
-
-function clampLabel(value: string, maxLength: number): string {
-  if (value.length <= maxLength) return value;
-  const trimmed = value.slice(0, maxLength).replace(/-+$/g, '');
-  return trimmed.length > 0 ? trimmed : 'x';
-}
-
-export function normalizeHostLabel(value: string): string {
-  const normalized = value
-    .toLowerCase()
-    .replace(/[^a-z0-9-]/g, '-')
-    .replace(/-+/g, '-')
-    .replace(/^-|-$/g, '');
-  if (!normalized) return 'x';
-  return clampLabel(normalized, MAX_LABEL_LENGTH);
-}
-
-export function buildProcessHostname(
-  serveDomain: string,
-  workspaceId: string,
-  processName: string,
-  instance: number,
-  portLabel: string
-): string {
-  const workspaceSegment = normalizeHostLabel(workspaceId);
-  const processSegment = normalizeHostLabel(processName);
-  const portSegment = normalizeHostLabel(portLabel);
-
-  const base = `${portSegment}.${processSegment}-${instance}`;
-  const suffix = `.${serveDomain}`;
-  let hostname = `${base}.${workspaceSegment}${suffix}`;
-
-  if (hostname.length <= MAX_HOSTNAME_LENGTH) {
-    return hostname;
-  }
-
-  const availableWorkspace = MAX_HOSTNAME_LENGTH - base.length - suffix.length - 1;
-  const trimmedWorkspace = clampLabel(workspaceSegment, Math.max(1, availableWorkspace));
-  hostname = `${base}.${trimmedWorkspace}${suffix}`;
-  return hostname;
-}

package/src/utils/hunk-header.ts

@@ -1,17 +0,0 @@
-export function normalizeHunkHeader(header: string): string {
-  const trimmed = header.trim();
-  if (!trimmed) {
-    return '@@ @@';
-  }
-
-  const match = trimmed.match(/^@@\s*(.*?)\s*@@(?:\s*(.*))?$/);
-  if (!match) {
-    return trimmed.replace(/\s+/g, ' ');
-  }
-
-  const specs = (match[1] ?? '').trim().replace(/\s+/g, ' ');
-  const context = (match[2] ?? '').trim().replace(/\s+/g, ' ');
-
-  const headerCore = specs ? `@@ ${specs} @@` : '@@ @@';
-  return context ? `${headerCore} ${context}` : headerCore;
-}

package/src/utils/id.ts

@@ -1,9 +0,0 @@
-/**
- * Generate a reasonably unique identifier.
- */
-export function generateId(): string {
-  if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
-    return crypto.randomUUID();
-  }
-  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
-}