sentix 2.0.1

package/src/commands/status.js

@@ -0,0 +1,149 @@
+/**
+ * sentix status — Governor 상태 + Memory Layer 요약 + 진화 단계 표시
+ */
+
+import { registerCommand } from '../registry.js';
+import { loadIndex } from '../lib/ticket-index.js';
+
+registerCommand('status', {
+  description: 'Show Governor state and Memory Layer summary',
+  usage: 'sentix status',
+
+  async run(_args, ctx) {
+    ctx.log('=== Sentix Status ===\n');
+
+    // ── Governor State ──────────────────────────────
+    if (ctx.exists('tasks/governor-state.json')) {
+      try {
+        const state = await ctx.readJSON('tasks/governor-state.json');
+        ctx.log(`Governor: ${state.status || 'unknown'}`);
+        ctx.log(`Cycle:    ${state.cycle_id || 'none'}`);
+        ctx.log(`Phase:    ${state.current_phase || 'idle'}`);
+        ctx.log(`Request:  "${state.request || ''}"`);
+
+        if (state.plan && state.plan.length > 0) {
+          ctx.log('\nPipeline:');
+          for (const step of state.plan) {
+            const icon = step.status === 'done' ? '✓'
+              : step.status === 'running' ? '▶'
+              : '○';
+            ctx.log(`  ${icon} ${step.agent} — ${step.status}${step.result ? ` (${step.result})` : ''}`);
+          }
+        }
+
+        if (state.retries && Object.keys(state.retries).length > 0) {
+          ctx.log(`\nRetries: ${JSON.stringify(state.retries)}`);
+        }
+      } catch {
+        ctx.warn('Could not read governor-state.json');
+      }
+    } else {
+      ctx.log('Governor: idle (no active cycle)');
+    }
+
+    // ── Memory Layer ────────────────────────────────
+    ctx.log('\n--- Memory Layer ---\n');
+
+    // lessons.md
+    if (ctx.exists('tasks/lessons.md')) {
+      const lessons = await ctx.readFile('tasks/lessons.md');
+      const lines = lessons.split('\n').filter(l => l.startsWith('- '));
+      ctx.log(`Lessons:     ${lines.length} entries`);
+    } else {
+      ctx.log('Lessons:     (not initialized)');
+    }
+
+    // patterns.md
+    if (ctx.exists('tasks/patterns.md')) {
+      const patterns = await ctx.readFile('tasks/patterns.md');
+      const lines = patterns.split('\n').filter(l => l.startsWith('- '));
+      ctx.log(`Patterns:    ${lines.length} entries`);
+    } else {
+      ctx.log('Patterns:    (not initialized)');
+    }
+
+    // pattern-log.jsonl
+    if (ctx.exists('tasks/pattern-log.jsonl')) {
+      const log = await ctx.readFile('tasks/pattern-log.jsonl');
+      const entries = log.trim().split('\n').filter(Boolean);
+      ctx.log(`Pattern Log: ${entries.length} events`);
+    } else {
+      ctx.log('Pattern Log: (empty)');
+    }
+
+    // agent-metrics.jsonl
+    if (ctx.exists('tasks/agent-metrics.jsonl')) {
+      const metrics = await ctx.readFile('tasks/agent-metrics.jsonl');
+      const entries = metrics.trim().split('\n').filter(Boolean);
+      ctx.log(`Metrics:     ${entries.length} records`);
+    } else {
+      ctx.log('Metrics:     (empty)');
+    }
+
+    // ── Tickets ───────────────────────────────────────
+    ctx.log('\n--- Tickets ---\n');
+
+    try {
+      const tickets = await loadIndex(ctx);
+      if (tickets.length > 0) {
+        const byStatus = {};
+        for (const t of tickets) {
+          byStatus[t.status] = (byStatus[t.status] || 0) + 1;
+        }
+        const critical = tickets.filter(t => t.severity === 'critical' && t.status !== 'closed').length;
+        const parts = Object.entries(byStatus).map(([k, v]) => `${k}: ${v}`);
+        ctx.log(`Tickets:     ${tickets.length} total (${parts.join(', ')})`);
+        if (critical > 0) {
+          ctx.warn(`Critical:    ${critical} open critical ticket(s)`);
+        }
+      } else {
+        ctx.log('Tickets:     (none)');
+      }
+    } catch {
+      ctx.log('Tickets:     (not initialized)');
+    }
+
+    // ── Evolution Stage ─────────────────────────────
+    ctx.log('\n--- Evolution ---\n');
+
+    if (ctx.exists('.sentix/config.toml')) {
+      const config = await ctx.readFile('.sentix/config.toml');
+
+      const layers = [
+        { name: 'Core (Governor + Agents)', key: 'layers.core', required: true },
+        { name: 'Learning Pipeline',        key: 'layers.learning' },
+        { name: 'Pattern Engine',            key: 'layers.pattern_engine' },
+        { name: 'Visual Perception',         key: 'layers.visual' },
+        { name: 'Self-Evolution',            key: 'layers.evolution' },
+      ];
+
+      for (const layer of layers) {
+        const enabled = layer.required || isLayerEnabled(config, layer.key);
+        const icon = enabled ? '●' : '○';
+        ctx.log(`  ${enabled ? icon : icon} ${layer.name}${enabled ? '' : ' (disabled)'}`);
+      }
+    } else {
+      ctx.warn('.sentix/config.toml not found. Run: sentix init');
+    }
+
+    ctx.log('');
+  },
+});
+
+/**
+ * Parse TOML config to check if a specific layer section has enabled = true.
+ * Handles per-section parsing instead of global string search.
+ */
+function isLayerEnabled(config, sectionKey) {
+  const sectionHeader = `[${sectionKey}]`;
+  const idx = config.indexOf(sectionHeader);
+  if (idx === -1) return false;
+
+  // Extract content between this section header and the next section header
+  const afterSection = config.slice(idx + sectionHeader.length);
+  const nextSection = afterSection.indexOf('\n[');
+  const sectionContent = nextSection === -1 ? afterSection : afterSection.slice(0, nextSection);
+
+  // Look for enabled = true within this section only
+  return /enabled\s*=\s*true/.test(sectionContent);
+}

