tycono-server 0.1.0-beta.0

package/src/api/src/services/claude-md-manager.ts

@@ -0,0 +1,94 @@
+/**
+ * claude-md-manager.ts — CLAUDE.md lifecycle management
+ *
+ * CLAUDE.md is 100% Tycono-managed. This module handles:
+ * - Version tracking via .tycono/rules-version
+ * - Auto-regeneration on version mismatch (server startup)
+ * - Backup of pre-existing CLAUDE.md (first time only)
+ * - Stub creation for knowledge/custom-rules.md
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const TEMPLATES_DIR = path.resolve(__dirname, '../../../../templates');
+
+/**
+ * Read the current package version from package.json
+ */
+function getPackageVersion(): string {
+  const pkgPath = path.resolve(__dirname, '../../../../package.json');
+  try {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+    return pkg.version || '0.0.0';
+  } catch {
+    return '0.0.0';
+  }
+}
+
+/**
+ * Generate CLAUDE.md content from template with version marker
+ */
+function generateClaudeMd(version: string): string {
+  const tmplPath = path.join(TEMPLATES_DIR, 'CLAUDE.md.tmpl');
+  const template = fs.readFileSync(tmplPath, 'utf-8');
+  return template.replaceAll('{{VERSION}}', version);
+}
+
+/**
+ * Ensure CLAUDE.md is up-to-date with the current package version.
+ *
+ * Called on server startup. Compares .tycono/rules-version with package version.
+ * If different, regenerates CLAUDE.md from template (safe because CLAUDE.md
+ * contains 0% user data — all user customization is in knowledge/custom-rules.md).
+ */
+export function ensureClaudeMd(companyRoot: string): void {
+  const tyconoDir = path.join(companyRoot, '.tycono');
+  const rulesVersionPath = path.join(tyconoDir, 'rules-version');
+  const claudeMdPath = path.join(companyRoot, 'knowledge', 'CLAUDE.md');
+  const knowledgeDir = path.join(companyRoot, 'knowledge');
+  const customRulesPath = path.join(knowledgeDir, 'custom-rules.md');
+  const backupPath = path.join(tyconoDir, 'CLAUDE.md.backup');
+
+  // Skip if not initialized (no .tycono/ directory)
+  if (!fs.existsSync(tyconoDir)) return;
+
+  const currentVersion = getPackageVersion();
+
+  // Read stored version
+  let storedVersion = '0.0.0';
+  if (fs.existsSync(rulesVersionPath)) {
+    storedVersion = fs.readFileSync(rulesVersionPath, 'utf-8').trim();
+  }
+
+  // Skip if already up-to-date
+  if (storedVersion === currentVersion) return;
+
+  // Backup existing CLAUDE.md (first time only — don't overwrite previous backup)
+  if (fs.existsSync(claudeMdPath) && !fs.existsSync(backupPath)) {
+    fs.copyFileSync(claudeMdPath, backupPath);
+    console.log(`[CLAUDE.md] Backed up existing CLAUDE.md to .tycono/CLAUDE.md.backup`);
+  }
+
+  // Regenerate CLAUDE.md from template
+  const content = generateClaudeMd(currentVersion);
+  fs.writeFileSync(claudeMdPath, content);
+
+  // Update rules-version
+  fs.writeFileSync(rulesVersionPath, currentVersion);
+
+  // Create custom-rules.md stub if not exists
+  if (!fs.existsSync(customRulesPath)) {
+    fs.writeFileSync(customRulesPath, `# Custom Rules
+
+> Company-specific rules, constraints, and processes.
+> This file is owned by you — Tycono will never overwrite it.
+
+<!-- Add your custom rules below -->
+`);
+  }
+
+  console.log(`[CLAUDE.md] System rules updated to v${currentVersion} (was v${storedVersion})`);
+}

package/src/api/src/services/company-config.ts

