pi-var 1.0.1

package/extensions/pi-var/__tests__/unit/command.test.ts

@@ -0,0 +1,322 @@
+/**
+ * Unit tests for /var command (autoregressive version)
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { registerVarCommand } from '../../src/tools/command/index';
+import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent';
+import type { VarRuntime, Variation } from '../../src/types/index';
+import type { RuntimeStore } from '../../src/state/types';
+
+// Mock the dependencies
+function createMockRuntimeStore(): RuntimeStore {
+  return {
+    ensure: vi.fn(),
+    get: vi.fn(),
+    delete: vi.fn(),
+    persistState: vi.fn(),
+    restoreState: vi.fn(),
+  };
+}
+
+function createMockDeps(runtime: VarRuntime = createMockRuntime()) {
+  return {
+    pi: {
+      registerCommand: vi.fn(),
+      on: vi.fn(),
+      exec: vi.fn().mockResolvedValue({ code: 0, stdout: '', stderr: '' }),
+      appendEntry: vi.fn(),
+    } as unknown as ExtensionAPI,
+    getRuntime: () => runtime,
+    runtimeStore: createMockRuntimeStore(),
+  };
+}
+
+function createMockRuntime(
+  overrides: Partial<VarRuntime> & { state?: Partial<VarRuntime['state']> } = {}
+): VarRuntime {
+  return {
+    state: {
+      activeVariationId: null,
+      variations: [],
+      sessionId: 'test-session',
+      ...overrides.state,
+    },
+
+    lastPersisted: Date.now(),
+    ...overrides,
+  };
+}
+
+function createMockCtx(overrides: Partial<ExtensionContext> = {}): ExtensionContext {
+  return {
+    cwd: '/home/user/project',
+    ui: {
+      notify: vi.fn(),
+      confirm: vi.fn().mockResolvedValue(true),
+      setStatus: vi.fn(),
+    },
+    hasUI: true,
+    sessionManager: {
+      getSessionId: vi.fn().mockReturnValue('test-session'),
+      getEntries: vi.fn().mockReturnValue([]),
+    },
+    ...overrides,
+  } as unknown as ExtensionContext;
+}
+
+function createMockVariation(overrides: Partial<Variation> = {}): Variation {
+  return {
+    id: 'var-123',
+    name: 'test-variation',
+    path: '/tmp/variations/project-abc/test-var',
+    sourcePath: '/home/user/project',
+    type: 'cow',
+    createdAt: new Date().toISOString(),
+    lastAccessed: new Date().toISOString(),
+    ...overrides,
+  };
+}
+
+describe('registerVarCommand', () => {
+  it('should register the /var command', () => {
+    const deps = createMockDeps();
+    registerVarCommand(deps.pi, deps);
+
+    expect(deps.pi.registerCommand).toHaveBeenCalledWith(
+      'var',
+      expect.objectContaining({
+        description: expect.stringContaining('status'),
+        handler: expect.any(Function),
+      })
+    );
+  });
+
+  it('should register command handler', () => {
+    const deps = createMockDeps();
+    registerVarCommand(deps.pi, deps);
+
+    expect(deps.pi.registerCommand).toHaveBeenCalled();
+  });
+});
+
+describe('var command - status (no args)', () => {
+  let deps: ReturnType<typeof createMockDeps>;
+  let handler: Function;
+
+  beforeEach(() => {
+    deps = createMockDeps();
+    registerVarCommand(deps.pi, deps);
+    handler = vi.mocked(deps.pi.registerCommand).mock.calls[0][1].handler;
+  });
+
+  it('should show autoregressive message when no variations', async () => {
+    const ctx = createMockCtx();
+    await handler('', ctx);
+
+    expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringContaining('create_variation'), 'info');
+  });
+
+  it('should show active variation in status', async () => {
+    const variation = createMockVariation({ id: 'var-1', name: 'feature-auth' });
+    const runtime = createMockRuntime({
+      state: {
+        variations: [variation],
+        activeVariationId: 'var-1',
+        sessionId: 'test-session',
+      },
+    });
+    deps = createMockDeps(runtime);
+    registerVarCommand(deps.pi, deps);
+    handler = vi.mocked(deps.pi.registerCommand).mock.calls[0][1].handler;
+
+    const ctx = createMockCtx();
+    await handler('', ctx);
+
+    expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringContaining('feature-auth'), 'info');
+    expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringContaining('🌿'), 'info');
+  });
+});
+
+describe('var command - list', () => {
+  let deps: ReturnType<typeof createMockDeps>;
+  let handler: Function;
+
+  beforeEach(() => {
+    deps = createMockDeps();
+    registerVarCommand(deps.pi, deps);
+    handler = vi.mocked(deps.pi.registerCommand).mock.calls[0][1].handler;
+  });
+
+  it('should list variations with type indicators', async () => {
+    const variation = createMockVariation({ id: 'var-1', name: 'feature-auth', type: 'cow' });
+    const runtime = createMockRuntime({
+      state: {
+        variations: [variation],
+        activeVariationId: null,
+        sessionId: 'test-session',
+      },
+    });
+    deps = createMockDeps(runtime);
+    registerVarCommand(deps.pi, deps);
+    handler = vi.mocked(deps.pi.registerCommand).mock.calls[0][1].handler;
+
+    const ctx = createMockCtx();
+    await handler('list', ctx);
+
+    expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringContaining('feature-auth'), 'info');
+    expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringContaining('⚡'), 'info');
+  });
+});
+
+describe('var command - stop (return to source)', () => {
+  let deps: ReturnType<typeof createMockDeps>;
+  let handler: Function;
+
+  beforeEach(() => {
+    deps = createMockDeps();
+    registerVarCommand(deps.pi, deps);
+    handler = vi.mocked(deps.pi.registerCommand).mock.calls[0][1].handler;
+  });
+
+  it('should deactivate current variation with stop', async () => {
+    const variation = createMockVariation({ id: 'var-1', name: 'feature-auth' });
+    const runtime = createMockRuntime({
+      state: {
+        variations: [variation],
+        activeVariationId: 'var-1',
+        sessionId: 'test-session',
+      },
+    });
+    deps = createMockDeps(runtime);
+    registerVarCommand(deps.pi, deps);
+    handler = vi.mocked(deps.pi.registerCommand).mock.calls[0][1].handler;
+
+    const ctx = createMockCtx();
+    await handler('stop', ctx);
+
+    expect(runtime.state.activeVariationId).toBeNull();
+
+    expect(ctx.ui.setStatus).toHaveBeenCalledWith('pi-var', '');
+    // Should persist state after stop
+    expect(deps.runtimeStore.persistState).toHaveBeenCalled();
+  });
+
+  it('should handle stop when already in source', async () => {
+    const runtime = createMockRuntime({
+      state: {
+        variations: [],
+        activeVariationId: null,
+        sessionId: 'test-session',
+      },
+    });
+    deps = createMockDeps(runtime);
+    registerVarCommand(deps.pi, deps);
+    handler = vi.mocked(deps.pi.registerCommand).mock.calls[0][1].handler;
+
+    const ctx = createMockCtx();
+    await handler('stop', ctx);
+
+    expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringContaining('Already'), 'info');
+  });
+});
+
+describe('var command - clean', () => {
+  let deps: ReturnType<typeof createMockDeps>;
+  let handler: Function;
+
+  beforeEach(() => {
+    deps = createMockDeps();
+    registerVarCommand(deps.pi, deps);
+    handler = vi.mocked(deps.pi.registerCommand).mock.calls[0][1].handler;
+  });
+
+  it('should show usage when no name or stale flag', async () => {
+    const ctx = createMockCtx();
+    await handler('clean', ctx);
+
+    expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringContaining('Usage'), 'warning');
+  });
+
+  it('should require confirmation before cleaning', async () => {
+    const variation = createMockVariation({ id: 'var-1', name: 'old-feature' });
+    const runtime = createMockRuntime({
+      state: { variations: [variation], activeVariationId: null, sessionId: 'test-session' },
+    });
+    deps = createMockDeps(runtime);
+    registerVarCommand(deps.pi, deps);
+    handler = vi.mocked(deps.pi.registerCommand).mock.calls[0][1].handler;
+
+    const ctx = createMockCtx();
+    ctx.ui.confirm = vi.fn().mockResolvedValue(false);
+
+    await handler('clean old-feature', ctx);
+
+    expect(ctx.ui.confirm).toHaveBeenCalled();
+    expect(ctx.ui.notify).toHaveBeenCalledWith('Clean cancelled', 'info');
+  });
+
+  it('should error when variation not found', async () => {
+    const ctx = createMockCtx();
+    await handler('clean non-existent', ctx);
+
+    expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringContaining('not found'), 'error');
+  });
+});
+
+describe('var command - stale cleanup', () => {
+  let deps: ReturnType<typeof createMockDeps>;
+  let handler: Function;
+
+  beforeEach(() => {
+    deps = createMockDeps();
+    registerVarCommand(deps.pi, deps);
+    handler = vi.mocked(deps.pi.registerCommand).mock.calls[0][1].handler;
+  });
+
+  it('should clean variations older than specified days', async () => {
+    const oldVariation = createMockVariation({
+      id: 'var-1',
+      name: 'old-feature',
+      lastAccessed: new Date(Date.now() - 10 * 24 * 60 * 60 * 1000).toISOString(), // 10 days ago
+    });
+    const runtime = createMockRuntime({
+      state: {
+        variations: [oldVariation],
+        activeVariationId: null,
+        sessionId: 'test-session',
+      },
+    });
+    deps = createMockDeps(runtime);
+    registerVarCommand(deps.pi, deps);
+    handler = vi.mocked(deps.pi.registerCommand).mock.calls[0][1].handler;
+
+    const ctx = createMockCtx();
+    await handler('clean --stale 7', ctx);
+
+    expect(ctx.ui.confirm).toHaveBeenCalled();
+  });
+
+  it('should show message when no stale variations found', async () => {
+    const freshVariation = createMockVariation({
+      id: 'var-1',
+      name: 'fresh-feature',
+      lastAccessed: new Date().toISOString(),
+    });
+    const runtime = createMockRuntime({
+      state: {
+        variations: [freshVariation],
+        activeVariationId: null,
+        sessionId: 'test-session',
+      },
+    });
+    deps = createMockDeps(runtime);
+    registerVarCommand(deps.pi, deps);
+    handler = vi.mocked(deps.pi.registerCommand).mock.calls[0][1].handler;
+
+    const ctx = createMockCtx();
+    await handler('clean --stale 7', ctx);
+
+    expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringContaining('No variations'), 'info');
+  });
+});

package/extensions/pi-var/__tests__/unit/cow-detection.test.ts

@@ -0,0 +1,340 @@
+/**
+ * Unit tests for CoW detection types and logic
+ * Tests the decision-making logic rather than mocking system calls
+ */
+
+import { describe, it, expect } from 'vitest';
+import type { CoWDetectionResult } from '../../src/types/index';
+
+describe('CoWDetectionResult type structure', () => {
+  it('should have the correct structure for successful CoW without EDR', () => {
+    const result: CoWDetectionResult = {
+      supported: true,
+      method: 'clonefile',
+      edr: {
+        detected: false,
+        products: [],
+        hasSlowCoWEDR: false,
+      },
+      performance: {
+        fast: true,
+        durationMs: 10,
+        samples: 2,
+        maxDurationMs: 12,
+        confidence: 'high',
+      },
+      recommendedType: 'cow',
+    };
+
+    expect(result.supported).toBe(true);
+    expect(result.method).toBe('clonefile');
+    expect(result.edr?.detected).toBe(false);
+    expect(result.edr?.hasSlowCoWEDR).toBe(false);
+    expect(result.performance?.fast).toBe(true);
+    expect(result.performance?.confidence).toBe('high');
+    expect(result.recommendedType).toBe('cow');
+  });
+
+  it('should have the correct structure when known slow EDR detected (short-circuit)', () => {
+    // When CrowdStrike is detected, we short-circuit to worktree without timing
+    const result: CoWDetectionResult = {
+      supported: true,
+      method: 'clonefile',
+      edr: {
+        detected: true,
+        products: ['CrowdStrike Falcon'],
+        hasSlowCoWEDR: true,
+      },
+      recommendedType: 'worktree',
+    };
+
+    expect(result.supported).toBe(true);
+    expect(result.edr?.detected).toBe(true);
+    expect(result.edr?.hasSlowCoWEDR).toBe(true);
+    expect(result.performance).toBeUndefined(); // No timing needed
+    expect(result.recommendedType).toBe('worktree');
+  });
+
+  it('should have the correct structure when EDR detected but CoW still fast', () => {
+    const result: CoWDetectionResult = {
+      supported: true,
+      method: 'clonefile',
+      edr: {
+        detected: true,
+        products: ['Microsoft Defender'],
+        hasSlowCoWEDR: false,
+      },
+      performance: {
+        fast: true,
+        durationMs: 15,
+        samples: 2,
+        maxDurationMs: 18,
+        confidence: 'high',
+      },
+      recommendedType: 'cow',
+    };
+
+    expect(result.supported).toBe(true);
+    expect(result.edr?.detected).toBe(true);
+    expect(result.edr?.hasSlowCoWEDR).toBe(false);
+    expect(result.performance?.fast).toBe(true);
+    expect(result.performance?.confidence).toBe('high');
+    expect(result.recommendedType).toBe('cow');
+  });
+
+  it('should recommend worktree in medium confidence (gray zone)', () => {
+    // 20-100ms is the gray zone - conservative approach uses worktree
+    const result: CoWDetectionResult = {
+      supported: true,
+      method: 'clonefile',
+      edr: {
+        detected: false,
+        products: [],
+        hasSlowCoWEDR: false,
+      },
+      performance: {
+        fast: false, // Conservative in gray zone
+        durationMs: 45,
+        samples: 2,
+        maxDurationMs: 48,
+        confidence: 'medium',
+      },
+      recommendedType: 'worktree',
+    };
+
+    expect(result.supported).toBe(true);
+    expect(result.performance?.confidence).toBe('medium');
+    expect(result.performance?.fast).toBe(false);
+    expect(result.recommendedType).toBe('worktree');
+  });
+
+  it('should recommend worktree when timing shows spikes', () => {
+    // Spike detection: max >> average indicates intermittent interference
+    const result: CoWDetectionResult = {
+      supported: true,
+      method: 'reflink',
+      edr: {
+        detected: true,
+        products: ['Unknown EDR'],
+        hasSlowCoWEDR: false,
+      },
+      performance: {
+        fast: false,
+        durationMs: 25, // Average in gray zone
+        samples: 2,
+        maxDurationMs: 150, // But spike into slow territory
+        confidence: 'medium',
+      },
+      recommendedType: 'worktree', // Spike triggers conservative choice
+    };
+
+    expect(result.supported).toBe(true);
+    expect(result.performance?.maxDurationMs).toBe(150);
+    expect(result.recommendedType).toBe('worktree');
+  });
+
+  it('should recommend worktree when CoW is not supported', () => {
+    const result: CoWDetectionResult = {
+      supported: false,
+      edr: {
+        detected: false,
+        products: [],
+        hasSlowCoWEDR: false,
+      },
+      recommendedType: 'worktree',
+    };
+
+    expect(result.supported).toBe(false);
+    expect(result.method).toBeUndefined();
+    expect(result.recommendedType).toBe('worktree');
+  });
+
+  it('should handle Windows case (no CoW support)', () => {
+    const result: CoWDetectionResult = {
+      supported: false,
+      edr: {
+        detected: true,
+        products: ['Microsoft Defender'],
+        hasSlowCoWEDR: false,
+      },
+      recommendedType: 'worktree',
+    };
+
+    expect(result.supported).toBe(false);
+    expect(result.edr?.detected).toBe(true);
+    expect(result.recommendedType).toBe('worktree');
+  });
+});
+
+describe('Confidence level logic', () => {
+  function getConfidence(
+    avgTiming: number,
+    fastThreshold = 20,
+    slowThreshold = 100
+  ): 'high' | 'medium' | 'low' {
+    if (avgTiming < fastThreshold) return 'high';
+    if (avgTiming > slowThreshold) return 'high';
+    return 'medium';
+  }
+
+  it('should assign high confidence to fast timings', () => {
+    expect(getConfidence(5)).toBe('high');
+    expect(getConfidence(10)).toBe('high');
+    expect(getConfidence(19)).toBe('high');
+  });
+
+  it('should assign high confidence to clearly slow timings', () => {
+    expect(getConfidence(101)).toBe('high');
+    expect(getConfidence(150)).toBe('high');
+    expect(getConfidence(500)).toBe('high');
+  });
+
+  it('should assign medium confidence to gray zone timings', () => {
+    expect(getConfidence(20)).toBe('medium');
+    expect(getConfidence(50)).toBe('medium');
+    expect(getConfidence(99)).toBe('medium');
+    expect(getConfidence(100)).toBe('medium'); // At boundary
+  });
+});
+
+describe('Spike detection logic', () => {
+  function hasSpike(
+    avgTiming: number,
+    maxTiming: number,
+    slowThreshold = 100,
+    ratioThreshold = 3
+  ): boolean {
+    return maxTiming > avgTiming * ratioThreshold && maxTiming > slowThreshold;
+  }
+
+  it('should detect spikes when max is much higher than average', () => {
+    expect(hasSpike(10, 150)).toBe(true); // 15x average, above threshold
+    expect(hasSpike(20, 150)).toBe(true); // 7.5x average, above threshold
+    expect(hasSpike(30, 150)).toBe(true); // 5x average, above threshold
+  });
+
+  it('should not detect spikes when max is close to average', () => {
+    expect(hasSpike(10, 15)).toBe(false); // 1.5x average
+    expect(hasSpike(50, 80)).toBe(false); // 1.6x average
+    expect(hasSpike(40, 100)).toBe(false); // 2.5x average, at threshold
+  });
+
+  it('should not detect spikes when max is below slow threshold', () => {
+    expect(hasSpike(10, 50)).toBe(false); // 5x average but below threshold
+    expect(hasSpike(20, 80)).toBe(false); // 4x average but below threshold
+  });
+});
+
+describe('Recommendation decision matrix', () => {
+  function getRecommendation(
+    cowSupported: boolean,
+    hasSlowCoWEDR: boolean,
+    cowFast: boolean,
+    confidence: 'high' | 'medium' | 'low',
+    hasSpike: boolean,
+    isGitRepo: boolean
+  ): 'cow' | 'worktree' | 'copy' {
+    // Priority 1: Known slow EDR - always worktree
+    if (hasSlowCoWEDR) {
+      return isGitRepo ? 'worktree' : 'copy';
+    }
+
+    // Priority 2: No CoW support
+    if (!cowSupported) {
+      return isGitRepo ? 'worktree' : 'copy';
+    }
+
+    // Priority 3: Uncertain or spikes - conservative (check BEFORE fast path)
+    if (hasSpike || confidence === 'medium') {
+      return isGitRepo ? 'worktree' : 'copy';
+    }
+
+    // Priority 4: Fast with high confidence
+    if (cowFast && confidence === 'high') {
+      return 'cow';
+    }
+
+    // Priority 5: Slow but confident
+    return isGitRepo ? 'worktree' : 'copy';
+  }
+
+  describe('Known slow EDR detected (CrowdStrike, etc.)', () => {
+    it('should recommend worktree regardless of timing', () => {
+      expect(getRecommendation(true, true, true, 'high', false, true)).toBe('worktree');
+      expect(getRecommendation(true, true, false, 'high', false, true)).toBe('worktree');
+      expect(getRecommendation(true, true, true, 'medium', false, true)).toBe('worktree');
+    });
+
+    it('should recommend copy when no git repo and slow EDR detected', () => {
+      expect(getRecommendation(true, true, true, 'high', false, false)).toBe('copy');
+    });
+  });
+
+  describe('No slow EDR - timing based decisions', () => {
+    it('should recommend cow when fast with high confidence', () => {
+      expect(getRecommendation(true, false, true, 'high', false, true)).toBe('cow');
+      expect(getRecommendation(true, false, true, 'high', false, false)).toBe('cow');
+    });
+
+    it('should recommend worktree when medium confidence (gray zone)', () => {
+      expect(getRecommendation(true, false, false, 'medium', false, true)).toBe('worktree');
+    });
+
+    it('should recommend worktree when spikes detected', () => {
+      expect(getRecommendation(true, false, true, 'high', true, true)).toBe('worktree');
+    });
+
+    it('should recommend worktree when slow with high confidence', () => {
+      expect(getRecommendation(true, false, false, 'high', false, true)).toBe('worktree');
+    });
+  });
+
+  describe('No CoW support', () => {
+    it('should recommend worktree when git repo exists', () => {
+      expect(getRecommendation(false, false, false, 'high', false, true)).toBe('worktree');
+    });
+
+    it('should recommend copy when no git repo', () => {
+      expect(getRecommendation(false, false, false, 'high', false, false)).toBe('copy');
+    });
+  });
+});
+
+describe('EDR impact classification', () => {
+  const KNOWN_SLOW_EDR_PRODUCTS = [
+    'CrowdStrike Falcon',
+    'SentinelOne',
+    'Cylance',
+    'Carbon Black/VMware',
+    'Microsoft Defender for Endpoint',
+    'FireEye/XAGENT',
+  ];
+
+  it('should classify known CoW-impacting EDRs correctly', () => {
+    for (const product of KNOWN_SLOW_EDR_PRODUCTS) {
+      expect(product).toBeDefined();
+      // These products should be flagged as knownSlowCoW
+      expect([
+        'CrowdStrike Falcon',
+        'SentinelOne',
+        'Cylance',
+        'Carbon Black/VMware',
+        'Microsoft Defender for Endpoint',
+        'FireEye/XAGENT',
+      ]).toContain(product);
+    }
+  });
+
+  it('should short-circuit to worktree when CrowdStrike detected', () => {
+    // CrowdStrike is the primary target - should always short-circuit
+    const result = [
+      'CrowdStrike Falcon',
+      'SentinelOne',
+      'Cylance',
+      'Carbon Black/VMware',
+      'FireEye/XAGENT',
+    ].includes('CrowdStrike Falcon');
+
+    expect(result).toBe(true);
+  });
+});