vibepulse 0.2.1 → 0.3.0-beta.0

package/.next/standalone/src/lib/claudeSessionOverrides.test.ts

@@ -0,0 +1,75 @@
+import { afterEach, describe, expect, it } from 'vitest';
+import { mkdtemp, readFile, rm } from 'fs/promises';
+import { tmpdir } from 'os';
+import { join } from 'path';
+
+async function withTempHome<T>(fn: (homeDir: string) => Promise<T>): Promise<T> {
+  const homeDir = await mkdtemp(join(tmpdir(), 'vibepulse-claude-overrides-'));
+  const originalHome = process.env.HOME;
+  process.env.HOME = homeDir;
+  try {
+    return await fn(homeDir);
+  } finally {
+    if (originalHome === undefined) delete process.env.HOME;
+    else process.env.HOME = originalHome;
+    await rm(homeDir, { recursive: true, force: true });
+  }
+}
+
+describe('claudeSessionOverrides', () => {
+  it('persists archived and deleted Claude overrides to the local registry file', async () => {
+    await withTempHome(async (homeDir) => {
+      const mod = await import('./claudeSessionOverrides');
+      await mod.markClaudeSessionArchived('session-a', 100);
+      await mod.markClaudeSessionDeleted('session-b', 200);
+
+      const entries = await mod.listClaudeSessionOverrides();
+      expect(entries).toEqual(expect.arrayContaining([
+        expect.objectContaining({ sessionId: 'session-a', archivedAt: 100 }),
+        expect.objectContaining({ sessionId: 'session-b', deletedAt: 200 }),
+      ]));
+
+      const content = await readFile(join(homeDir, '.config', 'vibepulse', 'claude-session-overrides.jsonc'), 'utf-8');
+      expect(content).toContain('session-a');
+      expect(content).toContain('session-b');
+    });
+  });
+
+  it('preserves all entries under concurrent override writes', async () => {
+    await withTempHome(async () => {
+      const mod = await import('./claudeSessionOverrides');
+
+      await Promise.all([
+        mod.markClaudeSessionArchived('session-a', 100),
+        mod.markClaudeSessionDeleted('session-b', 200),
+        mod.markClaudeSessionArchived('session-c', 300),
+      ]);
+
+      const entries = await mod.listClaudeSessionOverrides();
+      expect(entries).toEqual(expect.arrayContaining([
+        expect.objectContaining({ sessionId: 'session-a', archivedAt: 100 }),
+        expect.objectContaining({ sessionId: 'session-b', deletedAt: 200 }),
+        expect.objectContaining({ sessionId: 'session-c', archivedAt: 300 }),
+      ]));
+      expect(entries).toHaveLength(3);
+    });
+  });
+
+  it('can clear archived state while preserving deleted state when restoring a Claude session', async () => {
+    await withTempHome(async () => {
+      const mod = await import('./claudeSessionOverrides');
+      await mod.markClaudeSessionArchived('session-a', 100);
+      await mod.markClaudeSessionDeleted('session-b', 200);
+      await mod.clearClaudeSessionArchived('session-a');
+      await mod.clearClaudeSessionArchived('session-b');
+
+      const entries = await mod.listClaudeSessionOverrides();
+      expect(entries).toEqual(expect.arrayContaining([
+        expect.objectContaining({ sessionId: 'session-b', deletedAt: 200, restoredAt: expect.any(Number) }),
+      ]));
+      expect(entries).toEqual(expect.arrayContaining([
+        expect.objectContaining({ sessionId: 'session-a', restoredAt: expect.any(Number) }),
+      ]));
+    });
+  });
+});

package/.next/standalone/src/lib/claudeSessionOverrides.ts

