@opensassi/opencode 0.1.3 → 0.1.5

package/dashboard/dist/services/experiments.js

@@ -0,0 +1,108 @@
+import { readFileSync, readdirSync, existsSync, statSync } from 'node:fs';
+import { join, resolve, relative } from 'node:path';
+export class ExperimentsService {
+    experimentsDir;
+    constructor(experimentsDir) {
+        this.experimentsDir = resolve(experimentsDir);
+    }
+    listExperiments() {
+        const indexPath = join(this.experimentsDir, 'README.md');
+        if (!existsSync(indexPath))
+            return [];
+        const content = readFileSync(indexPath, 'utf-8');
+        return this.parseTable(content);
+    }
+    getExperiment(directory) {
+        const entries = this.listExperiments();
+        const entry = entries.find(e => e.directory === directory || e.directory.replace(/\/$/, '') === directory.replace(/\/$/, ''));
+        if (!entry)
+            return null;
+        const dirPath = join(this.experimentsDir, entry.directory.replace(/\/$/, ''));
+        if (!existsSync(dirPath))
+            return null;
+        let readme = null;
+        const readmePath = join(dirPath, 'README.md');
+        if (existsSync(readmePath)) {
+            readme = readFileSync(readmePath, 'utf-8');
+        }
+        const subdirs = [];
+        const allFiles = [];
+        const expPrefix = entry.directory.replace(/\/$/, '');
+        const items = readdirSync(dirPath);
+        for (const item of items) {
+            const itemPath = join(dirPath, item);
+            const stat = statSync(itemPath);
+            if (stat.isDirectory()) {
+                const files = this.listFilesRecursive(itemPath, this.experimentsDir);
+                subdirs.push({ name: item, files });
+                allFiles.push(...files);
+            }
+            else {
+                const file = {
+                    path: relative(this.experimentsDir, itemPath),
+                    name: item,
+                    size: stat.size,
+                };
+                if (item !== 'README.md') {
+                    allFiles.push(file);
+                }
+            }
+        }
+        return { entry, readme, subdirs, allFiles };
+    }
+    readFile(filePath) {
+        const fullPath = join(this.experimentsDir, filePath);
+        if (!existsSync(fullPath))
+            return null;
+        return readFileSync(fullPath, 'utf-8');
+    }
+    readFileRaw(filePath) {
+        const fullPath = join(this.experimentsDir, filePath);
+        if (!existsSync(fullPath))
+            return null;
+        return readFileSync(fullPath);
+    }
+    listFilesRecursive(dirPath, rootDir) {
+        const files = [];
+        const items = readdirSync(dirPath);
+        for (const item of items) {
+            const itemPath = join(dirPath, item);
+            const stat = statSync(itemPath);
+            if (stat.isDirectory()) {
+                files.push(...this.listFilesRecursive(itemPath, rootDir));
+            }
+            else {
+                files.push({
+                    path: relative(rootDir, itemPath),
+                    name: item,
+                    size: stat.size,
+                });
+            }
+        }
+        return files;
+    }
+    parseTable(content) {
+        const entries = [];
+        const lines = content.split('\n');
+        let inTable = false;
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith('|') && trimmed.includes('---')) {
+                inTable = true;
+                continue;
+            }
+            if (!trimmed.startsWith('|') || !inTable)
+                continue;
+            const cells = trimmed.split('|').slice(1, -1).map(c => c.trim());
+            if (cells.length < 5)
+                continue;
+            const date = cells[0].trim();
+            const dirCell = cells[1].replace(/^`|`$/g, '').replace(/\/$/, '').trim();
+            const desc = cells[2].replace(/^`|`$/g, '').trim();
+            const outcome = cells[3].replace(/\*\*/g, '').trim();
+            const agent = cells[4].replace(/^`|`$/g, '').trim();
+            entries.push({ date, directory: dirCell, description: desc, outcome, agent });
+        }
+        return entries;
+    }
+}

package/dashboard/dist/services/git.d.ts

@@ -0,0 +1,12 @@
+import type { GitLogEntry, GitStats } from '../types.js';
+export declare class GitService {
+    private repoDir;
+    private defaultSince;
+    constructor(repoDir: string, defaultSince?: string | null);
+    detectForkPoint(): string | null;
+    getRange(rangeBase: string | null): string | undefined;
+    getLog(since?: string, until?: string, forkRange?: string | null): GitLogEntry[];
+    private parseLogOutput;
+    getStats(forkRange?: string | null): GitStats;
+    getCommitDiff(hash: string): string;
+}

package/dashboard/dist/services/git.js