package/src/commands/ticket.js

@@ -0,0 +1,362 @@
+/**
+ * sentix ticket — 버그/이슈 티켓 관리
+ *
+ * sentix ticket create "설명" [--severity critical|warning|suggestion]
+ * sentix ticket list [--status open] [--severity critical]
+ * sentix ticket debug <ticket-id>
+ */
+
+import { spawnSync } from 'node:child_process';
+import { registerCommand } from '../registry.js';
+import {
+  loadIndex, addTicket, updateTicket, findTicket,
+  nextTicketId, classifySeverity, sortBySeverity, createTicketEntry,
+} from '../lib/ticket-index.js';
+import { findBestMatch } from '../lib/similarity.js';
+
+registerCommand('ticket', {
+  description: 'Manage bug/issue tickets (create | list | debug)',
+  usage: 'sentix ticket <create|list|debug> [args...] [--severity critical|warning|suggestion]',
+
+  async run(args, ctx) {
+    const subcommand = args[0];
+
+    if (subcommand === 'create') {
+      await createTicket(args.slice(1), ctx);
+    } else if (!subcommand || subcommand === 'list') {
+      await listTickets(args.slice(1), ctx);
+    } else if (subcommand === 'debug') {
+      const ticketId = args[1];
+      if (!ticketId) {
+        ctx.error('Usage: sentix ticket debug <ticket-id>');
+        return;
+      }
+      await debugTicket(ticketId, ctx);
+    } else {
+      ctx.error(`Unknown subcommand: ${subcommand}`);
+      ctx.log('Usage: sentix ticket <create|list|debug> [args...]');
+    }
+  },
+});
+
+// ── sentix ticket create ──────────────────────────────
+
+async function createTicket(args, ctx) {
+  // Parse --severity flag
+  let severity = null;
+  const flagIdx = args.indexOf('--severity');
+  if (flagIdx !== -1) {
+    severity = args[flagIdx + 1];
+    if (!['critical', 'warning', 'suggestion'].includes(severity)) {
+      ctx.error(`Invalid severity: ${severity} (use critical|warning|suggestion)`);
+      return;
+    }
+    args.splice(flagIdx, 2);
+  }
+
+  const description = args.join(' ').trim();
+  if (!description) {
+    ctx.error('Usage: sentix ticket create "bug description" [--severity critical|warning|suggestion]');
+    return;
+  }
+
+  // Auto-classify severity if not specified
+  if (!severity) {
+    severity = classifySeverity(description);
+    ctx.log(`Auto-classified severity: ${severity}`);
+  }
+
+  // Duplicate detection
+  await checkDuplicates(description, ctx);
+
+  // Create ticket
+  const id = await nextTicketId(ctx, 'bug');
+  const title = description.length > 80 ? description.slice(0, 77) + '...' : description;
+
+  const entry = createTicketEntry({
+    id,
+    type: 'bug',
+    title,
+    severity,
+    description,
+  });
+
+  // Generate markdown file
+  const md = `# ${id}: ${title}
+
+- **Status:** open
+- **Severity:** ${severity}
+- **Created:** ${entry.created_at}
+- **Related lessons:** ${await findRelatedLessons(description, ctx)}
+
+## Description
+
+${description}
+
+## Root Cause Analysis
+
+<!-- Populated after sentix ticket debug -->
+
+## Resolution
+
+<!-- Populated after fix -->
+`;
+
+  await ctx.writeFile(entry.file_path, md);
+  await addTicket(ctx, entry);
+
+  // Log event
+  await ctx.appendJSONL('tasks/pattern-log.jsonl', {
+    ts: new Date().toISOString(),
+    event: 'ticket:create',
+    id,
+    severity,
+    title,
+  });
+
+  ctx.success(`Created ${id}: ${title}`);
+  ctx.log(`  Severity: ${severity}`);
+  ctx.log(`  File:     ${entry.file_path}`);
+}
+
+// ── sentix ticket list ────────────────────────────────
+
+async function listTickets(args, ctx) {
+  ctx.log('=== Tickets ===\n');
+
+  let entries = await loadIndex(ctx);
+
+  if (entries.length === 0) {
+    ctx.log('  (no tickets)');
+    ctx.log('\n  Create one: sentix ticket create "description"');
+    return;
+  }
+
+  // Parse filters
+  const statusIdx = args.indexOf('--status');
+  if (statusIdx !== -1 && args[statusIdx + 1]) {
+    const status = args[statusIdx + 1];
+    entries = entries.filter(e => e.status === status);
+  }
+
+  const sevIdx = args.indexOf('--severity');
+  if (sevIdx !== -1 && args[sevIdx + 1]) {
+    const sev = args[sevIdx + 1];
+    entries = entries.filter(e => e.severity === sev);
+  }
+
+  entries = sortBySeverity(entries);
+
+  // Table header
+  ctx.log(`  ${'ID'.padEnd(12)} ${'SEVERITY'.padEnd(12)} ${'STATUS'.padEnd(14)} TITLE`);
+  ctx.log(`  ${'─'.repeat(12)} ${'─'.repeat(12)} ${'─'.repeat(14)} ${'─'.repeat(30)}`);
+
+  for (const e of entries) {
+    const sev = e.severity ? e.severity.padEnd(12) : '-'.padEnd(12);
+    ctx.log(`  ${e.id.padEnd(12)} ${sev} ${e.status.padEnd(14)} ${e.title}`);
+  }
+
+  ctx.log(`\n  Total: ${entries.length} ticket(s)`);
+}
+
+// ── sentix ticket debug ───────────────────────────────
+
+async function debugTicket(ticketId, ctx) {
+  // 1. Find ticket
+  const ticket = await findTicket(ctx, ticketId);
+  if (!ticket) {
+    ctx.error(`Ticket not found: ${ticketId}`);
+    return;
+  }
+
+  if (ticket.status !== 'open' && ticket.status !== 'in_progress') {
+    ctx.error(`Ticket ${ticketId} is ${ticket.status} — only open or in_progress tickets can be debugged`);
+    return;
+  }
+
+  // 2. Check Claude Code
+  const claudeCheck = spawnSync('claude', ['--version'], { encoding: 'utf-8', stdio: 'pipe' });
+  if (claudeCheck.error) {
+    ctx.error('Claude Code CLI not found. Install: https://docs.anthropic.com/en/docs/claude-code');
+    return;
+  }
+
+  // 3. Check for concurrent pipeline
+  if (ctx.exists('tasks/governor-state.json')) {
+    try {
+      const existing = await ctx.readJSON('tasks/governor-state.json');
+      if (existing.status === 'in_progress') {
+        ctx.error(`Another pipeline is running: ${existing.cycle_id}`);
+        return;
+      }
+    } catch { /* safe to proceed */ }
+  }
+
+  // 4. Update ticket status
+  await updateTicket(ctx, ticketId, { status: 'in_progress' });
+  ctx.log(`Debugging ${ticketId}: ${ticket.title}`);
+  ctx.log(`Severity: ${ticket.severity}\n`);
+
+  // 5. Read ticket markdown
+  let ticketContent = '';
+  if (ctx.exists(ticket.file_path)) {
+    ticketContent = await ctx.readFile(ticket.file_path);
+  }
+
+  // 6. Read lessons for context
+  let lessons = '';
+  if (ctx.exists('tasks/lessons.md')) {
+    lessons = await ctx.readFile('tasks/lessons.md');
+  }
+
+  // 7. Determine retry limit by severity
+  const retryLimits = { critical: 3, warning: 10, suggestion: 0 };
+  const retryLimit = retryLimits[ticket.severity] || 3;
+
+  // 8. Create governor state
+  const cycleId = `debug-${ticketId}-${String(Date.now()).slice(-3)}`;
+  const state = {
+    schema_version: 1,
+    cycle_id: cycleId,
+    request: `DEBUG: ${ticket.title}`,
+    status: 'in_progress',
+    current_phase: 'dev-fix',
+    plan: [{ agent: 'dev-fix', status: 'running', result_ref: null }],
+    retries: { 'dev-fix': 0 },
+    cross_judgments: [],
+    started_at: new Date().toISOString(),
+    completed_at: null,
+    human_intervention_requested: false,
+    ticket_id: ticketId,
+    ticket_type: 'bug',
+  };
+  await ctx.writeJSON('tasks/governor-state.json', state);
+
+  // 9. Log event
+  await ctx.appendJSONL('tasks/pattern-log.jsonl', {
+    ts: new Date().toISOString(),
+    event: 'ticket:debug',
+    id: ticketId,
+    severity: ticket.severity,
+    cycle_id: cycleId,
+  });
+
+  // 10. Invoke Claude Code with debug prompt
+  const prompt = [
+    'Read CLAUDE.md and FRAMEWORK.md first.',
+    '',
+    `DEBUG MODE — Ticket: ${ticketId}`,
+    '',
+    '## Ticket Content',
+    ticketContent,
+    '',
+    '## Known Lessons',
+    lessons.slice(0, 2000),
+    '',
+    '## Instructions',
+    '1. Analyze the bug described in the ticket',
+    '2. Identify root cause',
+    '3. Implement fix within SCOPE (respect hard rules)',
+    '4. Run tests to verify fix',
+    '5. Generate LESSON_LEARNED and append to tasks/lessons.md',
+    `6. Update ${ticket.file_path} with root cause analysis`,
+    '7. Update tasks/governor-state.json at each phase',
+    '',
+    `Severity: ${ticket.severity} (retry limit: ${retryLimit})`,
+  ].join('\n');
+
+  ctx.log('Invoking Claude Code for debugging...\n');
+
+  const result = spawnSync('claude', ['-p', prompt], {
+    cwd: ctx.cwd,
+    stdio: 'inherit',
+    timeout: 600_000,
+  });
+
+  // 11. Handle result
+  if (result.error || result.status !== 0) {
+    state.status = 'failed';
+    state.error = result.error?.message || `Exit code ${result.status}`;
+    await ctx.writeJSON('tasks/governor-state.json', state);
+
+    await ctx.appendJSONL('tasks/pattern-log.jsonl', {
+      ts: new Date().toISOString(),
+      event: 'ticket:debug:failed',
+      id: ticketId,
+      cycle_id: cycleId,
+      error: state.error,
+    });
+
+    // Escalate critical failures to roadmap
+    if (ticket.severity === 'critical') {
+      ctx.warn('Critical ticket debug failed — escalating to roadmap');
+      if (ctx.exists('tasks/roadmap.md')) {
+        const roadmap = await ctx.readFile('tasks/roadmap.md');
+        const escalation = `\n- **[ESCALATED]** ${ticketId}: ${ticket.title} (debug failed, needs manual review)\n`;
+        await ctx.writeFile('tasks/roadmap.md', roadmap + escalation);
+      }
+    }
+
+    await updateTicket(ctx, ticketId, { status: 'open' });
+    ctx.error(`Debug failed for ${ticketId}`);
+    return;
+  }
+
+  // 12. Success
+  state.status = 'completed';
+  state.completed_at = new Date().toISOString();
+  state.plan[0].status = 'done';
+  await ctx.writeJSON('tasks/governor-state.json', state);
+
+  await updateTicket(ctx, ticketId, {
+    status: 'review',
+    related_cycle: cycleId,
+  });
+
+  await ctx.appendJSONL('tasks/pattern-log.jsonl', {
+    ts: new Date().toISOString(),
+    event: 'ticket:debug:complete',
+    id: ticketId,
+    cycle_id: cycleId,
+  });
+
+  ctx.success(`Debug completed for ${ticketId} — status: review`);
+}
+
+// ── Helpers ───────────────────────────────────────────
+
+async function checkDuplicates(description, ctx) {
+  const candidates = [];
+
+  // Collect from lessons.md
+  if (ctx.exists('tasks/lessons.md')) {
+    const lessons = await ctx.readFile('tasks/lessons.md');
+    const lines = lessons.split('\n').filter(l => l.startsWith('- '));
+    for (const line of lines) {
+      candidates.push(line.replace(/^-\s*/, ''));
+    }
+  }
+
+  // Collect from existing tickets
+  const entries = await loadIndex(ctx);
+  for (const e of entries) {
+    candidates.push(e.title);
+  }
+
+  const match = findBestMatch(description, candidates);
+  if (match) {
+    ctx.warn(`Possible duplicate (${(match.score * 100).toFixed(0)}% similar):`);
+    ctx.warn(`  "${match.text}"`);
+  }
+}
+
+async function findRelatedLessons(description, ctx) {
+  if (!ctx.exists('tasks/lessons.md')) return '(none)';
+
+  const lessons = await ctx.readFile('tasks/lessons.md');
+  const lines = lessons.split('\n').filter(l => l.startsWith('- '));
+
+  const match = findBestMatch(description, lines.map(l => l.replace(/^-\s*/, '')));
+  if (match) return match.text;
+  return '(none)';
+}