@@ -0,0 +1,169 @@
+import { existsSync, mkdirSync } from 'fs';
+import { readFile, rename, writeFile } from 'fs/promises';
+import { homedir } from 'os';
+import { join } from 'path';
+import { parse, stringify } from 'comment-json';
+
+export const VIBEPULSE_CONFIG_DIR = join(homedir(), '.config', 'vibepulse');
+export const CLAUDE_SESSION_OVERRIDES_PATH = join(VIBEPULSE_CONFIG_DIR, 'claude-session-overrides.jsonc');
+
+export interface ClaudeSessionOverrideEntry {
+  sessionId: string;
+  archivedAt?: number;
+  deletedAt?: number;
+  restoredAt?: number;
+  updatedAt: number;
+}
+
+interface ClaudeSessionOverridesFile {
+  version: number;
+  sessions: ClaudeSessionOverrideEntry[];
+}
+
+let claudeOverrideWriteQueue: Promise<void> = Promise.resolve();
+
+function ensureConfigDir(): void {
+  if (!existsSync(VIBEPULSE_CONFIG_DIR)) {
+    mkdirSync(VIBEPULSE_CONFIG_DIR, { recursive: true });
+  }
+}
+
+function defaultOverrides(): ClaudeSessionOverridesFile {
+  return {
+    version: 1,
+    sessions: [],
+  };
+}
+
+function normalizeEntry(entry: unknown): ClaudeSessionOverrideEntry | null {
+  if (!entry || typeof entry !== 'object') return null;
+  const candidate = entry as Record<string, unknown>;
+  if (typeof candidate.sessionId !== 'string' || typeof candidate.updatedAt !== 'number') return null;
+  if (candidate.archivedAt !== undefined && typeof candidate.archivedAt !== 'number') return null;
+  if (candidate.deletedAt !== undefined && typeof candidate.deletedAt !== 'number') return null;
+  if (candidate.restoredAt !== undefined && typeof candidate.restoredAt !== 'number') return null;
+
+  return {
+    sessionId: candidate.sessionId,
+    updatedAt: candidate.updatedAt,
+    ...(typeof candidate.archivedAt === 'number' ? { archivedAt: candidate.archivedAt } : {}),
+    ...(typeof candidate.deletedAt === 'number' ? { deletedAt: candidate.deletedAt } : {}),
+    ...(typeof candidate.restoredAt === 'number' ? { restoredAt: candidate.restoredAt } : {}),
+  };
+}
+
+async function readOverridesFile(): Promise<ClaudeSessionOverridesFile> {
+  try {
+    ensureConfigDir();
+    if (!existsSync(CLAUDE_SESSION_OVERRIDES_PATH)) {
+      const initial = defaultOverrides();
+      await writeOverridesFile(initial);
+      return initial;
+    }
+
+    const raw = await readFile(CLAUDE_SESSION_OVERRIDES_PATH, 'utf-8');
+    const parsed = parse(raw, null, false) as unknown;
+    if (!parsed || typeof parsed !== 'object') {
+      return defaultOverrides();
+    }
+
+    const file = parsed as Record<string, unknown>;
+    const sessions = Array.isArray(file.sessions)
+      ? file.sessions.map(normalizeEntry).filter((entry): entry is ClaudeSessionOverrideEntry => entry !== null)
+      : [];
+
+    return {
+      version: typeof file.version === 'number' ? file.version : 1,
+      sessions,
+    };
+  } catch {
+    return defaultOverrides();
+  }
+}
+
+async function writeOverridesFile(file: ClaudeSessionOverridesFile): Promise<void> {
+  ensureConfigDir();
+  const tempPath = `${CLAUDE_SESSION_OVERRIDES_PATH}.tmp`;
+  await writeFile(tempPath, stringify(file, null, 2), 'utf-8');
+  await rename(tempPath, CLAUDE_SESSION_OVERRIDES_PATH);
+}
+
+export async function listClaudeSessionOverrides(): Promise<ClaudeSessionOverrideEntry[]> {
+  const file = await readOverridesFile();
+  return file.sessions;
+}
+
+export async function getClaudeSessionOverride(sessionId: string): Promise<ClaudeSessionOverrideEntry | null> {
+  const file = await readOverridesFile();
+  return file.sessions.find((entry) => entry.sessionId === sessionId) ?? null;
+}
+
+async function upsertClaudeSessionOverride(
+  sessionId: string,
+  mutate: (current: ClaudeSessionOverrideEntry | null, now: number) => ClaudeSessionOverrideEntry | null,
+): Promise<void> {
+  const run = async () => {
+    const file = await readOverridesFile();
+    const now = Date.now();
+    const current = file.sessions.find((entry) => entry.sessionId === sessionId) ?? null;
+    const next = mutate(current, now);
+    const withoutCurrent = file.sessions.filter((entry) => entry.sessionId !== sessionId);
+    file.sessions = next ? [...withoutCurrent, next] : withoutCurrent;
+    await writeOverridesFile(file);
+  };
+
+  const queued = claudeOverrideWriteQueue.then(run, run);
+  claudeOverrideWriteQueue = queued.then(() => undefined, () => undefined);
+  await queued;
+}
+
+export async function markClaudeSessionArchived(sessionId: string, archivedAt: number = Date.now()): Promise<void> {
+  await upsertClaudeSessionOverride(sessionId, (current, now) => ({
+    sessionId,
+    archivedAt,
+    deletedAt: current?.deletedAt,
+    restoredAt: undefined,
+    updatedAt: now,
+  }));
+}
+
+export async function markClaudeSessionDeleted(sessionId: string, deletedAt: number = Date.now()): Promise<void> {
+  await upsertClaudeSessionOverride(sessionId, (_current, now) => ({
+    sessionId,
+    deletedAt,
+    restoredAt: undefined,
+    updatedAt: now,
+  }));
+}
+
+export async function clearClaudeSessionDeleted(sessionId: string): Promise<void> {
+  await upsertClaudeSessionOverride(sessionId, (current, now) => {
+    if (!current) return null;
+    if (current.archivedAt === undefined) return null;
+    return {
+      sessionId,
+      archivedAt: current.archivedAt,
+      restoredAt: current.restoredAt,
+      updatedAt: now,
+    };
+  });
+}
+
+export async function clearClaudeSessionArchived(sessionId: string): Promise<void> {
+  await upsertClaudeSessionOverride(sessionId, (current, now) => {
+    if (!current) return null;
+    if (current.deletedAt !== undefined) {
+      return {
+        sessionId,
+        deletedAt: current.deletedAt,
+        restoredAt: now,
+        updatedAt: now,
+      };
+    }
+    return {
+      sessionId,
+      restoredAt: now,
+      updatedAt: now,
+    };
+  });
+}

