openbuilder 0.1.0

package/src/audio/transcriber.ts

@@ -0,0 +1,126 @@
+/**
+ * transcriber.ts — Whisper transcription via OpenAI API
+ *
+ * Sends WAV audio chunks to the OpenAI Whisper API and returns
+ * transcription text with timestamps.
+ */
+
+import { createReadStream } from "node:fs";
+
+export interface TranscriptionSegment {
+  start: number; // seconds
+  end: number; // seconds
+  text: string;
+}
+
+export interface TranscriptionResult {
+  text: string;
+  segments: TranscriptionSegment[];
+}
+
+export interface TranscriberOptions {
+  /** OpenAI API key (defaults to OPENAI_API_KEY env var) */
+  apiKey?: string;
+  /** Whisper model name (default "whisper-1") */
+  model?: string;
+  /** Language hint for Whisper (e.g. "en") */
+  language?: string;
+}
+
+export class Transcriber {
+  private client: InstanceType<typeof import("openai").default> | null = null;
+  private model: string;
+  private language?: string;
+  private apiKey?: string;
+
+  constructor(options: TranscriberOptions = {}) {
+    this.model = options.model ?? "whisper-1";
+    this.language = options.language;
+    this.apiKey = options.apiKey;
+  }
+
+  /** Lazily initialize the OpenAI client */
+  private async getClient(): Promise<InstanceType<typeof import("openai").default>> {
+    if (this.client) return this.client;
+
+    try {
+      const { default: OpenAI } = await import("openai");
+      this.client = new OpenAI({
+        apiKey: this.apiKey ?? process.env.OPENAI_API_KEY,
+      });
+      return this.client;
+    } catch {
+      throw new Error(
+        "OpenAI package not found. Install it with: npm install openai",
+      );
+    }
+  }
+
+  /**
+   * Transcribe a WAV audio chunk using the Whisper API.
+   *
+   * Returns text and segment-level timestamps.
+   * Retries on rate limit (429) errors with exponential backoff.
+   */
+  async transcribeChunk(wavPath: string): Promise<TranscriptionResult> {
+    const client = await this.getClient();
+
+    let lastError: Error | undefined;
+
+    for (let attempt = 0; attempt < 3; attempt++) {
+      try {
+        const response = await client.audio.transcriptions.create({
+          model: this.model,
+          file: createReadStream(wavPath),
+          response_format: "verbose_json",
+          timestamp_granularities: ["segment"],
+          ...(this.language ? { language: this.language } : {}),
+        });
+
+        // The response with verbose_json includes segments
+        const raw = response as Record<string, unknown>;
+        const segments: TranscriptionSegment[] = [];
+
+        if (Array.isArray(raw.segments)) {
+          for (const seg of raw.segments) {
+            if (seg && typeof seg === "object") {
+              const s = seg as { start?: number; end?: number; text?: string };
+              segments.push({
+                start: s.start ?? 0,
+                end: s.end ?? 0,
+                text: (s.text ?? "").trim(),
+              });
+            }
+          }
+        }
+
+        return {
+          text: (response.text ?? "").trim(),
+          segments,
+        };
+      } catch (err: unknown) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+
+        // Check for rate limit (429) — retry with backoff
+        const statusCode =
+          err && typeof err === "object" && "status" in err
+            ? (err as { status: number }).status
+            : 0;
+
+        if (statusCode === 429 && attempt < 2) {
+          const delay = Math.pow(2, attempt + 1) * 1000; // 2s, 4s
+          console.log(`  Whisper rate limited, retrying in ${delay / 1000}s...`);
+          await new Promise((r) => setTimeout(r, delay));
+          continue;
+        }
+
+        // Non-retryable error
+        break;
+      }
+    }
+
+    throw new Error(
+      `Whisper transcription failed: ${lastError?.message ?? "unknown error"}`,
+    );
+  }
+}

package/src/report/generator.ts

