im-pickle-rick 0.1.0

package/src/utils/search.ts

@@ -0,0 +1,103 @@
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+
+export interface SearchOptions {
+  limit?: number;
+  timeoutMs?: number;
+  ignore?: string[];
+}
+
+export interface SearchResult {
+  files: string[];
+  truncated: boolean;
+}
+
+export function fuzzyScore(text: string, query: string): number {
+  if (!query) return 1;
+  const target = text.toLowerCase();
+  const pattern = query.toLowerCase();
+  
+  let score = 0;
+  let queryIdx = 0;
+  
+  // Check for exact substring match first (highest priority)
+  if (target.includes(pattern)) {
+    score += 100;
+    // Bonus for matching at start of path segment
+    if (target.startsWith(pattern) || target.includes("/" + pattern)) {
+      score += 50;
+    }
+  }
+
+  // Fallback to subsequence matching
+  for (let i = 0; i < target.length && queryIdx < pattern.length; i++) {
+    if (target[i] === pattern[queryIdx]) {
+      queryIdx++;
+      if (queryIdx === 1) {
+        // Bonus for matching first char at start of segment
+        if (i === 0 || target[i-1] === "/" || target[i-1] === "_" || target[i-1] === "-") {
+          score += 10;
+        }
+      }
+    }
+  }
+
+  return queryIdx === pattern.length ? score + 1 : 0;
+}
+
+export function fuzzyMatch(text: string, query: string): boolean {
+  return fuzzyScore(text, query) > 0;
+}
+
+export async function recursiveSearch(
+  dir: string,
+  query: string,
+  options: SearchOptions = {}
+): Promise<SearchResult> {
+  const { limit = 20000, timeoutMs = 250, ignore = ["node_modules", ".git", "dist", ".DS_Store"] } = options;
+  const start = Date.now();
+  const results: { path: string, score: number }[] = [];
+  let fileCount = 0;
+  let truncated = false;
+
+  async function walk(currentDir: string) {
+    if (truncated) return;
+    if (Date.now() - start >= timeoutMs) {
+      truncated = true;
+      return;
+    }
+
+    try {
+      const entries = await readdir(currentDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (truncated) return;
+        if (ignore.includes(entry.name)) continue;
+
+        const fullPath = join(currentDir, entry.name);
+        if (entry.isDirectory()) {
+          await walk(fullPath);
+        } else {
+          fileCount++;
+          const relativePath = fullPath.replace(dir + "/", "");
+          const score = fuzzyScore(relativePath, query);
+          if (score > 0) {
+            results.push({ path: fullPath, score });
+          }
+          if (fileCount >= limit) {
+            truncated = true;
+            return;
+          }
+        }
+      }
+    } catch (err) {
+      // Silently ignore
+    }
+  }
+
+  await walk(dir);
+
+  // Sort by score descending
+  results.sort((a, b) => b.score - a.score);
+
+  return { files: results.map(r => r.path), truncated };
+}

package/src/utils/session-tracker.test.ts

@@ -0,0 +1,46 @@
+import { expect, test, describe, beforeEach } from "bun:test";
+import { sessionTracker, type TrackedSession } from "./session-tracker.js";
+
+describe("SessionTracker", () => {
+    beforeEach(() => {
+        sessionTracker.clear();
+    });
+
+    const mockSession: TrackedSession = {
+        id: "session-1",
+        prompt: "Test Prompt",
+        createdAt: 1000,
+        startedAt: "2026-02-03T00:00:00Z",
+        sessionDir: "/tmp/session-1"
+    };
+
+    test("should add and track a session", () => {
+        sessionTracker.addSession(mockSession);
+        expect(sessionTracker.isTracked("session-1")).toBe(true);
+        expect(sessionTracker.getTrackedSessions()).toHaveLength(1);
+    });
+
+    test("should update a session", () => {
+        sessionTracker.addSession(mockSession);
+        sessionTracker.updateSession("session-1", { status: "running", iteration: 5 });
+        
+        const sessions = sessionTracker.getTrackedSessions();
+        expect(sessions[0].status).toBe("running");
+        expect(sessions[0].iteration).toBe(5);
+    });
+
+    test("should remove a session", () => {
+        sessionTracker.addSession(mockSession);
+        sessionTracker.removeSession("session-1");
+        expect(sessionTracker.isTracked("session-1")).toBe(false);
+    });
+
+    test("should sort sessions by createdAt descending", () => {
+        sessionTracker.addSession({ ...mockSession, id: "old", createdAt: 1000 });
+        sessionTracker.addSession({ ...mockSession, id: "new", createdAt: 2000 });
+        
+        const sessions = sessionTracker.getTrackedSessions();
+        expect(sessions[0].id).toBe("new");
+        expect(sessions[1].id).toBe("old");
+    });
+});

package/src/utils/session-tracker.ts