@@ -0,0 +1,149 @@
+import { execFileSync } from 'node:child_process';
+export class GitService {
+    repoDir;
+    defaultSince;
+    constructor(repoDir, defaultSince) {
+        this.repoDir = repoDir;
+        this.defaultSince = defaultSince ?? null;
+    }
+    detectForkPoint() {
+        const makeOpts = (mb) => ({
+            cwd: this.repoDir, encoding: 'utf-8', maxBuffer: mb,
+            stdio: ['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) {
+        if (!rangeBase)
+            return undefined;
+        return rangeBase + '..HEAD';
+    }
+    getLog(since, until, forkRange) {
+        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'] });
+            return this.parseLogOutput(output);
+        }
+        catch {
+            return [];
+        }
+    }
+    parseLogOutput(output) {
+        const entries = [];
+        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) {
+        const allLog = this.getLog(undefined, undefined, forkRange);
+        const perDate = {};
+        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) {
+        try {
+            return execFileSync('git', ['show', hash, '--no-color'], {
+                cwd: this.repoDir,
+                encoding: 'utf-8',
+                maxBuffer: 10 * 1024 * 1024,
+                stdio: ['pipe', 'pipe', 'ignore'],
+            });
+        }
+        catch {
+            return '';
+        }
+    }
+}

package/dashboard/dist/services/sessions.d.ts

@@ -0,0 +1,25 @@
+import type { NormalizedDay, SessionDetail, SessionEntry, SearchResult } from '../types.js';
+export interface SessionsConfig {
+    sessionsDir: string;
+}
+export declare class SessionsService {
+    private dailyCache;
+    private detailCache;
+    private daysListCache;
+    private sessionsDir;
+    constructor(sessionsDir: string);
+    get dailyDir(): string;
+    listDays(): string[];
+    listSessionsDirFiles(): string[];
+    getDay(date: string): NormalizedDay;
+    getAllSessionsFlat(): Array<{
+        date: string;
+        entry: SessionEntry;
+    }>;
+    getSessionDetail(sessionId: string): SessionDetail | null;
+    getSessionSummary(sessionId: string): string | null;
+    private resolveBz2File;
+    private resolveMdFile;
+    search(query: string): SearchResult[];
+    refresh(): void;
+}

package/dashboard/dist/services/sessions.js

@@ -0,0 +1,208 @@
+import { readFileSync, readdirSync, existsSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { TTLCache } from './cache.js';
+function normalizeDay(raw, date) {
+    const a = raw;
+    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;
+    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 class SessionsService {
+    dailyCache = new TTLCache(60_000);
+    detailCache = new TTLCache(300_000);
+    daysListCache = new TTLCache(30_000);
+    sessionsDir;
+    constructor(sessionsDir) {
+        this.sessionsDir = resolve(sessionsDir);
+    }
+    get dailyDir() {
+        return join(this.sessionsDir, 'daily');
+    }
+    listDays() {
+        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() {
+        if (!existsSync(this.sessionsDir))
+            return [];
+        return readdirSync(this.sessionsDir).filter(f => f.endsWith('.json.bz2'));
+    }
+    getDay(date) {
+        const cached = this.dailyCache.get(date);
+        if (cached)
+            return cached;
+        const path = join(this.dailyDir, `${date}.json`);
+        if (!existsSync(path)) {
+            const day = {
+                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() {
+        const days = this.listDays();
+        const result = [];
+        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) {
+        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);
+            this.detailCache.set(sessionId, detail);
+            return detail;
+        }
+        catch {
+            return null;
+        }
+    }
+    getSessionSummary(sessionId) {
+        const mdFile = this.resolveMdFile(sessionId);
+        if (!mdFile)
+            return null;
+        return readFileSync(mdFile, 'utf-8');
+    }
+    resolveBz2File(sessionId) {
+        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;
+    }
+    resolveMdFile(sessionId) {
+        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) {
+        const q = query.toLowerCase();
+        const results = [];
+        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() {
+        this.dailyCache.invalidateAll();
+        this.daysListCache.invalidateAll();
+        this.detailCache.invalidateAll();
+    }
+}

package/dashboard/dist/services/specs.d.ts

@@ -0,0 +1,9 @@
+import type { SpecNode } from '../types.js';
+export declare class TechSpecService {
+    private rootDir;
+    constructor(rootDir: string);
+    getTree(): SpecNode;
+    readSpec(specPath: string): string | null;
+    private scanDir;
+    private hasSpecs;
+}

package/dashboard/dist/services/specs.js

@@ -0,0 +1,102 @@
+import { readFileSync, readdirSync, existsSync, statSync } from 'node:fs';
+import { join, resolve, relative } from 'node:path';
+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 {
+    rootDir;
+    constructor(rootDir) {
+        this.rootDir = resolve(rootDir);
+    }
+    getTree() {
+        return {
+            name: 'Technical Specifications',
+            path: '',
+            isDir: true,
+            children: this.scanDir(this.rootDir, 6),
+        };
+    }
+    readSpec(specPath) {
+        const fullPath = join(this.rootDir, specPath);
+        if (!existsSync(fullPath))
+            return null;
+        return readFileSync(fullPath, 'utf-8');
+    }
+    scanDir(dir, maxDepth) {
+        if (maxDepth <= 0)
+            return [];
+        const entries = [];
+        try {
+            const items = readdirSync(dir);
+            const dirs = [];
+            const specFiles = [];
+            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;
+    }
+    hasSpecs(dir) {
+        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;
+    }
+}