vibepulse 0.1.0 → 0.1.2

package/src/lib/opencodeConfig.test.ts

@@ -0,0 +1,81 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { readConfig, writeConfig } from './opencodeConfig';
+import { writeFile, unlink, mkdir } from 'fs/promises';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+const TEST_CONFIG_DIR = join(tmpdir(), 'vibepulse-test-' + Date.now());
+const TEST_CONFIG_PATH = join(TEST_CONFIG_DIR, 'oh-my-opencode.json');
+
+async function cleanup() {
+  try {
+    if (existsSync(TEST_CONFIG_PATH)) {
+      await unlink(TEST_CONFIG_PATH);
+    }
+  } catch {}
+}
+
+describe('opencodeConfig', () => {
+  beforeEach(cleanup);
+  afterEach(cleanup);
+
+  describe('config echo bug fixes', () => {
+    it('should correctly read config immediately after saving', async () => {
+      const originalConfig = {
+        agents: {
+          sisyphus: {
+            model: 'claude-sonnet-4-20250514',
+            variant: 'high',
+            temperature: 0.2,
+            top_p: 0.9,
+          },
+        },
+        categories: {
+          coding: { model: 'gpt-4', variant: 'high' },
+        },
+      };
+
+      await writeConfig(originalConfig, TEST_CONFIG_PATH);
+      const echoed = await readConfig(TEST_CONFIG_PATH);
+
+      expect(echoed).toEqual(originalConfig);
+    });
+
+    it('should not lose other fields during partial update', async () => {
+      await writeConfig({
+        agents: {
+          sisyphus: { model: 'claude', temperature: 0.5 },
+          prometheus: { model: 'gpt-4', temperature: 0.7 },
+        },
+      }, TEST_CONFIG_PATH);
+
+      const loaded = await readConfig(TEST_CONFIG_PATH);
+      const updated = {
+        ...loaded,
+        agents: {
+          ...loaded.agents,
+          sisyphus: { ...loaded.agents?.sisyphus, temperature: 0.9 },
+        },
+      };
+
+      await writeConfig(updated, TEST_CONFIG_PATH);
+      const final = await readConfig(TEST_CONFIG_PATH);
+
+      expect(final.agents?.prometheus).toEqual({ model: 'gpt-4', temperature: 0.7 });
+    });
+
+    it('should return empty object when file does not exist', async () => {
+      const config = await readConfig(TEST_CONFIG_PATH);
+      expect(config).toEqual({});
+    });
+
+    it('should return empty object for invalid JSON', async () => {
+      await mkdir(TEST_CONFIG_DIR, { recursive: true });
+      await writeFile(TEST_CONFIG_PATH, 'invalid {{{ json');
+
+      const config = await readConfig(TEST_CONFIG_PATH);
+      expect(config).toEqual({});
+    });
+  });
+});

package/src/lib/opencodeConfig.ts