package/.next/standalone/src/lib/opencodeConfig.test.ts

@@ -1,12 +1,12 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { normalizeVibePulseConfig, readConfig, writeConfig } from './opencodeConfig';
-import { writeFile, unlink, mkdir } from 'fs/promises';
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { OH_MY_OPENAGENT_CONFIG_SCHEMA, normalizeVibePulseConfig, readConfig, writeConfig } from './opencodeConfig';
+import { writeFile, unlink, mkdir, mkdtemp, rm } 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.jsonc');
+const TEST_CONFIG_PATH = join(TEST_CONFIG_DIR, 'oh-my-openagent.jsonc');
 
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null;
@@ -96,5 +96,54 @@ describe('opencodeConfig', () => {
         openEditorTargetMode: 'hub',
       });
     });
+
+    it('injects the canonical schema when writing the default config path', async () => {
+      vi.resetModules();
+      const testHomeDir = await mkdtemp(join(tmpdir(), 'vibepulse-home-'));
+      const originalHome = process.env.HOME;
+
+      process.env.HOME = testHomeDir;
+
+      try {
+        const { CONFIG_PATH: defaultConfigPath, readConfig: readDefaultConfig, writeConfig: writeDefaultConfig } = await import('./opencodeConfig');
+
+        await writeDefaultConfig({ agents: { sisyphus: { model: 'claude' } } });
+
+        const persisted = await readDefaultConfig(defaultConfigPath);
+
+        expect(persisted.$schema).toBe(OH_MY_OPENAGENT_CONFIG_SCHEMA);
+      } finally {
+        process.env.HOME = originalHome;
+        await rm(testHomeDir, { recursive: true, force: true });
+      }
+    });
+
+    it('detects and reads the legacy default config when the new file is absent', async () => {
+      vi.resetModules();
+      const testHomeDir = await mkdtemp(join(tmpdir(), 'vibepulse-home-'));
+      const originalHome = process.env.HOME;
+
+      process.env.HOME = testHomeDir;
+
+      try {
+        const {
+          LEGACY_CONFIG_PATH: legacyConfigPath,
+          detectConfig: detectDefaultConfig,
+          readConfig: readDefaultConfig,
+        } = await import('./opencodeConfig');
+
+        await mkdir(join(testHomeDir, '.config', 'opencode'), { recursive: true });
+        await writeFile(legacyConfigPath, '{"agents":{"sisyphus":{"model":"claude"}}}');
+
+        expect(detectDefaultConfig()).toBe(true);
+
+        const config = await readDefaultConfig();
+
+        expect(config.agents?.sisyphus).toEqual({ model: 'claude' });
+      } finally {
+        process.env.HOME = originalHome;
+        await rm(testHomeDir, { recursive: true, force: true });
+      }
+    });
   });
 });

package/.next/standalone/src/lib/opencodeConfig.ts