@@ -0,0 +1,67 @@
+/**
+ * Global session tracking utility
+ * Tracks sessions created from the current UI instance (LandingView/Dashboard)
+ */
+
+export interface TrackedSession {
+  id: string;
+  prompt: string;
+  createdAt: number;
+  startedAt: string;
+  sessionDir: string;
+  status?: string;
+  iteration?: number;
+}
+
+class SessionTracker {
+  private sessions: Map<string, TrackedSession> = new Map();
+
+  /**
+   * Add a session to the tracking list
+   */
+  public addSession(session: TrackedSession): void {
+    this.sessions.set(session.id, session);
+  }
+
+  /**
+   * Update status/iteration metadata for a tracked session
+   */
+  public updateSession(sessionId: string, partial: Partial<TrackedSession>): void {
+    const existing = this.sessions.get(sessionId);
+    if (!existing) return;
+    this.sessions.set(sessionId, { ...existing, ...partial });
+  }
+
+  /**
+   * Remove a session from tracking
+   */
+  public removeSession(sessionId: string): void {
+    this.sessions.delete(sessionId);
+  }
+
+  /**
+   * Get all tracked sessions
+   */
+  public getTrackedSessions(): TrackedSession[] {
+    return Array.from(this.sessions.values()).sort(
+      (a, b) => b.createdAt - a.createdAt
+    );
+  }
+
+  /**
+   * Clear all tracked sessions (for testing/cleanup)
+   */
+  public clear(): void {
+    this.sessions.clear();
+  }
+
+  /**
+   * Check if a session is being tracked
+   */
+  public isTracked(sessionId: string): boolean {
+    return this.sessions.has(sessionId);
+  }
+}
+
+// Export singleton instance
+export const sessionTracker = new SessionTracker();

package/src/utils/spinner.test.ts

@@ -0,0 +1,54 @@
+import { expect, test, describe, beforeEach, afterEach, mock } from "bun:test";
+import { Spinner } from "./spinner.js";
+
+describe("Spinner Utility", () => {
+    let spinner: Spinner;
+    let originalWrite: any;
+    let mockWrite: any;
+
+    beforeEach(() => {
+        originalWrite = process.stdout.write;
+        mockWrite = mock(() => true);
+        process.stdout.write = mockWrite;
+        spinner = new Spinner();
+    });
+
+    afterEach(() => {
+        if (spinner['timer']) {
+            clearInterval(spinner['timer']);
+        }
+        process.stdout.write = originalWrite;
+    });
+
+    test("should start and create newline", () => {
+        spinner.start("Thinking...");
+        const calls = mockWrite.mock.calls.flat();
+        expect(calls).toContain("\x1B[?25l");
+        expect(calls).toContain("\n"); // Check for the initial newline
+        expect(calls.some((c: string) => c.includes("Thinking..."))).toBe(true);
+    });
+
+    test("should stop and show cursor", () => {
+        spinner.start("Work");
+        mockWrite.mockClear();
+        spinner.stop("Done");
+        
+        const calls = mockWrite.mock.calls.flat();
+        expect(calls).toContain("\x1B[?25h");
+    });
+
+    test("should use move-up logic in printAbove", () => {
+        spinner.start("Spinning");
+        mockWrite.mockClear();
+        
+        spinner.printAbove("Log message");
+        
+        const calls = mockWrite.mock.calls.flat();
+        // Sequence: Clear -> Up -> Content -> Newline -> Render
+        expect(calls[0]).toBe('\r\x1B[K');
+        expect(calls[1]).toBe('\x1B[1A'); // The key fix
+        expect(calls[2]).toBe("Log message");
+        expect(calls[3]).toBe("\n");
+        expect(calls[4]).toContain("Spinning");
+    });
+});

package/src/utils/spinner.ts

@@ -0,0 +1,87 @@
+import pc from "picocolors";
+
+export class Spinner {
+    private timer: Timer | null = null;
+    private text: string = "";
+    private frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    private frameIndex = 0;
+    private isSpinning = false;
+
+    start(text: string) {
+        if (this.isSpinning) {
+            this.update(text);
+            return;
+        }
+        this.isSpinning = true;
+        this.text = text;
+        process.stdout.write("\x1B[?25l"); // Hide cursor
+        
+        // Create a new line for the spinner to live on
+        process.stdout.write("\n"); 
+        
+        this.render();
+        this.timer = setInterval(() => {
+            this.frameIndex = (this.frameIndex + 1) % this.frames.length;
+            this.render();
+        }, 80);
+    }
+
+    stop(message?: string, type: 'success' | 'error' = 'success') {
+        if (!this.isSpinning) return;
+        clearInterval(this.timer!);
+        this.timer = null;
+        this.isSpinning = false;
+        
+        this.clearLine();
+        
+        if (message) {
+            const symbol = type === 'success' ? pc.green('✔') : pc.red('✖');
+            process.stdout.write(`\r${symbol} ${message}\n`);
+        }
+        process.stdout.write("\x1B[?25h"); // Show cursor
+    }
+
+    success(text: string) {
+        this.stop(text, 'success');
+    }
+
+    error(text: string) {
+        this.stop(text, 'error');
+    }
+
+    update(text: string) {
+        this.text = text;
+    }
+
+    printAbove(content: string) {
+        if (this.isSpinning) {
+            // 1. Clear the spinner line
+            process.stdout.write('\r\x1B[K');
+            // 2. Move cursor up to the previous line (the log line)
+            process.stdout.write('\x1B[1A');
+            // 3. Print content (this appends to the log line)
+            process.stdout.write(content);
+            
+            // 4. Ensure we return to the spinner line
+            if (!content.endsWith('\n')) {
+                 process.stdout.write('\n');
+            }
+            
+            // 5. Redraw spinner
+            this.render();
+        } else {
+            // Fallback if not spinning
+            process.stdout.write(content);
+            if (!content.endsWith('\n')) process.stdout.write('\n');
+        }
+    }
+
+    private clearLine() {
+        process.stdout.write('\r\x1B[K');
+    }
+
+    private render() {
+        const frame = pc.cyan(this.frames[this.frameIndex]);
+        process.stdout.write(`\r${frame} ${this.text}`);
+    }
+}