@@ -0,0 +1,149 @@
+/**
+ * generator.ts — Meeting report generation
+ *
+ * Combines AI analysis results with speaker analytics to produce
+ * a structured markdown meeting report.
+ */
+
+import type { MeetingAnalytics } from "../analytics/speaker-stats.js";
+
+export interface MeetingAnalysis {
+  summary: string;
+  chapters: Array<{ timestamp: string; title: string; description: string }>;
+  actionItems: Array<{ description: string; assignee: string | null }>;
+  keyDecisions: string[];
+  keyQuestions: Array<{ question: string; status: string }>;
+}
+
+export interface ReportOptions {
+  meetingId?: string;
+  date?: string;
+  transcriptPath?: string;
+  analysis: MeetingAnalysis;
+  analytics: MeetingAnalytics;
+}
+
+/** Parse the JSON response from AI into a MeetingAnalysis object. */
+export function parseAnalysisResponse(response: string): MeetingAnalysis {
+  // Strip markdown fences if the AI included them
+  let cleaned = response.trim();
+  if (cleaned.startsWith("```")) {
+    cleaned = cleaned.replace(/^```(?:json)?\s*\n?/, "").replace(/\n?```\s*$/, "");
+  }
+
+  const parsed = JSON.parse(cleaned) as Record<string, unknown>;
+
+  return {
+    summary: typeof parsed.summary === "string" ? parsed.summary : "",
+    chapters: Array.isArray(parsed.chapters)
+      ? parsed.chapters.map((c: Record<string, unknown>) => ({
+          timestamp: String(c.timestamp ?? ""),
+          title: String(c.title ?? ""),
+          description: String(c.description ?? ""),
+        }))
+      : [],
+    actionItems: Array.isArray(parsed.actionItems)
+      ? parsed.actionItems.map((a: Record<string, unknown>) => ({
+          description: String(a.description ?? ""),
+          assignee: a.assignee ? String(a.assignee) : null,
+        }))
+      : [],
+    keyDecisions: Array.isArray(parsed.keyDecisions)
+      ? parsed.keyDecisions.map((d: unknown) => String(d))
+      : [],
+    keyQuestions: Array.isArray(parsed.keyQuestions)
+      ? parsed.keyQuestions.map((q: Record<string, unknown>) => ({
+          question: String(q.question ?? ""),
+          status: String(q.status ?? "unknown"),
+        }))
+      : [],
+  };
+}
+
+/** Generate a formatted markdown meeting report. */
+export function generateReport(options: ReportOptions): string {
+  const { analysis, analytics, meetingId, date, transcriptPath } = options;
+  const reportDate = date ?? new Date().toISOString().split("T")[0]!;
+  const title = meetingId ? `${meetingId} — ${reportDate}` : reportDate;
+
+  const lines: string[] = [];
+
+  lines.push(`# Meeting Report: ${title}`);
+  lines.push("");
+
+  // Summary
+  lines.push("## Summary");
+  lines.push("");
+  lines.push(analysis.summary || "(No summary generated)");
+  lines.push("");
+
+  // Chapters
+  if (analysis.chapters.length > 0) {
+    lines.push("## Chapters");
+    lines.push("");
+    for (let i = 0; i < analysis.chapters.length; i++) {
+      const ch = analysis.chapters[i]!;
+      lines.push(`${i + 1}. [${ch.timestamp}] ${ch.title} — ${ch.description}`);
+    }
+    lines.push("");
+  }
+
+  // Action Items
+  if (analysis.actionItems.length > 0) {
+    lines.push("## Action Items");
+    lines.push("");
+    for (const item of analysis.actionItems) {
+      const assignee = item.assignee ? ` (@${item.assignee})` : "";
+      lines.push(`- [ ] ${item.description}${assignee}`);
+    }
+    lines.push("");
+  }
+
+  // Key Decisions
+  if (analysis.keyDecisions.length > 0) {
+    lines.push("## Key Decisions");
+    lines.push("");
+    for (const decision of analysis.keyDecisions) {
+      lines.push(`- ${decision}`);
+    }
+    lines.push("");
+  }
+
+  // Key Questions
+  if (analysis.keyQuestions.length > 0) {
+    lines.push("## Key Questions");
+    lines.push("");
+    for (const q of analysis.keyQuestions) {
+      lines.push(`- ${q.question} (${q.status})`);
+    }
+    lines.push("");
+  }
+
+  // Speaker Analytics
+  if (analytics.speakers.length > 0) {
+    lines.push("## Speaker Analytics");
+    lines.push("");
+    lines.push("| Speaker | Talk Time | % of Meeting | Words |");
+    lines.push("|---------|-----------|--------------|-------|");
+    for (const speaker of analytics.speakers) {
+      lines.push(
+        `| ${speaker.speaker} | ${speaker.talkTimeFormatted} | ${speaker.percentage}% | ${speaker.wordCount.toLocaleString()} |`,
+      );
+    }
+    lines.push("");
+  }
+
+  // Metadata
+  lines.push("## Metadata");
+  lines.push("");
+  lines.push(`- Duration: ${analytics.totalDurationFormatted}`);
+  lines.push(`- Participants: ${analytics.participantCount}`);
+  if (transcriptPath) {
+    lines.push(`- Transcript: ${transcriptPath}`);
+  }
+  lines.push(`- Generated: ${new Date().toISOString()}`);
+  lines.push(`- Powered by: OpenBuilder (https://github.com/superliangbot/openbuilder)`);
+  lines.push("");
+
+  return lines.join("\n");
+}

