@opensassi/opencode 0.1.2 → 0.1.4

package/dashboard/src/services/git.ts

@@ -0,0 +1,139 @@
+import { execFileSync } from 'node:child_process';
+import type { GitLogEntry, GitStats } from '../types.js';
+
+export class GitService {
+  private repoDir: string;
+  private defaultSince: string | null;
+
+  constructor(repoDir: string, defaultSince?: string | null) {
+    this.repoDir = repoDir;
+    this.defaultSince = defaultSince ?? null;
+  }
+
+  detectForkPoint(): string | null {
+    const makeOpts = (mb: number) => ({
+      cwd: this.repoDir, encoding: 'utf-8' as const, maxBuffer: mb,
+      stdio: ['pipe', 'pipe', 'ignore'] as ['pipe', 'pipe', 'ignore'],
+    });
+    try {
+      const base = execFileSync('git', ['merge-base', 'HEAD', 'upstream/main'], makeOpts(1024 * 1024)).trim();
+      if (base) return base;
+    } catch {}
+    try {
+      const allFork = execFileSync('git', ['rev-list', '--reverse', '--author=opensassi', 'HEAD'], makeOpts(10 * 1024 * 1024)).trim().split('\n').filter(Boolean);
+      if (allFork.length > 0) {
+        const parent = execFileSync('git', ['rev-parse', allFork[0] + '^'], makeOpts(1024 * 1024)).trim();
+        if (parent) return parent;
+      }
+    } catch {}
+    try {
+      const allFork = execFileSync('git', ['rev-list', '--reverse', '--author=Ersun', 'HEAD'], makeOpts(10 * 1024 * 1024)).trim().split('\n').filter(Boolean);
+      if (allFork.length > 0) {
+        const parent = execFileSync('git', ['rev-parse', allFork[0] + '^'], makeOpts(1024 * 1024)).trim();
+        if (parent) return parent;
+      }
+    } catch {}
+    return null;
+  }
+
+  getRange(rangeBase: string | null): string | undefined {
+    if (!rangeBase) return undefined;
+    return rangeBase + '..HEAD';
+  }
+
+  getLog(since?: string, until?: string, forkRange?: string | null): GitLogEntry[] {
+    const args = ['log', '--oneline', '--stat', '--no-merges', '--format=COMMIT%x1e%H%x1f%an%x1f%ai%x1f%s'];
+    if (forkRange) {
+      args.push(forkRange);
+    } else {
+      const s = since ?? this.defaultSince;
+      if (s) args.push('--after', s);
+      if (until) args.push('--before', until);
+    }
+    try {
+      const output = execFileSync('git', args, { cwd: this.repoDir, encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024, stdio: ['pipe', 'pipe', 'ignore'] as ['pipe', 'pipe', 'ignore'] });
+      return this.parseLogOutput(output);
+    } catch {
+      return [];
+    }
+  }
+
+  private parseLogOutput(output: string): GitLogEntry[] {
+    const entries: GitLogEntry[] = [];
+    const blocks = output.split('\x1e').filter(b => b.trim());
+    for (let bi = 0; bi < blocks.length; bi++) {
+      const block = blocks[bi];
+      const lines = block.trim().split('\n');
+      if (lines.length === 0) continue;
+      const header = lines[0];
+      const parts = header.split('\x1f');
+      // First block is just "COMMIT" (before first \x1e), skip it
+      if (bi === 0 && parts.length === 1 && parts[0] === 'COMMIT') continue;
+      // Subsequent blocks: hash\x1fauthor\x1fdate\x1fsubject
+      if (parts.length < 3) continue;
+      const commit = parts[0];
+      const author = parts[1];
+      const date = parts[2];
+      const message = parts.slice(3).join('\x1f');
+      let filesChanged = 0;
+      let insertions = 0;
+      let deletions = 0;
+      for (let i = 1; i < lines.length; i++) {
+        const statMatch = lines[i].match(/(\d+) file[s]? changed/);
+        if (statMatch) filesChanged = parseInt(statMatch[1], 10);
+        const insMatch = lines[i].match(/(\d+) insertion[s]?/);
+        if (insMatch) insertions = parseInt(insMatch[1], 10);
+        const delMatch = lines[i].match(/(\d+) deletion[s]?/);
+        if (delMatch) deletions = parseInt(delMatch[1], 10);
+      }
+      entries.push({
+        commit: commit ?? '',
+        author: author ?? '',
+        date: date ?? '',
+        message: message ?? '',
+        files_changed: filesChanged,
+        insertions,
+        deletions,
+      });
+    }
+    return entries;
+  }
+
+  getStats(forkRange?: string | null): GitStats {
+    const allLog = this.getLog(undefined, undefined, forkRange);
+    const perDate: Record<string, { commits: number; insertions: number; deletions: number }> = {};
+    let totalFilesChanged = 0;
+    let totalInsertions = 0;
+    let totalDeletions = 0;
+    for (const entry of allLog) {
+      const day = entry.date.slice(0, 10);
+      if (!perDate[day]) perDate[day] = { commits: 0, insertions: 0, deletions: 0 };
+      perDate[day].commits++;
+      perDate[day].insertions += entry.insertions;
+      perDate[day].deletions += entry.deletions;
+      totalFilesChanged += entry.files_changed;
+      totalInsertions += entry.insertions;
+      totalDeletions += entry.deletions;
+    }
+    return {
+      total_commits: allLog.length,
+      total_files_changed: totalFilesChanged,
+      total_insertions: totalInsertions,
+      total_deletions: totalDeletions,
+      per_date: perDate,
+    };
+  }
+
+  getCommitDiff(hash: string): string {
+    try {
+      return execFileSync('git', ['show', hash, '--no-color'], {
+        cwd: this.repoDir,
+        encoding: 'utf-8',
+        maxBuffer: 10 * 1024 * 1024,
+        stdio: ['pipe', 'pipe', 'ignore'] as ['pipe', 'pipe', 'ignore'],
+      });
+    } catch {
+      return '';
+    }
+  }
+}