package/src/commands/update.js

@@ -0,0 +1,143 @@
+/**
+ * sentix update — 프레임워크 파일을 최신 버전으로 동기화
+ *
+ * sentix 원본 패키지에서 프레임워크 공통 파일을 가져와 로컬 프로젝트를 업데이트한다.
+ * 프로젝트 고유 파일(CLAUDE.md, .sentix/config.toml, providers/, env-profiles/)은 건드리지 않는다.
+ *
+ * 사용법:
+ *   sentix update          # 실제 업데이트
+ *   sentix update --dry    # 변경 사항만 미리 확인
+ */
+
+import { registerCommand } from '../registry.js';
+import { VERSION } from '../version.js';
+import { readFileSync, existsSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const sentixRoot = resolve(__dirname, '..', '..');
+
+// 동기화 대상: 프레임워크 공통 파일 (모든 프로젝트가 동일해야 하는 것)
+const SYNC_FILES = [
+  { src: '.github/workflows/deploy.yml',        dst: '.github/workflows/deploy.yml' },
+  { src: '.github/workflows/security-scan.yml',  dst: '.github/workflows/security-scan.yml' },
+  { src: '.sentix/rules/hard-rules.md',          dst: '.sentix/rules/hard-rules.md' },
+  { src: 'FRAMEWORK.md',                         dst: 'FRAMEWORK.md' },
+  { src: 'docs/governor-sop.md',                 dst: 'docs/governor-sop.md' },
+  { src: 'docs/agent-scopes.md',                 dst: 'docs/agent-scopes.md' },
+  { src: 'docs/severity.md',                     dst: 'docs/severity.md' },
+  { src: 'docs/architecture.md',                 dst: 'docs/architecture.md' },
+];
+
+registerCommand('update', {
+  description: 'Update framework files to the latest sentix version',
+  usage: 'sentix update [--dry]',
+
+  async run(args, ctx) {
+    const dryRun = args.includes('--dry');
+
+    ctx.log(`sentix update v${VERSION}`);
+    ctx.log(`source: ${sentixRoot}`);
+    ctx.log(`target: ${ctx.cwd}`);
+    if (dryRun) ctx.warn('DRY RUN — no files will be changed\n');
+    else ctx.log('');
+
+    // sentix 원본에서 실행 중인지 확인
+    if (resolve(ctx.cwd) === resolve(sentixRoot)) {
+      ctx.error('Cannot update sentix itself. Run this from a downstream project.');
+      return;
+    }
+
+    // sentix가 초기화된 프로젝트인지 확인
+    if (!ctx.exists('.sentix/config.toml') && !ctx.exists('CLAUDE.md')) {
+      ctx.error('This project has not been initialized with sentix.');
+      ctx.log('Run: sentix init');
+      return;
+    }
+
+    const results = { updated: [], created: [], skipped: [], unchanged: [] };
+
+    for (const { src, dst } of SYNC_FILES) {
+      const srcPath = resolve(sentixRoot, src);
+
+      // 원본 파일이 없으면 스킵
+      if (!existsSync(srcPath)) {
+        results.skipped.push({ file: dst, reason: 'source not found' });
+        continue;
+      }
+
+      const srcContent = readFileSync(srcPath, 'utf-8');
+
+      if (ctx.exists(dst)) {
+        const dstContent = await ctx.readFile(dst);
+
+        if (srcContent === dstContent) {
+          results.unchanged.push(dst);
+          continue;
+        }
+
+        // diff 요약 생성
+        const srcLines = srcContent.split('\n');
+        const dstLines = dstContent.split('\n');
+        const added = srcLines.length - dstLines.length;
+
+        ctx.log(`${dryRun ? '[DRY] ' : ''}Updating: ${dst}`);
+        ctx.log(`  ${dstLines.length} lines → ${srcLines.length} lines (${added >= 0 ? '+' : ''}${added})`);
+
+        // 주요 변경 내용 표시 (새로 추가된 라인 중 의미 있는 것)
+        const dstSet = new Set(dstLines.map(l => l.trim()));
+        const newLines = srcLines
+          .filter(l => l.trim() && !l.trim().startsWith('#') && !dstSet.has(l.trim()))
+          .slice(0, 5);
+        if (newLines.length > 0) {
+          ctx.log('  New:');
+          for (const line of newLines) {
+            ctx.log(`    + ${line.trim().substring(0, 80)}`);
+          }
+        }
+
+        if (!dryRun) {
+          await ctx.writeFile(dst, srcContent);
+          ctx.success(`Updated: ${dst}`);
+        }
+        results.updated.push(dst);
+      } else {
+        ctx.log(`${dryRun ? '[DRY] ' : ''}Creating: ${dst}`);
+        if (!dryRun) {
+          await ctx.writeFile(dst, srcContent);
+          ctx.success(`Created: ${dst}`);
+        }
+        results.created.push(dst);
+      }
+    }
+
+    // 요약
+    ctx.log('\n=== Update Summary ===');
+    if (results.updated.length > 0) {
+      ctx.log(`Updated:   ${results.updated.length} file(s)`);
+      for (const f of results.updated) ctx.log(`  ${f}`);
+    }
+    if (results.created.length > 0) {
+      ctx.log(`Created:   ${results.created.length} file(s)`);
+      for (const f of results.created) ctx.log(`  ${f}`);
+    }
+    if (results.unchanged.length > 0) {
+      ctx.log(`Unchanged: ${results.unchanged.length} file(s)`);
+    }
+    if (results.skipped.length > 0) {
+      ctx.warn(`Skipped:   ${results.skipped.length} file(s)`);
+      for (const s of results.skipped) ctx.log(`  ${s.file} (${s.reason})`);
+    }
+
+    const totalChanges = results.updated.length + results.created.length;
+    if (totalChanges === 0) {
+      ctx.success('\nAlready up to date.');
+    } else if (dryRun) {
+      ctx.warn(`\n${totalChanges} file(s) would be changed. Run without --dry to apply.`);
+    } else {
+      ctx.success(`\n${totalChanges} file(s) updated to sentix v${VERSION}.`);
+      ctx.log('Run: sentix doctor  — to verify project health');
+    }
+  },
+});