package/src/utils/config.ts

@@ -0,0 +1,102 @@
+/**
+ * config.ts — Configuration file management for OpenBuilder
+ *
+ * Config file: ~/.openbuilder/config.json
+ * Environment variables override config file values.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export const OPENBUILDER_DIR = join(homedir(), ".openbuilder");
+export const CONFIG_FILE = join(OPENBUILDER_DIR, "config.json");
+export const AUTH_FILE = join(OPENBUILDER_DIR, "auth.json");
+export const AUTH_META_FILE = join(OPENBUILDER_DIR, "auth-meta.json");
+export const PID_FILE = join(OPENBUILDER_DIR, "builder.pid");
+export const WORKSPACE_DIR = join(homedir(), ".openclaw", "workspace", "openbuilder");
+export const TRANSCRIPTS_DIR = join(WORKSPACE_DIR, "transcripts");
+export const REPORTS_DIR = join(WORKSPACE_DIR, "reports");
+export const SCREENSHOT_READY_FILE = join(WORKSPACE_DIR, "screenshot-ready.json");
+
+export interface OpenBuilderConfig {
+  aiProvider?: "claude" | "openai";
+  anthropicApiKey?: string;
+  openaiApiKey?: string;
+  botName?: string;
+  defaultDuration?: string;
+  captureMode?: "audio" | "captions" | "auto";
+  whisperModel?: string;
+}
+
+const ENV_MAP: Record<string, keyof OpenBuilderConfig> = {
+  OPENBUILDER_AI_PROVIDER: "aiProvider",
+  ANTHROPIC_API_KEY: "anthropicApiKey",
+  OPENAI_API_KEY: "openaiApiKey",
+  OPENBUILDER_BOT_NAME: "botName",
+  OPENBUILDER_DEFAULT_DURATION: "defaultDuration",
+  OPENBUILDER_CAPTURE_MODE: "captureMode",
+  OPENBUILDER_WHISPER_MODEL: "whisperModel",
+};
+
+/** Read the config file from disk. Returns empty object if not found. */
+export function readConfig(): OpenBuilderConfig {
+  if (!existsSync(CONFIG_FILE)) return {};
+  try {
+    return JSON.parse(readFileSync(CONFIG_FILE, "utf-8")) as OpenBuilderConfig;
+  } catch {
+    return {};
+  }
+}
+
+/** Write the config file to disk. */
+export function writeConfig(config: OpenBuilderConfig): void {
+  mkdirSync(OPENBUILDER_DIR, { recursive: true });
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n");
+}
+
+/**
+ * Get the effective config — file values with environment variable overrides.
+ * Environment variables always take precedence over config file values.
+ */
+export function getConfig(): OpenBuilderConfig {
+  const fileConfig = readConfig();
+
+  // Apply environment variable overrides
+  for (const [envVar, configKey] of Object.entries(ENV_MAP)) {
+    const envValue = process.env[envVar];
+    if (envValue !== undefined && envValue !== "") {
+      (fileConfig as Record<string, string>)[configKey] = envValue;
+    }
+  }
+
+  return fileConfig;
+}
+
+/** Get a single config value (with env override). */
+export function getConfigValue(key: keyof OpenBuilderConfig): string | undefined {
+  const config = getConfig();
+  return config[key] as string | undefined;
+}
+
+/** Set a single config value in the config file. */
+export function setConfigValue(key: keyof OpenBuilderConfig, value: string): void {
+  const config = readConfig();
+  (config as Record<string, string>)[key] = value;
+  writeConfig(config);
+}
+
+/** Delete a config value from the config file. */
+export function deleteConfigValue(key: keyof OpenBuilderConfig): void {
+  const config = readConfig();
+  delete config[key];
+  writeConfig(config);
+}
+
+/** Ensure all required directories exist. */
+export function ensureDirs(): void {
+  mkdirSync(OPENBUILDER_DIR, { recursive: true });
+  mkdirSync(WORKSPACE_DIR, { recursive: true });
+  mkdirSync(TRANSCRIPTS_DIR, { recursive: true });
+  mkdirSync(REPORTS_DIR, { recursive: true });
+}