@@ -0,0 +1,115 @@
+/**
+ * company-config.ts — .tycono/config.json 관리
+ *
+ * AKB 디렉토리의 영구 설정을 읽고 쓴다.
+ * scaffold 시 생성되고, 서버 시작 시 로드된다.
+ */
+import { execSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+
+export interface ConversationLimits {
+  /** Harness 레벨 경고 턴 수 (기본 50). 도달 시 turn:warning 이벤트 발생. */
+  softLimit: number;
+  /** Harness 레벨 강제 종료 턴 수 (기본 200). 도달 시 Runner abort. */
+  hardLimit: number;
+}
+
+export interface CompanyConfig {
+  engine: 'claude-cli' | 'direct-api';
+  model?: string;
+  apiKey?: string;
+  codeRoot?: string;  // 코드 프로젝트 경로 (AKB와 분리된 코드 repo)
+  conversationLimits?: Partial<ConversationLimits>;
+  supervision?: {
+    mode: 'supervisor' | 'direct';
+  };
+}
+
+export const TYCONO_DIR = '.tycono';
+const CONFIG_DIR = TYCONO_DIR;
+const CONFIG_FILE = 'config.json';
+const DEFAULT_CONVERSATION_LIMITS: ConversationLimits = {
+  softLimit: 50,
+  hardLimit: 200,
+};
+
+const DEFAULT_CONFIG: CompanyConfig = { engine: 'claude-cli' };
+
+/** Resolve conversation limits with defaults. */
+export function getConversationLimits(config: CompanyConfig): ConversationLimits {
+  return {
+    ...DEFAULT_CONVERSATION_LIMITS,
+    ...config.conversationLimits,
+  };
+}
+
+function configPath(companyRoot: string): string {
+  return path.join(companyRoot, CONFIG_DIR, CONFIG_FILE);
+}
+
+/**
+ * Resolve codeRoot: explicit config > auto-generated sibling directory.
+ * When codeRoot is not configured, defaults to `../{dirname}-code/` next to companyRoot.
+ * Auto-creates the directory if it doesn't exist.
+ */
+export function resolveCodeRoot(companyRoot: string): string {
+  const config = readConfig(companyRoot);
+  const codeRoot = config.codeRoot ?? (() => {
+    // Auto-generate: ../{folder-name}-code/
+    const dirName = path.basename(companyRoot);
+    const auto = path.join(path.dirname(companyRoot), `${dirName}-code`);
+    if (!fs.existsSync(auto)) {
+      fs.mkdirSync(auto, { recursive: true });
+    }
+    // Persist so it's stable across restarts
+    writeConfig(companyRoot, { ...config, codeRoot: auto });
+    return auto;
+  })();
+
+  // Auto-init git if not already a repo (even if codeRoot was already configured)
+  const gitDir = path.join(codeRoot, '.git');
+  if (fs.existsSync(codeRoot) && !fs.existsSync(gitDir)) {
+    try {
+      execSync('git init', { cwd: codeRoot, stdio: 'pipe' });
+      execSync('git commit --allow-empty -m "Initial commit by Tycono"', { cwd: codeRoot, stdio: 'pipe' });
+    } catch { /* ignore — git may not be installed */ }
+  }
+
+  return codeRoot;
+}
+
+/** Read config from .tycono/config.json. Returns defaults if missing. */
+export function readConfig(companyRoot: string): CompanyConfig {
+  const p = configPath(companyRoot);
+  if (!fs.existsSync(p)) return { ...DEFAULT_CONFIG };
+  try {
+    return { ...DEFAULT_CONFIG, ...JSON.parse(fs.readFileSync(p, 'utf-8')) };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+
+/** Write config to .tycono/config.json. Creates dir if needed. */
+export function writeConfig(companyRoot: string, config: CompanyConfig): void {
+  const dir = path.join(companyRoot, CONFIG_DIR);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(configPath(companyRoot), JSON.stringify(config, null, 2) + '\n');
+}
+
+/**
+ * Load config and apply to process.env.
+ * Called once at server startup.
+ */
+export function applyConfig(companyRoot: string): CompanyConfig {
+  const config = readConfig(companyRoot);
+
+  if (config.apiKey && !process.env.ANTHROPIC_API_KEY) {
+    process.env.ANTHROPIC_API_KEY = config.apiKey;
+  }
+  if (!process.env.EXECUTION_ENGINE) {
+    process.env.EXECUTION_ENGINE = config.engine;
+  }
+
+  return config;
+}

package/src/api/src/services/database.ts

@@ -0,0 +1,77 @@
+/**
+ * Database Service — SQLite for operational data
+ *
+ * Stores: sessions, messages, waves, wave_messages, activity_events, cost
+ * NOT stored: knowledge/, CLAUDE.md, role.yaml, skills/ (stay as files for AI grep + git diff)
+ *
+ * Location: .tycono/tycono.db (single file, no server)
+ */
+
+import Database from 'better-sqlite3';
+import path from 'node:path';
+import fs from 'node:fs';
+import { COMPANY_ROOT } from './file-reader.js';
+
+let db: Database.Database | null = null;
+
+export function getDb(): Database.Database {
+  if (db) return db;
+
+  const dbDir = path.join(COMPANY_ROOT, '.tycono');
+  if (!fs.existsSync(dbDir)) fs.mkdirSync(dbDir, { recursive: true });
+
+  const dbPath = path.join(dbDir, 'tycono.db');
+  db = new Database(dbPath);
+
+  // Performance: WAL mode for concurrent reads during writes
+  db.pragma('journal_mode = WAL');
+  db.pragma('synchronous = NORMAL');
+  db.pragma('foreign_keys = ON');
+
+  initSchema(db);
+  return db;
+}
+
+export function closeDb(): void {
+  if (db) {
+    db.close();
+    db = null;
+  }
+}
+
+function initSchema(db: Database.Database): void {
+  db.exec(`
+    -- ── Wave Messages (CEO↔Supervisor conversation history) ──
+    CREATE TABLE IF NOT EXISTS wave_message (
+      seq          INTEGER NOT NULL,
+      wave_id      TEXT    NOT NULL,
+      role         TEXT    NOT NULL CHECK (role IN ('user', 'assistant', 'summary')),
+      content      TEXT    NOT NULL,
+      ts           TEXT    NOT NULL,
+      execution_id TEXT,
+      metadata     TEXT,
+      summarizes_start_seq INTEGER,
+      summarizes_end_seq   INTEGER,
+      PRIMARY KEY (wave_id, seq)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_wave_message_wave ON wave_message(wave_id);
+
+    -- ── Activity Events (execution event log) ──
+    CREATE TABLE IF NOT EXISTS activity_event (
+      id           INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id   TEXT    NOT NULL,
+      seq          INTEGER NOT NULL,
+      ts           TEXT    NOT NULL,
+      type         TEXT    NOT NULL,
+      role_id      TEXT    NOT NULL,
+      trace_id     TEXT,
+      parent_session_id TEXT,
+      data         TEXT    NOT NULL DEFAULT '{}',
+      UNIQUE(session_id, seq)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_activity_session ON activity_event(session_id);
+    CREATE INDEX IF NOT EXISTS idx_activity_session_seq ON activity_event(session_id, seq);
+  `);
+}

package/src/api/src/services/digest-engine.ts

@@ -0,0 +1,313 @@
+/**
+ * DigestEngine — Server-side JSONL event summarizer for C-Level supervision.
+ *
+ * Pure TypeScript, zero LLM calls ($0 cost).
+ * Classifies activity events by significance tier, detects anomalies,
+ * and produces a concise digest for C-Level consumption.
+ *
+ * SV-2: Core supervision service
+ */
+import type { ActivityEvent, ActivityEventType } from '../../../shared/types.js';
+
+/* ─── Types ──────────────────────────────────── */
+
+export interface Anomaly {
+  type: 'error' | 'stall' | 'scope_creep' | 'awaiting_input' | 'budget_warning' | 'ceo_directive';
+  sessionId: string;
+  message: string;
+  severity: number; // 0-10
+}
+
+export interface DigestResult {
+  text: string;                      // C-Level readable summary (<500 tokens quiet, <2000 active)
+  significanceScore: number;         // 0-10
+  anomalies: Anomaly[];
+  checkpoints: Map<string, number>;  // sessionId → lastSeq
+  peerActivity?: string;             // peer C-Level activity summary
+  eventCount: number;
+  errorCount: number;
+}
+
+/* ─── Event Classification ───────────────────── */
+
+type EventTier = 'critical' | 'high' | 'medium' | 'low';
+
+const EVENT_TIER_MAP: Partial<Record<ActivityEventType, EventTier>> = {
+  'msg:error': 'critical',
+  'msg:awaiting_input': 'critical',
+  'dispatch:start': 'high',
+  'dispatch:done': 'high',
+  'msg:done': 'high',
+  'msg:start': 'high',
+  'thinking': 'medium',
+  'text': 'low',
+  'stderr': 'medium',
+  'msg:turn-complete': 'low',
+  'turn:warning': 'high',
+  'turn:limit': 'critical',
+};
+
+const TIER_WEIGHT: Record<EventTier, number> = {
+  critical: 10,
+  high: 5,
+  medium: 2,
+  low: 0,
+};
+
+function classifyEvent(event: ActivityEvent): EventTier {
+  // tool:start classification depends on tool name
+  if (event.type === 'tool:start') {
+    const toolName = (event.data?.name as string) ?? '';
+    const highTools = ['write_file', 'edit_file', 'bash_execute', 'dispatch', 'consult'];
+    if (highTools.includes(toolName)) return 'high';
+    return 'medium';
+  }
+
+  if (event.type === 'tool:result') {
+    const isError = event.data?.is_error === true;
+    return isError ? 'high' : 'low';
+  }
+
+  return EVENT_TIER_MAP[event.type] ?? 'low';
+}
+
+/* ─── Anomaly Detection ──────────────────────── */
+
+interface SessionState {
+  sessionId: string;
+  roleId: string;
+  lastEventTs: number;
+  eventCount: number;
+  errorCount: number;
+  isDone: boolean;
+  isError: boolean;
+  isAwaitingInput: boolean;
+  toolCalls: string[];       // tool names used
+  filesModified: string[];   // file paths modified
+}
+
+function detectAnomalies(
+  sessionStates: Map<string, SessionState>,
+  now: number,
+): Anomaly[] {
+  const anomalies: Anomaly[] = [];
+
+  for (const [sessionId, state] of sessionStates) {
+    // Stall detection: 3+ minutes without events
+    if (!state.isDone && !state.isError && !state.isAwaitingInput) {
+      const silenceMs = now - state.lastEventTs;
+      if (silenceMs > 3 * 60 * 1000) {
+        anomalies.push({
+          type: 'stall',
+          sessionId,
+          message: `Session ${sessionId} (${state.roleId}): No events for ${Math.round(silenceMs / 60000)}min`,
+          severity: 7,
+        });
+      }
+    }
+
+    // Error detection
+    if (state.isError) {
+      anomalies.push({
+        type: 'error',
+        sessionId,
+        message: `Session ${sessionId} (${state.roleId}): Ended with error`,
+        severity: 10,
+      });
+    }
+
+    // Awaiting input
+    if (state.isAwaitingInput) {
+      anomalies.push({
+        type: 'awaiting_input',
+        sessionId,
+        message: `Session ${sessionId} (${state.roleId}): Awaiting input`,
+        severity: 8,
+      });
+    }
+  }
+
+  return anomalies;
+}
+
+/* ─── Digest Builder ─────────────────────────── */
+
+function buildDigestText(
+  sessionStates: Map<string, SessionState>,
+  eventsBySession: Map<string, ActivityEvent[]>,
+  anomalies: Anomaly[],
+  significanceScore: number,
+): string {
+  const parts: string[] = [];
+
+  // Header
+  const totalEvents = Array.from(eventsBySession.values()).reduce((sum, evts) => sum + evts.length, 0);
+  const totalErrors = Array.from(sessionStates.values()).reduce((sum, s) => sum + s.errorCount, 0);
+  const activeSessions = Array.from(sessionStates.values()).filter(s => !s.isDone && !s.isError).length;
+  const doneSessions = Array.from(sessionStates.values()).filter(s => s.isDone).length;
+
+  parts.push(`## Supervision Digest [score: ${significanceScore}/10]`);
+  parts.push(`Sessions: ${activeSessions} active, ${doneSessions} done | Events: ${totalEvents} | Errors: ${totalErrors}`);
+  parts.push('');
+
+  // Anomalies first (most important)
+  if (anomalies.length > 0) {
+    parts.push('### ⚠️ Anomalies');
+    for (const a of anomalies) {
+      const icon = a.type === 'error' ? '🔴' : a.type === 'stall' ? '🟡' : a.type === 'awaiting_input' ? '🟠' : '⚪';
+      parts.push(`- ${icon} **${a.type}**: ${a.message}`);
+    }
+    parts.push('');
+  }
+
+  // Per-session summary
+  parts.push('### Session Activity');
+  for (const [sessionId, state] of sessionStates) {
+    const events = eventsBySession.get(sessionId) ?? [];
+    const status = state.isDone ? '✅ Done' : state.isError ? '❌ Error' : state.isAwaitingInput ? '🟠 Awaiting' : '🔵 Active';
+
+    parts.push(`**[${state.roleId}]** ${sessionId} — ${status} (${events.length} events)`);
+
+    // Highlight significant events
+    const significant = events.filter(e => {
+      const tier = classifyEvent(e);
+      return tier === 'critical' || tier === 'high';
+    });
+
+    for (const evt of significant.slice(-5)) { // Last 5 significant events
+      const summary = summarizeEvent(evt);
+      if (summary) parts.push(`  - ${summary}`);
+    }
+  }
+
+  return parts.join('\n');
+}
+
+function summarizeEvent(event: ActivityEvent): string | null {
+  switch (event.type) {
+    case 'msg:start':
+      return `Started: ${(event.data?.task as string ?? '').slice(0, 80)}`;
+    case 'msg:done':
+      return `Completed (${event.data?.turns ?? '?'} turns)`;
+    case 'msg:error':
+      return `Error: ${(event.data?.message as string ?? 'unknown').slice(0, 100)}`;
+    case 'msg:awaiting_input':
+      return `Awaiting input: ${(event.data?.question as string ?? '').slice(0, 80)}`;
+    case 'dispatch:start':
+      return `Dispatched → ${event.data?.targetRoleId}: ${(event.data?.task as string ?? '').slice(0, 60)}`;
+    case 'dispatch:done':
+      return `Dispatch completed: ${event.data?.targetRoleId}`;
+    case 'tool:start': {
+      const toolName = event.data?.name as string ?? 'unknown';
+      const input = event.data?.input as Record<string, unknown> | undefined;
+      if (toolName === 'write_file' || toolName === 'edit_file') {
+        return `${toolName}: ${(input?.path as string ?? '').slice(0, 60)}`;
+      }
+      if (toolName === 'bash_execute') {
+        return `bash: ${(input?.command as string ?? '').slice(0, 60)}`;
+      }
+      return null; // Skip read-only tools in summary
+    }
+    case 'turn:warning':
+      return `⚠️ Turn limit warning (${event.data?.turn}/${event.data?.hardLimit})`;
+    case 'turn:limit':
+      return `🔴 Turn limit reached (${event.data?.turn})`;
+    default:
+      return null;
+  }
+}
+
+/* ─── Public API ─────────────────────────────── */
+
+/**
+ * Digest a set of events from multiple sessions.
+ *
+ * @param eventsBySession - Map of sessionId → events collected during the watch period
+ * @param peerEvents - Optional events from peer C-Level sessions
+ */
+export function digest(
+  eventsBySession: Map<string, ActivityEvent[]>,
+  peerEvents?: Map<string, ActivityEvent[]>,
+): DigestResult {
+  const now = Date.now();
+  const sessionStates = new Map<string, SessionState>();
+  const checkpoints = new Map<string, number>();
+
+  // Build session states
+  for (const [sessionId, events] of eventsBySession) {
+    if (events.length === 0) continue;
+
+    const state: SessionState = {
+      sessionId,
+      roleId: events[0].roleId,
+      lastEventTs: new Date(events[events.length - 1].ts).getTime(),
+      eventCount: events.length,
+      errorCount: events.filter(e => e.type === 'msg:error' || (e.type === 'tool:result' && e.data?.is_error)).length,
+      isDone: events.some(e => e.type === 'msg:done'),
+      isError: events.some(e => e.type === 'msg:error'),
+      isAwaitingInput: events.some(e => e.type === 'msg:awaiting_input') && !events.some(e => e.type === 'msg:done'),
+      toolCalls: events.filter(e => e.type === 'tool:start').map(e => e.data?.name as string).filter(Boolean),
+      filesModified: events
+        .filter(e => e.type === 'tool:start' && ['write_file', 'edit_file'].includes(e.data?.name as string))
+        .map(e => (e.data?.input as Record<string, unknown>)?.path as string)
+        .filter(Boolean),
+    };
+    sessionStates.set(sessionId, state);
+    checkpoints.set(sessionId, events[events.length - 1].seq);
+  }
+
+  // Calculate significance score
+  let maxWeight = 0;
+  for (const events of eventsBySession.values()) {
+    for (const event of events) {
+      const tier = classifyEvent(event);
+      const weight = TIER_WEIGHT[tier];
+      if (weight > maxWeight) maxWeight = weight;
+    }
+  }
+
+  const anomalies = detectAnomalies(sessionStates, now);
+  const anomalyBoost = anomalies.length > 0 ? Math.min(anomalies.reduce((sum, a) => sum + a.severity, 0), 10) : 0;
+  const significanceScore = Math.min(10, Math.max(maxWeight, anomalyBoost));
+
+  // Build digest text
+  const text = buildDigestText(sessionStates, eventsBySession, anomalies, significanceScore);
+
+  // Peer activity digest
+  let peerActivity: string | undefined;
+  if (peerEvents && peerEvents.size > 0) {
+    const peerLines: string[] = ['## Peer Activity'];
+    for (const [sessionId, events] of peerEvents) {
+      if (events.length === 0) continue;
+      const roleId = events[0].roleId;
+      const significant = events.filter(e => {
+        const tier = classifyEvent(e);
+        return tier === 'critical' || tier === 'high';
+      });
+      for (const evt of significant.slice(-3)) {
+        const summary = summarizeEvent(evt);
+        if (summary) peerLines.push(`[${roleId}] ${summary}`);
+      }
+    }
+    if (peerLines.length > 1) {
+      peerActivity = peerLines.join('\n');
+    }
+  }
+
+  return {
+    text: peerActivity ? `${text}\n\n${peerActivity}` : text,
+    significanceScore,
+    anomalies,
+    checkpoints,
+    peerActivity,
+    eventCount: Array.from(eventsBySession.values()).reduce((sum, evts) => sum + evts.length, 0),
+    errorCount: Array.from(sessionStates.values()).reduce((sum, s) => sum + s.errorCount, 0),
+  };
+}
+
+/**
+ * Generate a quiet tick summary (for significanceScore < 2 && no anomalies)
+ */
+export function quietDigest(sessionCount: number, eventCount: number, errorCount: number): string {
+  return `All ${sessionCount} sessions progressing normally. No anomalies. [${eventCount} events, ${errorCount} errors]`;
+}