@@ -0,0 +1,48 @@
+import { readFile, writeFile } from 'fs/promises';
+import { existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { parse, stringify } from 'comment-json';
+
+export const CONFIG_DIR = join(homedir(), '.config', 'opencode');
+export const CONFIG_PATH = join(CONFIG_DIR, 'oh-my-opencode.json');
+
+export type OpenCodeConfig = {
+  agents?: Record<string, unknown>;
+  [key: string]: unknown;
+};
+
+export function detectConfig(configPath: string = CONFIG_PATH): boolean {
+  try {
+    return existsSync(configPath);
+  } catch {
+    return false;
+  }
+}
+
+export async function readConfig(configPath: string = CONFIG_PATH): Promise<OpenCodeConfig> {
+  try {
+    const content = await readFile(configPath, 'utf-8');
+    const config = parse(content, null, false) as OpenCodeConfig;
+    return config;
+  } catch {
+    return {};
+  }
+}
+
+export async function writeConfig(
+  config: OpenCodeConfig, 
+  configPath: string = CONFIG_PATH
+): Promise<void> {
+  try {
+    const configDir = join(configPath, '..');
+    if (!existsSync(configDir)) {
+      mkdirSync(configDir, { recursive: true });
+    }
+
+    const content = stringify(config, null, 2);
+    await writeFile(configPath, content, 'utf-8');
+  } catch (error) {
+    throw new Error(`Failed to write config: ${error}`);
+  }
+}

package/src/lib/opencodeDiscovery.ts

@@ -0,0 +1,154 @@
+import { execSync } from 'child_process';
+
+const knownPorts = new Set<number>();
+
+export type OpencodeProcessCwd = {
+  pid: number;
+  cwd: string;
+};
+
+function toUniqueSortedPorts(ports: number[]): number[] {
+  return Array.from(
+    new Set(ports.filter((port) => Number.isInteger(port) && port > 0 && port <= 65535))
+  ).sort((a, b) => a - b);
+}
+
+function getPortsFromLsof(): number[] {
+  try {
+    const output = execSync('lsof -nP -iTCP -sTCP:LISTEN', {
+      encoding: 'utf-8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    const lines = output.split('\n');
+    const ports: number[] = [];
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith('COMMAND')) {
+        continue;
+      }
+
+      const parts = trimmed.split(/\s+/);
+      const command = parts[0]?.toLowerCase();
+      if (command !== 'opencode') {
+        continue;
+      }
+
+      const match = trimmed.match(/:(\d+)\s+\(LISTEN\)/);
+      if (!match) {
+        continue;
+      }
+
+      const port = parseInt(match[1], 10);
+      if (Number.isFinite(port)) {
+        ports.push(port);
+      }
+    }
+
+    return ports;
+  } catch {
+    return [];
+  }
+}
+
+function getPortsFromProcessArgs(): number[] {
+  try {
+    const output = execSync('ps -axo command', {
+      encoding: 'utf-8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    const matches = [...output.matchAll(/\bopencode\b[^\n]*\b--port(?:=|\s+)(\d+)\b/g)];
+    return matches
+      .map((match) => parseInt(match[1], 10))
+      .filter((port) => Number.isFinite(port));
+  } catch {
+    return [];
+  }
+}
+
+export function discoverOpencodePorts(): number[] {
+  const discoveredPorts = toUniqueSortedPorts([
+    ...getPortsFromLsof(),
+    ...getPortsFromProcessArgs(),
+  ]);
+
+  for (const port of discoveredPorts) {
+    knownPorts.add(port);
+  }
+
+  return toUniqueSortedPorts([
+    ...discoveredPorts,
+    ...Array.from(knownPorts),
+  ]);
+}
+
+function getOpencodePidsWithoutPortFlag(): number[] {
+  try {
+    const output = execSync('ps -axo pid=,command=', {
+      encoding: 'utf-8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+
+    const pids: number[] = [];
+    const lines = output.split('\n');
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+
+      const match = trimmed.match(/^(\d+)\s+(.+)$/);
+      if (!match) continue;
+
+      const pid = parseInt(match[1], 10);
+      const command = match[2];
+
+      if (!Number.isFinite(pid)) continue;
+      if (!/\bopencode\b/.test(command)) continue;
+      if (/\b--port(?:=|\s+)\d+\b/.test(command)) continue;
+
+      pids.push(pid);
+    }
+
+    return Array.from(new Set(pids));
+  } catch {
+    return [];
+  }
+}
+
+function getCwdForPid(pid: number): string | null {
+  try {
+    const output = execSync(`lsof -nP -a -p ${pid} -d cwd -Fn`, {
+      encoding: 'utf-8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+
+    const cwdLine = output
+      .split('\n')
+      .find((line) => line.startsWith('n') && line.length > 1);
+
+    if (!cwdLine) return null;
+    return cwdLine.slice(1);
+  } catch {
+    return null;
+  }
+}
+
+export function discoverOpencodeProcessCwdsWithoutPort(): OpencodeProcessCwd[] {
+  const pids = getOpencodePidsWithoutPortFlag();
+  if (!pids.length) return [];
+
+  const processes: OpencodeProcessCwd[] = [];
+  const seen = new Set<string>();
+
+  for (const pid of pids) {
+    const cwd = getCwdForPid(pid);
+    if (!cwd) continue;
+
+    const key = `${pid}:${cwd}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    processes.push({ pid, cwd });
+  }
+
+  return processes;
+}

package/src/lib/profiles/storage.ts

@@ -0,0 +1,264 @@
+import { readFile, writeFile, unlink } from 'fs/promises';
+import { existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { parse, stringify } from 'comment-json';
+import type { AgentConfig, CategoryConfig } from '@/types/opencodeConfig';
+
+export const PROFILES_DIR = join(homedir(), '.config', 'opencode', 'profiles');
+export const PROFILE_INDEX_PATH = join(PROFILES_DIR, 'index.json');
+
+export interface Profile {
+  id: string;
+  name: string;
+  emoji: string;
+  description?: string;
+  createdAt: string;
+  updatedAt: string;
+  isDefault?: boolean;
+  isBuiltIn?: boolean;
+}
+
+export interface ProfileIndex {
+  version: number;
+  profiles: Profile[];
+  activeProfileId: string | null;
+  lastModified: string;
+}
+
+export interface ProfileConfig {
+  agents: Record<string, AgentConfig>;
+  categories?: Record<string, CategoryConfig>;
+}
+
+const BUILTIN_PROFILES: Profile[] = [
+  {
+    id: 'balanced',
+    name: 'Balanced',
+    emoji: '⚖️',
+    description: 'Balanced multi-model orchestration optimized for general coding tasks',
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    isBuiltIn: true,
+  },
+];
+
+const BUILTIN_PROFILE_CONFIGS: Record<string, ProfileConfig> = {
+  balanced: {
+    agents: {
+      sisyphus: {
+        model: 'kimi-for-coding/k2p5',
+        variant: 'high',
+        temperature: 0.2,
+        top_p: 0.9,
+      },
+      oracle: {
+        model: 'openai/gpt-5.4',
+        variant: 'high',
+        temperature: 0.2,
+        top_p: 0.9,
+      },
+      librarian: {
+        model: 'google/gemini-3-flash',
+        temperature: 0.3,
+        top_p: 0.9,
+      },
+      explore: {
+        model: 'github-copilot/grok-code-fast-1',
+        temperature: 0.1,
+        top_p: 0.9,
+      },
+      'multimodal-looker': {
+        model: 'kimi-for-coding/k2p5',
+        temperature: 0.2,
+        top_p: 0.9,
+      },
+    },
+    categories: {
+      'visual-engineering': {
+        model: 'google/gemini-3.1-pro',
+        variant: 'high',
+      },
+      deep: {
+        model: 'openai/gpt-5.3-codex',
+        variant: 'medium',
+      },
+      quick: {
+        model: 'anthropic/claude-haiku-4-5',
+        temperature: 0.1,
+      },
+      'unspecified-low': {
+        model: 'anthropic/claude-sonnet-4-6',
+        temperature: 0.2,
+      },
+      'unspecified-high': {
+        model: 'openai/gpt-5.4',
+        variant: 'high',
+        temperature: 0.2,
+      },
+      writing: {
+        model: 'kimi-for-coding/k2p5',
+        temperature: 0.3,
+      },
+    },
+  },
+};
+
+export function ensureProfilesDir(): void {
+  if (!existsSync(PROFILES_DIR)) {
+    mkdirSync(PROFILES_DIR, { recursive: true });
+  }
+}
+
+function getProfileConfigPath(id: string): string {
+  return join(PROFILES_DIR, `${id}.json`);
+}
+
+function createDefaultProfileIndex(): ProfileIndex {
+  return {
+    version: 1,
+    profiles: [...BUILTIN_PROFILES],
+    activeProfileId: null,
+    lastModified: new Date().toISOString(),
+  };
+}
+
+async function createBuiltinProfileConfigs(): Promise<void> {
+  const validBuiltinIds = new Set(BUILTIN_PROFILES.map(p => p.id));
+  const deprecatedBuiltinIds = ['coding', 'writing', 'debug', 'minimal'];
+
+  for (const deprecatedId of deprecatedBuiltinIds) {
+    if (!validBuiltinIds.has(deprecatedId)) {
+      const deprecatedConfigPath = getProfileConfigPath(deprecatedId);
+      if (existsSync(deprecatedConfigPath)) {
+        await unlink(deprecatedConfigPath);
+      }
+    }
+  }
+
+  for (const profile of BUILTIN_PROFILES) {
+    const configPath = getProfileConfigPath(profile.id);
+    const config = BUILTIN_PROFILE_CONFIGS[profile.id] || { agents: {} };
+    const content = stringify(config, null, 2);
+    await writeFile(configPath, content, 'utf-8');
+  }
+}
+
+export async function readProfileIndex(): Promise<ProfileIndex> {
+  try {
+    ensureProfilesDir();
+
+    if (!existsSync(PROFILE_INDEX_PATH)) {
+      const defaultIndex = createDefaultProfileIndex();
+      await writeProfileIndex(defaultIndex);
+      await createBuiltinProfileConfigs();
+      return defaultIndex;
+    }
+
+    const content = await readFile(PROFILE_INDEX_PATH, 'utf-8');
+    const index = parse(content, null, false) as unknown as ProfileIndex;
+    
+    // Ensure all built-in profiles exist in the index
+    let modified = false;
+    for (const builtinProfile of BUILTIN_PROFILES) {
+      const exists = index.profiles.some(p => p.id === builtinProfile.id);
+      if (!exists) {
+        index.profiles.push(builtinProfile);
+        modified = true;
+      }
+    }
+    
+    // Remove built-in profiles that are no longer in BUILTIN_PROFILES
+    const builtinIds = new Set(BUILTIN_PROFILES.map(p => p.id));
+    const oldLength = index.profiles.length;
+    index.profiles = index.profiles.filter(p => !p.isBuiltIn || builtinIds.has(p.id));
+    if (index.profiles.length !== oldLength) {
+      modified = true;
+    }
+    
+    await createBuiltinProfileConfigs();
+    
+    if (modified) {
+      index.lastModified = new Date().toISOString();
+      await writeProfileIndex(index);
+    }
+    
+    return index;
+  } catch {
+    return createDefaultProfileIndex();
+  }
+}
+
+export async function writeProfileIndex(index: ProfileIndex): Promise<void> {
+  ensureProfilesDir();
+  
+  index.lastModified = new Date().toISOString();
+  const content = stringify(index, null, 2);
+  
+  await writeFile(PROFILE_INDEX_PATH, content, 'utf-8');
+}
+
+
+export async function readProfileConfig(id: string): Promise<ProfileConfig> {
+  try {
+    const configPath = getProfileConfigPath(id);
+    
+    if (!existsSync(configPath)) {
+      return { agents: {} };
+    }
+    
+    const content = await readFile(configPath, 'utf-8');
+    const config = parse(content, null, false) as unknown as ProfileConfig;
+    return config;
+  } catch {
+    return { agents: {} };
+  }
+}
+
+export async function writeProfileConfig(
+  id: string, 
+  config: ProfileConfig
+): Promise<void> {
+  ensureProfilesDir();
+  
+  const configPath = getProfileConfigPath(id);
+  const content = stringify(config, null, 2);
+  
+  await writeFile(configPath, content, 'utf-8');
+}
+
+export async function deleteProfileConfig(id: string): Promise<boolean> {
+  const index = await readProfileIndex();
+  const profile = index.profiles.find(p => p.id === id);
+  
+  if (profile?.isBuiltIn) {
+    const defaultConfig = BUILTIN_PROFILE_CONFIGS[id] || { agents: {} };
+    await writeProfileConfig(id, defaultConfig);
+    return true;
+  }
+  
+  const configPath = getProfileConfigPath(id);
+  
+  if (!existsSync(configPath)) {
+    return false;
+  }
+  
+  await unlink(configPath);
+  return true;
+}
+
+export async function getProfileById(id: string): Promise<Profile | undefined> {
+  const index = await readProfileIndex();
+  return index.profiles.find(p => p.id === id);
+}
+
+export async function getActiveProfileId(): Promise<string | null> {
+  const index = await readProfileIndex();
+  return index.activeProfileId;
+}
+
+export async function setActiveProfileId(id: string | null): Promise<void> {
+  const index = await readProfileIndex();
+  index.activeProfileId = id;
+  await writeProfileIndex(index);
+}

package/src/lib/transform.ts

@@ -0,0 +1,84 @@
+import { KanbanCard, OpencodeSession, KanbanColumn } from '@/types';
+
+interface EnrichedSession extends OpencodeSession {
+  realTimeStatus?: 'idle' | 'busy' | 'retry';
+  projectName?: string;
+  branch?: string;
+  waitingForUser?: boolean;
+}
+
+export function transformSession(session: EnrichedSession): KanbanCard {
+    let status: KanbanColumn;
+    
+    const realTimeStatus = session.realTimeStatus || 'idle';
+    const hasActiveChildren = (session.children || []).some((child) => {
+        const childStatus = child.realTimeStatus || 'idle';
+        return childStatus === 'busy' || childStatus === 'retry';
+    });
+    const effectiveStatus =
+        realTimeStatus === 'retry'
+            ? 'retry'
+            : (realTimeStatus === 'busy' || hasActiveChildren)
+                ? 'busy'
+                : 'idle';
+    const hasWaitingChildren = (session.children || []).some((child) => {
+        const childStatus = child.realTimeStatus || 'idle';
+        return childStatus === 'retry' || (childStatus !== 'idle' && !!child.waitingForUser);
+    });
+    const waitingForUser =
+        effectiveStatus === 'retry' ||
+        (effectiveStatus === 'busy' && (!!session.waitingForUser || hasWaitingChildren));
+    
+    if (session.time?.archived) {
+        status = 'done';
+    } else if (waitingForUser) {
+        status = 'review';  // Needs Attention
+    } else if (effectiveStatus === 'busy') {
+        status = 'busy';
+    } else {
+        status = 'idle';
+    }
+    
+    return {
+        id: session.id,
+        sessionSlug: session.slug,
+        title: session.title || 'Untitled Session',
+        directory: session.directory,
+        projectName: session.projectName || 'Unknown Project',
+        branch: session.branch,
+        agents: extractAgents(session.slug),
+        messageCount: session.messageCount || 0,
+        status: status,
+        opencodeStatus: effectiveStatus,
+        waitingForUser,
+        todosTotal: 0,
+        todosCompleted: 0,
+        createdAt: session.time.created,
+        updatedAt: session.time.updated,
+        archivedAt: session.time.archived,
+        sortOrder: 0,
+        children: (session.children || []).map(c => ({
+            id: c.id,
+            title: c.title,
+            realTimeStatus: c.realTimeStatus || 'idle',
+            waitingForUser:
+                (c.realTimeStatus || 'idle') === 'retry' ||
+                ((c.realTimeStatus || 'idle') === 'busy' && !!c.waitingForUser),
+        })),
+    };
+}
+
+function extractAgents(slug: string): string[] {
+    // Extract agent names from session slug
+    // Slug format: session_<timestamp>_<agent1>-<agent2>...
+    const parts = slug.split('_');
+    if (parts.length >= 3) {
+        const agentsPart = parts[parts.length - 1];
+        return agentsPart.split('-').filter(Boolean);
+    }
+    return [];
+}
+
+export function transformSessions(sessions: EnrichedSession[]): KanbanCard[] {
+    return sessions.map(transformSession);
+}

package/src/test/setup.ts

@@ -0,0 +1,8 @@
+import '@testing-library/jest-dom';
+import { cleanup } from '@testing-library/react';
+import { afterEach } from 'vitest';
+
+// Cleanup after each test
+afterEach(() => {
+  cleanup();
+});