package/src/utils/transcript-parser.ts

@@ -0,0 +1,116 @@
+/**
+ * transcript-parser.ts — Parse OpenBuilder transcript files
+ *
+ * Transcript format: [HH:MM:SS] Speaker: text
+ * Handles both live-captured and manually-created transcripts.
+ */
+
+import { readFileSync } from "node:fs";
+
+export interface TranscriptLine {
+  timestamp: string;
+  hours: number;
+  minutes: number;
+  seconds: number;
+  totalSeconds: number;
+  speaker: string;
+  text: string;
+}
+
+export interface ParsedTranscript {
+  lines: TranscriptLine[];
+  speakers: string[];
+  durationSeconds: number;
+  wordCount: number;
+  rawText: string;
+}
+
+const LINE_RE = /^\[(\d{2}):(\d{2}):(\d{2})\]\s+(.+?):\s+(.+)$/;
+
+/** Parse a single transcript line. Returns null if the line doesn't match. */
+export function parseTranscriptLine(line: string): TranscriptLine | null {
+  const match = line.trim().match(LINE_RE);
+  if (!match) return null;
+
+  const hours = parseInt(match[1]!, 10);
+  const minutes = parseInt(match[2]!, 10);
+  const seconds = parseInt(match[3]!, 10);
+
+  return {
+    timestamp: `${match[1]}:${match[2]}:${match[3]}`,
+    hours,
+    minutes,
+    seconds,
+    totalSeconds: hours * 3600 + minutes * 60 + seconds,
+    speaker: match[4]!.trim(),
+    text: match[5]!.trim(),
+  };
+}
+
+/** Parse an entire transcript file or string. */
+export function parseTranscript(input: string): ParsedTranscript {
+  const rawLines = input.split("\n").filter((l) => l.trim().length > 0);
+  const lines: TranscriptLine[] = [];
+
+  for (const rawLine of rawLines) {
+    const parsed = parseTranscriptLine(rawLine);
+    if (parsed) lines.push(parsed);
+  }
+
+  const speakers = [...new Set(lines.map((l) => l.speaker))];
+  const wordCount = lines.reduce((sum, l) => sum + l.text.split(/\s+/).length, 0);
+
+  // Duration: difference between first and last timestamp
+  let durationSeconds = 0;
+  if (lines.length >= 2) {
+    durationSeconds = lines[lines.length - 1]!.totalSeconds - lines[0]!.totalSeconds;
+  }
+
+  return { lines, speakers, durationSeconds, wordCount, rawText: input };
+}
+
+/** Read and parse a transcript file from disk. */
+export function parseTranscriptFile(filePath: string): ParsedTranscript {
+  const content = readFileSync(filePath, "utf-8");
+  return parseTranscript(content);
+}
+
+/**
+ * Format transcript as a clean string for AI processing.
+ * Includes all lines with timestamps and speaker names.
+ */
+export function formatTranscriptForAI(transcript: ParsedTranscript): string {
+  return transcript.lines
+    .map((l) => `[${l.timestamp}] ${l.speaker}: ${l.text}`)
+    .join("\n");
+}
+
+/**
+ * Chunk a transcript into segments that fit within a token limit.
+ * Uses a rough estimate of 4 characters per token.
+ * Each chunk preserves complete lines (never splits mid-line).
+ */
+export function chunkTranscript(
+  transcript: ParsedTranscript,
+  maxCharsPerChunk: number = 30000,
+): string[] {
+  const chunks: string[] = [];
+  let currentChunk = "";
+
+  for (const line of transcript.lines) {
+    const formattedLine = `[${line.timestamp}] ${line.speaker}: ${line.text}\n`;
+
+    if (currentChunk.length + formattedLine.length > maxCharsPerChunk && currentChunk.length > 0) {
+      chunks.push(currentChunk.trim());
+      currentChunk = "";
+    }
+
+    currentChunk += formattedLine;
+  }
+
+  if (currentChunk.trim().length > 0) {
+    chunks.push(currentChunk.trim());
+  }
+
+  return chunks.length > 0 ? chunks : ["(empty transcript)"];
+}