@@ -3,19 +3,15 @@ import { existsSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
 import { parse, stringify } from 'comment-json';
-import type { OpenEditorTargetMode, VibePulseConfig } from '@/types/opencodeConfig';
+import type { OhMyOpenAgentConfig, OpenEditorTargetMode, VibePulseConfig } from '@/types/opencodeConfig';
 
 export const CONFIG_DIR = join(homedir(), '.config', 'opencode');
-export const CONFIG_PATH = join(CONFIG_DIR, 'oh-my-opencode.jsonc');
-export const OPEN_CODE_CONFIG_SCHEMA = 'https://opencode.ai/config.json';
+export const CONFIG_PATH = join(CONFIG_DIR, 'oh-my-openagent.jsonc');
+export const LEGACY_CONFIG_PATH = join(CONFIG_DIR, 'oh-my-opencode.jsonc');
+export const OH_MY_OPENAGENT_CONFIG_SCHEMA = 'https://raw.githubusercontent.com/code-yeongyu/oh-my-openagent/v3.15.2/assets/oh-my-opencode.schema.json';
 export const DEFAULT_OPEN_EDITOR_TARGET_MODE: OpenEditorTargetMode = 'remote';
 
-export type OpenCodeConfig = {
-  $schema?: string;
-  agents?: Record<string, unknown>;
-  vibepulse?: VibePulseConfig;
-  [key: string]: unknown;
-};
+export type OpenCodeConfig = OhMyOpenAgentConfig;
 
 export function normalizeOpenEditorTargetMode(value: unknown): OpenEditorTargetMode {
   return value === 'hub' ? 'hub' : DEFAULT_OPEN_EDITOR_TARGET_MODE;
@@ -32,9 +28,25 @@ export function normalizeVibePulseConfig(value: unknown): VibePulseConfig {
   };
 }
 
+export function resolveConfigPath(configPath: string = CONFIG_PATH): string {
+  if (configPath !== CONFIG_PATH) {
+    return configPath;
+  }
+
+  if (existsSync(CONFIG_PATH)) {
+    return CONFIG_PATH;
+  }
+
+  if (existsSync(LEGACY_CONFIG_PATH)) {
+    return LEGACY_CONFIG_PATH;
+  }
+
+  return CONFIG_PATH;
+}
+
 export function detectConfig(configPath: string = CONFIG_PATH): boolean {
   try {
-    return existsSync(configPath);
+    return existsSync(resolveConfigPath(configPath));
   } catch {
     return false;
   }
@@ -42,7 +54,7 @@ export function detectConfig(configPath: string = CONFIG_PATH): boolean {
 
 export async function readConfig(configPath: string = CONFIG_PATH): Promise<OpenCodeConfig> {
   try {
-    const content = await readFile(configPath, 'utf-8');
+    const content = await readFile(resolveConfigPath(configPath), 'utf-8');
     const config = parse(content, null, false) as OpenCodeConfig;
     return config;
   } catch {
@@ -64,7 +76,7 @@ export async function writeConfig(
     const configWithSchema: OpenCodeConfig = shouldEnforceSchema
       ? {
           ...config,
-          $schema: config.$schema || OPEN_CODE_CONFIG_SCHEMA,
+          $schema: config.$schema || OH_MY_OPENAGENT_CONFIG_SCHEMA,
         }
       : config;
 

package/.next/standalone/src/lib/profiles/storage.test.ts

@@ -4,7 +4,7 @@ import { tmpdir } from 'os';
 import { join } from 'path';
 import { parse } from 'comment-json';
 
-const SCHEMA_URL = 'https://opencode.ai/config.json';
+const SCHEMA_URL = 'https://raw.githubusercontent.com/code-yeongyu/oh-my-openagent/v3.15.2/assets/oh-my-opencode.schema.json';
 
 describe('profile storage schema handling', () => {
   let testHomeDir: string;
@@ -105,4 +105,41 @@ describe('profile storage schema handling', () => {
       await chmod(configPath, 0o600);
     }
   });
+
+  it('creates the built-in balanced profile with upstream-aligned defaults', async () => {
+    await storage.readProfileIndex();
+
+    const balanced = await storage.readProfileConfig('balanced');
+
+    expect(balanced.agents.hephaestus).toMatchObject({
+      model: 'openai/gpt-5.4',
+      variant: 'medium',
+    });
+    expect((balanced.agents as Record<string, unknown>).hepheastus).toBeUndefined();
+    expect(balanced.agents.librarian).toMatchObject({
+      model: 'minimax-m2.7',
+    });
+    expect(balanced.agents.explore).toMatchObject({
+      model: 'grok-code-fast-1',
+    });
+    expect(balanced.agents['multimodal-looker']).toMatchObject({
+      model: 'openai/gpt-5.4',
+      variant: 'medium',
+    });
+    expect(balanced.categories?.quick).toMatchObject({
+      model: 'openai/gpt-5.4-mini',
+    });
+    expect(balanced.categories?.ultrabrain).toMatchObject({
+      model: 'openai/gpt-5.4',
+      variant: 'xhigh',
+    });
+    expect(balanced.categories?.deep).toMatchObject({
+      model: 'openai/gpt-5.4',
+      variant: 'medium',
+    });
+    expect(balanced.categories?.['unspecified-high']).toMatchObject({
+      model: 'anthropic/claude-opus-4-6',
+      variant: 'max',
+    });
+  });
 });

package/.next/standalone/src/lib/profiles/storage.ts

@@ -3,7 +3,7 @@ import { existsSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
 import { parse, stringify } from 'comment-json';
-import { OPEN_CODE_CONFIG_SCHEMA } from '../opencodeConfig';
+import { OH_MY_OPENAGENT_CONFIG_SCHEMA } from '../opencodeConfig';
 import type { AgentConfig, CategoryConfig } from '@/types/opencodeConfig';
 
 export const PROFILES_DIR = join(homedir(), '.config', 'opencode', 'profiles');
@@ -83,25 +83,25 @@ const BUILTIN_PROFILE_CONFIGS: Record<string, ProfileConfig> = {
         temperature: 0.2,
         top_p: 0.9,
       },
-      hepheastus: {
-        model: 'openai/gpt-5.3-codex',
-        variant: 'xhigh',
+      hephaestus: {
+        model: 'openai/gpt-5.4',
+        variant: 'medium',
         temperature: 0.2,
         top_p: 0.9,
       },
       librarian: {
-        model: 'anthropic/claude-sonnet-4-6',
+        model: 'minimax-m2.7',
         temperature: 0.3,
         top_p: 0.9,
       },
       explore: {
-        model: 'anthropic/claude-haiku-4-5',
+        model: 'grok-code-fast-1',
         temperature: 0.1,
         top_p: 0.9,
       },
       'multimodal-looker': {
-        model: 'google/gemini-3.1-pro',
-        variant: 'high',
+        model: 'openai/gpt-5.4',
+        variant: 'medium',
         temperature: 0.2,
         top_p: 0.9,
       },
@@ -118,11 +118,11 @@ const BUILTIN_PROFILE_CONFIGS: Record<string, ProfileConfig> = {
         variant: 'high',
       },
       ultrabrain: {
-        model: 'openai/gpt-5.3-codex',
+        model: 'openai/gpt-5.4',
         variant: 'xhigh',
       },
       deep: {
-        model: 'openai/gpt-5.3-codex',
+        model: 'openai/gpt-5.4',
         variant: 'medium',
       },
       artistry: {
@@ -130,7 +130,7 @@ const BUILTIN_PROFILE_CONFIGS: Record<string, ProfileConfig> = {
         variant: 'high',
       },
       quick: {
-        model: 'anthropic/claude-haiku-4-5',
+        model: 'openai/gpt-5.4-mini',
         temperature: 0.1,
       },
       'unspecified-low': {
@@ -138,8 +138,8 @@ const BUILTIN_PROFILE_CONFIGS: Record<string, ProfileConfig> = {
         temperature: 0.2,
       },
       'unspecified-high': {
-        model: 'openai/gpt-5.4',
-        variant: 'high',
+        model: 'anthropic/claude-opus-4-6',
+        variant: 'max',
         temperature: 0.2,
       },
       writing: {
@@ -163,7 +163,7 @@ function getProfileConfigPath(id: string): string {
 function normalizeProfileConfig(config: unknown): ProfileConfig {
   if (!config || typeof config !== 'object') {
     return {
-      $schema: OPEN_CODE_CONFIG_SCHEMA,
+      $schema: OH_MY_OPENAGENT_CONFIG_SCHEMA,
       agents: {},
     };
   }
@@ -182,7 +182,7 @@ function normalizeProfileConfig(config: unknown): ProfileConfig {
   const schema =
     typeof candidate.$schema === 'string' && candidate.$schema.trim().length > 0
       ? candidate.$schema
-      : OPEN_CODE_CONFIG_SCHEMA;
+      : OH_MY_OPENAGENT_CONFIG_SCHEMA;
 
   return {
     $schema: schema,
@@ -291,7 +291,7 @@ export async function readProfileConfig(id: string): Promise<ProfileConfig> {
     
     if (!existsSync(configPath)) {
       return {
-        $schema: OPEN_CODE_CONFIG_SCHEMA,
+        $schema: OH_MY_OPENAGENT_CONFIG_SCHEMA,
         agents: {},
       };
     }
@@ -315,7 +315,7 @@ export async function readProfileConfig(id: string): Promise<ProfileConfig> {
     return normalizedConfig;
   } catch {
     return {
-      $schema: OPEN_CODE_CONFIG_SCHEMA,
+        $schema: OH_MY_OPENAGENT_CONFIG_SCHEMA,
       agents: {},
     };
   }