package/dashboard/src/services/sessions.ts

@@ -0,0 +1,216 @@
+import { readFileSync, readdirSync, existsSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { TTLCache } from './cache.js';
+import type {
+  NormalizedDay, FormatA, FormatB,
+  SessionDetail, SessionEntry, SearchResult,
+} from '../types.js';
+
+function normalizeDay(raw: unknown, date: string): NormalizedDay {
+  const a = raw as FormatA;
+  if (a && typeof a === 'object' && 'dashboard' in a && a.dashboard) {
+    const ds = a.dashboard.daily_summary;
+    return {
+      date: ds.date,
+      metadata: a.dashboard.metadata,
+      total_prompter_time_hours: ds.total_prompter_time_hours,
+      total_sme_time_hours: ds.total_sme_time_hours,
+      ai_multiplier: ds.ai_multiplier,
+      total_sessions: ds.total_sessions,
+      top_subject_areas: ds.top_subject_areas,
+      session_breakdown: a.dashboard.session_breakdown,
+    };
+  }
+  const b = raw as FormatB;
+  if (b && typeof b === 'object' && 'date' in b && b.date) {
+    return {
+      date: b.date,
+      total_prompter_time_hours: b.total_prompter_time_hours,
+      total_sme_time_hours: b.total_sme_time_hours,
+      ai_multiplier: b.ai_multiplier,
+      total_sessions: b.total_sessions,
+      top_subject_areas: b.top_subject_areas,
+      session_breakdown: b.session_breakdown,
+    };
+  }
+  return {
+    date,
+    total_prompter_time_hours: 0,
+    total_sme_time_hours: 0,
+    ai_multiplier: 0,
+    total_sessions: 0,
+    top_subject_areas: [],
+    session_breakdown: [],
+  };
+}
+
+export interface SessionsConfig {
+  sessionsDir: string;
+}
+
+export class SessionsService {
+  private dailyCache = new TTLCache<NormalizedDay>(60_000);
+  private detailCache = new TTLCache<SessionDetail>(300_000);
+  private daysListCache = new TTLCache<string[]>(30_000);
+  private sessionsDir: string;
+
+  constructor(sessionsDir: string) {
+    this.sessionsDir = resolve(sessionsDir);
+  }
+
+  get dailyDir(): string {
+    return join(this.sessionsDir, 'daily');
+  }
+
+  listDays(): string[] {
+    const cached = this.daysListCache.get('list');
+    if (cached) return cached;
+    const dir = this.dailyDir;
+    if (!existsSync(dir)) return [];
+    const files = readdirSync(dir).filter(f => f.endsWith('.json')).map(f => f.replace(/\.json$/, '')).sort();
+    this.daysListCache.set('list', files);
+    return files;
+  }
+
+  listSessionsDirFiles(): string[] {
+    if (!existsSync(this.sessionsDir)) return [];
+    return readdirSync(this.sessionsDir).filter(f => f.endsWith('.json.bz2'));
+  }
+
+  getDay(date: string): NormalizedDay {
+    const cached = this.dailyCache.get(date);
+    if (cached) return cached;
+    const path = join(this.dailyDir, `${date}.json`);
+    if (!existsSync(path)) {
+      const day: NormalizedDay = {
+        date,
+        total_prompter_time_hours: 0,
+        total_sme_time_hours: 0,
+        ai_multiplier: 0,
+        total_sessions: 0,
+        top_subject_areas: [],
+        session_breakdown: [],
+      };
+      this.dailyCache.set(date, day);
+      return day;
+    }
+    const raw = JSON.parse(readFileSync(path, 'utf-8'));
+    const day = normalizeDay(raw, date);
+    this.dailyCache.set(date, day);
+    return day;
+  }
+
+  getAllSessionsFlat(): Array<{ date: string; entry: SessionEntry }> {
+    const days = this.listDays();
+    const result: Array<{ date: string; entry: SessionEntry }> = [];
+    for (const day of days) {
+      const normalized = this.getDay(day);
+      for (const entry of normalized.session_breakdown) {
+        result.push({ date: day, entry });
+      }
+    }
+    return result;
+  }
+
+  getSessionDetail(sessionId: string): SessionDetail | null {
+    const cached = this.detailCache.get(sessionId);
+    if (cached) return cached;
+    const bz2File = this.resolveBz2File(sessionId);
+    if (!bz2File) return null;
+    try {
+      const json = execFileSync('bzcat', [bz2File], { encoding: 'utf-8', maxBuffer: 100 * 1024 * 1024 });
+      const detail = JSON.parse(json) as SessionDetail;
+      this.detailCache.set(sessionId, detail);
+      return detail;
+    } catch {
+      return null;
+    }
+  }
+
+  getSessionSummary(sessionId: string): string | null {
+    const mdFile = this.resolveMdFile(sessionId);
+    if (!mdFile) return null;
+    return readFileSync(mdFile, 'utf-8');
+  }
+
+  private resolveBz2File(sessionId: string): string | null {
+    const exact = join(this.sessionsDir, `${sessionId}.json.bz2`);
+    if (existsSync(exact)) return exact;
+    const files = this.listSessionsDirFiles();
+    const match = files.find(f => f.startsWith(sessionId) && f.endsWith('.json.bz2'));
+    if (match) return join(this.sessionsDir, match);
+    return null;
+  }
+
+  private resolveMdFile(sessionId: string): string | null {
+    const exact = join(this.sessionsDir, `${sessionId}.md`);
+    if (existsSync(exact)) return exact;
+    if (!existsSync(this.sessionsDir)) return null;
+    const files = readdirSync(this.sessionsDir).filter(f => f.endsWith('.md'));
+    const match = files.find(f => f.startsWith(sessionId));
+    if (match) return join(this.sessionsDir, match);
+    return null;
+  }
+
+  search(query: string): SearchResult[] {
+    const q = query.toLowerCase();
+    const results: SearchResult[] = [];
+    const days = this.listDays();
+    for (const day of days) {
+      const normalized = this.getDay(day);
+      for (const entry of normalized.session_breakdown) {
+        if (entry.top_component_summary.toLowerCase().includes(q)) {
+          results.push({
+            session_id: entry.session_id,
+            date: day,
+            summary: entry.top_component_summary,
+            tags: entry.tags,
+            match_type: 'summary',
+            match_snippet: entry.top_component_summary,
+          });
+          continue;
+        }
+        const matchedTag = entry.tags.find(t => t.toLowerCase().includes(q));
+        if (matchedTag) {
+          results.push({
+            session_id: entry.session_id,
+            date: day,
+            summary: entry.top_component_summary,
+            tags: entry.tags,
+            match_type: 'tag',
+            match_snippet: matchedTag,
+          });
+          continue;
+        }
+        const detail = this.getSessionDetail(entry.session_id);
+        if (detail) {
+          for (const msg of detail.messages) {
+            for (const part of msg.parts) {
+              if (part.text && part.text.toLowerCase().includes(q)) {
+                const snippet = part.text.slice(Math.max(0, part.text.toLowerCase().indexOf(q) - 40), part.text.toLowerCase().indexOf(q) + 80);
+                results.push({
+                  session_id: entry.session_id,
+                  date: day,
+                  summary: entry.top_component_summary,
+                  tags: entry.tags,
+                  match_type: 'transcript',
+                  match_snippet: snippet,
+                });
+                break;
+              }
+            }
+            if (results.length > 0 && results[results.length - 1].session_id === entry.session_id && results[results.length - 1].match_type === 'transcript') break;
+          }
+        }
+      }
+    }
+    return results;
+  }
+
+  refresh(): void {
+    this.dailyCache.invalidateAll();
+    this.daysListCache.invalidateAll();
+    this.detailCache.invalidateAll();
+  }
+}

package/dashboard/src/services/specs.ts

@@ -0,0 +1,95 @@
+import { readFileSync, readdirSync, existsSync, statSync } from 'node:fs';
+import { join, resolve, relative } from 'node:path';
+import type { SpecNode } from '../types.js';
+
+const SKIP_DIRS = new Set(['node_modules', 'thirdparty', 'external', '.git', 'build', 'build_debug', 'build_ml', 'build_ml_release', 'build_baseline', 'build_clean', 'build_clean_p3', 'build_clean_test', 'build_debug', 'build_final_clean', 'build_hw', 'build_hw_dbg', 'build_off', 'build_phase2', 'build_pipeline_baseline', 'build_release', 'build_sched', 'build_sched_full', 'build_sched_trace', 'lib', 'bin', 'install', 'pkgconfig', '.artifacts', '.github', '.playwright-mcp', '.profiler', 'ml-data', 'ml-models', 'ml-models-v2', 'logs', 'sessions', 'coverage', 'deps', 'cfg', 'docs', 'microbench', 'perf', 'test', 'thirdparty']);
+
+export class TechSpecService {
+  private rootDir: string;
+
+  constructor(rootDir: string) {
+    this.rootDir = resolve(rootDir);
+  }
+
+  getTree(): SpecNode {
+    return {
+      name: 'Technical Specifications',
+      path: '',
+      isDir: true,
+      children: this.scanDir(this.rootDir, 6),
+    };
+  }
+
+  readSpec(specPath: string): string | null {
+    const fullPath = join(this.rootDir, specPath);
+    if (!existsSync(fullPath)) return null;
+    return readFileSync(fullPath, 'utf-8');
+  }
+
+  private scanDir(dir: string, maxDepth: number): SpecNode[] {
+    if (maxDepth <= 0) return [];
+    const entries: SpecNode[] = [];
+    try {
+      const items = readdirSync(dir);
+      const dirs: string[] = [];
+      const specFiles: SpecNode[] = [];
+
+      for (const item of items) {
+        if (SKIP_DIRS.has(item)) continue;
+        const fullPath = join(dir, item);
+        let stat;
+        try { stat = statSync(fullPath); } catch { continue; }
+
+        if (stat.isDirectory()) {
+          if (this.hasSpecs(fullPath)) {
+            dirs.push(fullPath);
+          }
+        } else if (item.endsWith('.spec.md') || item === 'technical-specification.md') {
+          specFiles.push({
+            name: item,
+            path: relative(this.rootDir, fullPath),
+            isDir: false,
+          });
+        }
+      }
+
+      for (const d of dirs.sort()) {
+        const relPath = relative(this.rootDir, d);
+        entries.push({
+          name: relPath,
+          path: relPath,
+          isDir: true,
+          children: this.scanDir(d, maxDepth - 1),
+        });
+      }
+
+      entries.push(...specFiles);
+      entries.sort((a, b) => {
+        // Root spec first, then aggregate specs, then dirs, then other files
+        if (a.name === 'technical-specification.md') return -1;
+        if (b.name === 'technical-specification.md') return 1;
+        if (a.isDir && !b.isDir) return 1;
+        if (!a.isDir && b.isDir) return -1;
+        return a.name.localeCompare(b.name);
+      });
+    } catch {}
+    return entries;
+  }
+
+  private hasSpecs(dir: string): boolean {
+    try {
+      const items = readdirSync(dir);
+      for (const item of items) {
+        if (SKIP_DIRS.has(item)) continue;
+        if (item.endsWith('.spec.md') || item === 'technical-specification.md') return true;
+        const fullPath = join(dir, item);
+        try {
+          if (statSync(fullPath).isDirectory() && !SKIP_DIRS.has(item)) {
+            if (this.hasSpecs(fullPath)) return true;
+          }
+        } catch {}
+      }
+    } catch {}
+    return false;
+  }
+}

package/dashboard/src/types.ts

@@ -0,0 +1,168 @@
+export interface SubjectArea {
+  name: string;
+  prompter_time_hours: number;
+  sme_time_hours: number;
+  ai_multiplier: number;
+}
+
+export interface SessionEntry {
+  session_id: string;
+  duration_minutes: number;
+  prompter_time_minutes: number;
+  sme_time_minutes: number;
+  top_component_summary: string;
+  tags: string[];
+  human_confidence: 'high' | 'medium' | 'low';
+}
+
+export interface DailyMetadata {
+  generated_at: string;
+  audited: boolean;
+  audit_note: string;
+}
+
+export interface NormalizedDay {
+  date: string;
+  metadata?: DailyMetadata;
+  total_prompter_time_hours: number;
+  total_sme_time_hours: number;
+  ai_multiplier: number;
+  total_sessions: number;
+  top_subject_areas: SubjectArea[];
+  session_breakdown: SessionEntry[];
+}
+
+export interface FormatA {
+  dashboard: {
+    metadata: DailyMetadata;
+    daily_summary: {
+      date: string;
+      total_prompter_time_hours: number;
+      total_sme_time_hours: number;
+      ai_multiplier: number;
+      total_sessions: number;
+      top_subject_areas: SubjectArea[];
+    };
+    session_breakdown: SessionEntry[];
+  };
+}
+
+export interface FormatB {
+  date: string;
+  total_prompter_time_hours: number;
+  total_sme_time_hours: number;
+  ai_multiplier: number;
+  total_sessions: number;
+  top_subject_areas: SubjectArea[];
+  session_breakdown: SessionEntry[];
+}
+
+export interface SessionInfo {
+  id: string;
+  slug: string;
+  title: string;
+  agent: string;
+  model: { id: string; providerID: string };
+  summary: { additions: number; deletions: number; files: number };
+  time: { created: number; updated: number };
+}
+
+export interface MessageInfo {
+  role: string;
+  time: { created: number };
+  agent: string;
+  model: { providerID: string; modelID: string };
+  summary: { diffs: Array<{ path: string; type: string; lines: Record<string, number> }> };
+  id: string;
+}
+
+export interface MessagePart {
+  type: string;
+  text?: string;
+}
+
+export interface SessionMessage {
+  info: MessageInfo;
+  parts: MessagePart[];
+}
+
+export interface SessionDetail {
+  info: SessionInfo;
+  messages: SessionMessage[];
+}
+
+export interface GitLogEntry {
+  commit: string;
+  author: string;
+  date: string;
+  message: string;
+  files_changed: number;
+  insertions: number;
+  deletions: number;
+}
+
+export interface GitStats {
+  total_commits: number;
+  total_files_changed: number;
+  total_insertions: number;
+  total_deletions: number;
+  per_date: Record<string, { commits: number; insertions: number; deletions: number }>;
+}
+
+export interface SearchResult {
+  session_id: string;
+  date: string;
+  summary: string;
+  tags: string[];
+  match_type: 'summary' | 'tag' | 'transcript';
+  match_snippet: string;
+}
+
+export interface CrossDayStats {
+  total_days: number;
+  total_sessions: number;
+  total_prompter_time_hours: number;
+  total_sme_time_hours: number;
+  avg_multiplier: number;
+  per_day: NormalizedDay[];
+}
+
+export interface SpecNode {
+  name: string;
+  path: string;
+  isDir: boolean;
+  children?: SpecNode[];
+}
+
+export interface HealthStatus {
+  status: 'ok' | 'error';
+  days_count: number;
+  sessions_count: number;
+  sessions_path: string;
+}
+
+export interface ExperimentEntry {
+  date: string;
+  directory: string;
+  description: string;
+  outcome: string;
+  agent: string;
+}
+
+export interface ExperimentFile {
+  path: string;
+  name: string;
+  size: number;
+}
+
+export interface ExperimentSubdir {
+  name: string;
+  files: ExperimentFile[];
+}
+
+export interface ExperimentDetail {
+  entry: ExperimentEntry;
+  readme: string | null;
+  subdirs: ExperimentSubdir[];
+  allFiles: ExperimentFile[];
+}