sentix 2.0.1

package/src/commands/evolve.js

@@ -0,0 +1,203 @@
+/**
+ * sentix evolve — 자기 개선 루프
+ *
+ * sentix가 자기 자신의 코드를 분석하고 개선점을 찾아 티켓을 생성한다.
+ * --auto 플래그를 붙이면 sentix run으로 직접 수정까지 실행한다.
+ *
+ * 사용법:
+ *   sentix evolve           # 분석 + 티켓 생성만
+ *   sentix evolve --auto    # 분석 + 티켓 생성 + sentix run으로 자동 수정
+ */
+
+import { spawnSync } from 'node:child_process';
+import { registerCommand } from '../registry.js';
+import { runGates } from '../lib/verify-gates.js';
+
+registerCommand('evolve', {
+  description: 'Self-analyze and improve (Layer 5)',
+  usage: 'sentix evolve [--auto]',
+
+  async run(args, ctx) {
+    const autoFix = args.includes('--auto');
+    ctx.log('=== Sentix Self-Evolution ===\n');
+
+    const issues = [];
+
+    // ── 1. 테스트 상태 ──────────────────────────────
+    ctx.log('--- Test Health ---\n');
+    const testResult = spawnSync('npm', ['test'], {
+      cwd: ctx.cwd,
+      encoding: 'utf-8',
+      stdio: 'pipe',
+      timeout: 60000,
+    });
+
+    if (testResult.status === 0) {
+      const passMatch = testResult.stdout.match(/# pass (\d+)/);
+      const failMatch = testResult.stdout.match(/# fail (\d+)/);
+      ctx.success(`Tests: ${passMatch?.[1] || '?'} passed, ${failMatch?.[1] || '0'} failed`);
+    } else {
+      ctx.error('Tests: FAILING');
+      issues.push({
+        type: 'bug',
+        severity: 'critical',
+        title: 'Tests are failing',
+        detail: testResult.stderr?.slice(-300) || 'Unknown error',
+      });
+    }
+
+    // ── 2. 검증 게이트 ──────────────────────────────
+    ctx.log('\n--- Verification Gates ---\n');
+    const gates = runGates(ctx.cwd);
+
+    if (gates.passed) {
+      ctx.success(`Gates: ${gates.checks.length}/${gates.checks.length} passed`);
+    } else {
+      for (const v of gates.violations) {
+        ctx.warn(`Gate violation: [${v.rule}] ${v.message}`);
+        issues.push({
+          type: 'bug',
+          severity: 'warning',
+          title: `Gate violation: ${v.rule}`,
+          detail: v.message,
+        });
+      }
+    }
+
+    // ── 3. Doctor 체크 ──────────────────────────────
+    ctx.log('\n--- Doctor ---\n');
+
+    const requiredFiles = [
+      'CLAUDE.md', 'FRAMEWORK.md', '.sentix/config.toml',
+      '.sentix/rules/hard-rules.md', 'tasks/lessons.md',
+      'docs/governor-sop.md', 'docs/architecture.md',
+    ];
+
+    for (const file of requiredFiles) {
+      if (!ctx.exists(file)) {
+        ctx.warn(`Missing: ${file}`);
+        issues.push({
+          type: 'bug',
+          severity: 'suggestion',
+          title: `Missing file: ${file}`,
+          detail: `Required file ${file} does not exist`,
+        });
+      }
+    }
+
+    if (requiredFiles.every(f => ctx.exists(f))) {
+      ctx.success('All required files present');
+    }
+
+    // ── 4. 코드 품질 (간이 분석) ────────────────────
+    ctx.log('\n--- Code Quality ---\n');
+
+    // 큰 파일 탐지
+    const { readdirSync, statSync } = await import('node:fs');
+    const { resolve, join } = await import('node:path');
+
+    const bigFiles = [];
+    function scanDir(dir, prefix = '') {
+      try {
+        const entries = readdirSync(resolve(ctx.cwd, dir), { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+          const relPath = join(prefix, entry.name);
+          if (entry.isDirectory()) {
+            scanDir(join(dir, entry.name), relPath);
+          } else if (entry.name.endsWith('.js')) {
+            const stat = statSync(resolve(ctx.cwd, dir, entry.name));
+            const lines = Math.round(stat.size / 40); // 대략적 줄 수
+            if (lines > 300) {
+              bigFiles.push({ path: relPath, lines });
+            }
+          }
+        }
+      } catch { /* 접근 불가 디렉토리 무시 */ }
+    }
+
+    scanDir('src');
+    scanDir('bin');
+
+    if (bigFiles.length > 0) {
+      for (const f of bigFiles) {
+        ctx.warn(`Large file: ${f.path} (~${f.lines} lines) — consider splitting`);
+        issues.push({
+          type: 'feature',
+          severity: 'suggestion',
+          title: `Refactor: ${f.path} is too large (~${f.lines} lines)`,
+          detail: `Consider splitting into smaller modules`,
+        });
+      }
+    } else {
+      ctx.success('No oversized files');
+    }
+
+    // ── 5. 학습 파일 상태 ───────────────────────────
+    ctx.log('\n--- Learning Health ---\n');
+
+    if (ctx.exists('tasks/lessons.md')) {
+      const lessons = await ctx.readFile('tasks/lessons.md');
+      const lessonCount = (lessons.match(/^##/gm) || []).length;
+      ctx.log(`  Lessons: ${lessonCount} entries`);
+    }
+
+    if (ctx.exists('tasks/agent-metrics.jsonl')) {
+      const metrics = await ctx.readFile('tasks/agent-metrics.jsonl');
+      const lineCount = metrics.trim().split('\n').filter(Boolean).length;
+      ctx.log(`  Metrics: ${lineCount} records`);
+    } else {
+      ctx.log('  Metrics: (empty — run sentix run to collect)');
+    }
+
+    // ── 결과 요약 ───────────────────────────────────
+    ctx.log('\n=== Evolution Summary ===\n');
+
+    if (issues.length === 0) {
+      ctx.success('No issues found. Sentix is in good shape.');
+      return;
+    }
+
+    ctx.log(`Found ${issues.length} issue(s):\n`);
+
+    const critical = issues.filter(i => i.severity === 'critical');
+    const warnings = issues.filter(i => i.severity === 'warning');
+    const suggestions = issues.filter(i => i.severity === 'suggestion');
+
+    if (critical.length > 0) {
+      ctx.error(`  Critical: ${critical.length}`);
+      for (const i of critical) ctx.log(`    - ${i.title}`);
+    }
+    if (warnings.length > 0) {
+      ctx.warn(`  Warning: ${warnings.length}`);
+      for (const i of warnings) ctx.log(`    - ${i.title}`);
+    }
+    if (suggestions.length > 0) {
+      ctx.log(`  Suggestion: ${suggestions.length}`);
+      for (const i of suggestions) ctx.log(`    - ${i.title}`);
+    }
+
+    // ── 티켓 생성 ───────────────────────────────────
+    if (critical.length > 0 || warnings.length > 0) {
+      ctx.log('');
+      for (const issue of [...critical, ...warnings]) {
+        const cmdType = issue.type === 'feature' ? 'feature add' : 'ticket create';
+        const severityFlag = issue.severity === 'critical' ? ' --severity critical' : '';
+        ctx.log(`  → sentix ${cmdType} "${issue.title}"${severityFlag}`);
+      }
+
+      // --auto: 가장 심각한 이슈를 sentix run으로 자동 수정
+      if (autoFix && critical.length > 0) {
+        ctx.log('\n--- Auto-fix (critical issues) ---\n');
+        const firstIssue = critical[0];
+
+        ctx.log(`Running: sentix run "${firstIssue.title}"\n`);
+        spawnSync('node', ['bin/sentix.js', 'run', firstIssue.title], {
+          cwd: ctx.cwd,
+          stdio: 'inherit',
+          timeout: 600_000,
+        });
+      }
+    }
+  },
+});

package/src/commands/feature.js

@@ -0,0 +1,327 @@
+/**
+ * sentix feature — 기능 추가 워크플로우
+ *
+ * sentix feature add "설명"            — 기능 티켓 생성 + Governor 파이프라인 실행
+ * sentix feature list [--status open]  — 기능 목록
+ * sentix feature impact <id|"설명">     — 영향 분석
+ */
+
+import { registerCommand } from '../registry.js';
+import {
+  loadIndex, addTicket, nextTicketId, createTicketEntry, findTicket,
+} from '../lib/ticket-index.js';
+
+registerCommand('feature', {
+  description: 'Manage feature development (add | list | impact)',
+  usage: 'sentix feature <add|list|impact> [args...]',
+
+  async run(args, ctx) {
+    const subcommand = args[0];
+
+    if (subcommand === 'add') {
+      await addFeature(args.slice(1), ctx);
+    } else if (!subcommand || subcommand === 'list') {
+      await listFeatures(args.slice(1), ctx);
+    } else if (subcommand === 'impact') {
+      await analyzeImpact(args.slice(1), ctx);
+    } else {
+      ctx.error(`Unknown subcommand: ${subcommand}`);
+      ctx.log('Usage: sentix feature <add|list|impact> [args...]');
+    }
+  },
+});
+
+// ── Complexity keywords ───────────────────────────────
+
+const COMPLEXITY_KEYWORDS = {
+  high: ['api', 'database', 'auth', 'migration', 'multi-tenant', 'real-time', 'websocket', 'oauth', '인증', '데이터베이스', '마이그레이션'],
+  medium: ['form', 'validation', 'upload', 'notification', 'cache', 'filter', 'search', '폼', '알림', '캐시'],
+};
+
+function assessComplexity(description) {
+  const lower = description.toLowerCase();
+  let score = 0;
+
+  for (const keyword of COMPLEXITY_KEYWORDS.high) {
+    if (lower.includes(keyword)) score += 2;
+  }
+  for (const keyword of COMPLEXITY_KEYWORDS.medium) {
+    if (lower.includes(keyword)) score += 1;
+  }
+
+  // Multiple systems mentioned
+  if ((lower.match(/\band\b|,\s*\w+/g) || []).length >= 2) score += 2;
+
+  if (score >= 4) return 'high';
+  if (score >= 2) return 'medium';
+  return 'low';
+}
+
+// ── sentix feature add ────────────────────────────────
+
+async function addFeature(args, ctx) {
+  const description = args.join(' ').trim();
+  if (!description) {
+    ctx.error('Usage: sentix feature add "feature description"');
+    return;
+  }
+
+  const complexity = assessComplexity(description);
+  const id = await nextTicketId(ctx, 'feat');
+  const title = description.length > 80 ? description.slice(0, 77) + '...' : description;
+
+  ctx.log(`Feature: ${title}`);
+  ctx.log(`Complexity: ${complexity}\n`);
+
+  // Impact analysis
+  const impact = await getImpactData(description, ctx);
+
+  // Create ticket entry
+  const entry = createTicketEntry({
+    id,
+    type: 'feature',
+    title,
+    severity: null,
+    description,
+  });
+
+  // Generate markdown
+  const md = `# ${id}: ${title}
+
+- **Status:** open
+- **Complexity:** ${complexity}
+- **Deploy flag:** ${impact.deployFlag}
+- **Security flag:** ${impact.securityFlag}
+- **Created:** ${entry.created_at}
+
+## Description
+
+${description}
+
+## Impact Analysis
+
+${impact.summary}
+
+## Decomposition
+
+${complexity === 'high' ? generateDecomposition(description) : '<!-- N/A — low/medium complexity -->'}
+
+## Acceptance Criteria
+
+<!-- Populated by planner agent -->
+`;
+
+  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: 'feature:add',
+    id,
+    complexity,
+    title,
+  });
+
+  ctx.success(`Created ${id}: ${title}`);
+  ctx.log(`  Complexity:     ${complexity}`);
+  ctx.log(`  Deploy flag:    ${impact.deployFlag}`);
+  ctx.log(`  Security flag:  ${impact.securityFlag}`);
+  ctx.log(`  File:           ${entry.file_path}`);
+  ctx.log('');
+  ctx.log('Governor: proceed with FEATURE pipeline using this ticket.');
+}
+
+// ── sentix feature list ───────────────────────────────
+
+async function listFeatures(args, ctx) {
+  ctx.log('=== Features ===\n');
+
+  let entries = await loadIndex(ctx);
+  entries = entries.filter(e => e.type === 'feature');
+
+  // Parse --status filter
+  const statusIdx = args.indexOf('--status');
+  if (statusIdx !== -1 && args[statusIdx + 1]) {
+    const status = args[statusIdx + 1];
+    entries = entries.filter(e => e.status === status);
+  }
+
+  if (entries.length === 0) {
+    ctx.log('  (no features)');
+    ctx.log('\n  Create one: sentix feature add "description"');
+    return;
+  }
+
+  // Read complexity from ticket files
+  ctx.log(`  ${'ID'.padEnd(12)} ${'COMPLEXITY'.padEnd(12)} ${'STATUS'.padEnd(14)} TITLE`);
+  ctx.log(`  ${'─'.repeat(12)} ${'─'.repeat(12)} ${'─'.repeat(14)} ${'─'.repeat(30)}`);
+
+  for (const e of entries) {
+    let complexity = '-';
+    if (ctx.exists(e.file_path)) {
+      try {
+        const content = await ctx.readFile(e.file_path);
+        const match = content.match(/\*\*Complexity:\*\*\s*(\w+)/);
+        if (match) complexity = match[1];
+      } catch { /* use default */ }
+    }
+    ctx.log(`  ${e.id.padEnd(12)} ${complexity.padEnd(12)} ${e.status.padEnd(14)} ${e.title}`);
+  }
+
+  ctx.log(`\n  Total: ${entries.length} feature(s)`);
+}
+
+// ── sentix feature impact ─────────────────────────────
+
+async function analyzeImpact(args, ctx) {
+  const input = args.join(' ').trim();
+  if (!input) {
+    ctx.error('Usage: sentix feature impact <feature-id | "description">');
+    return;
+  }
+
+  // Resolve description: check if it's a ticket ID first
+  let description = input;
+  const ticket = await findTicket(ctx, input);
+  if (ticket && ctx.exists(ticket.file_path)) {
+    const content = await ctx.readFile(ticket.file_path);
+    const descMatch = content.match(/## Description\n\n([\s\S]*?)(?=\n## |\n$)/);
+    if (descMatch) description = descMatch[1].trim();
+  }
+
+  ctx.log('=== Impact Analysis ===\n');
+
+  const impact = await getImpactData(description, ctx);
+
+  ctx.log(impact.summary);
+  ctx.log('');
+  ctx.log('--- Flags ---');
+  ctx.log(`  DEPLOY_FLAG:   ${impact.deployFlag}`);
+  ctx.log(`  SECURITY_FLAG: ${impact.securityFlag}`);
+  ctx.log('');
+
+  const complexity = assessComplexity(description);
+  ctx.log(`  Recommendation: COMPLEXITY ${complexity}`);
+  if (impact.securityFlag) {
+    ctx.log('  → Run with security pre-analysis');
+  }
+
+  // Log event
+  await ctx.appendJSONL('tasks/pattern-log.jsonl', {
+    ts: new Date().toISOString(),
+    event: 'feature:impact',
+    input,
+    deploy_flag: impact.deployFlag,
+    security_flag: impact.securityFlag,
+  });
+}
+
+// ── Impact analysis engine ────────────────────────────
+
+async function getImpactData(description, ctx) {
+  const lower = description.toLowerCase();
+  const lines = [];
+  let deployFlag = false;
+  let securityFlag = false;
+
+  // Check INTERFACE.md for affected APIs
+  if (ctx.exists('INTERFACE.md')) {
+    try {
+      const iface = await ctx.readFile('INTERFACE.md');
+
+      // Extract exported API entries
+      const apiSection = iface.match(/## Exported APIs[\s\S]*?(?=\n## |$)/);
+      if (apiSection) {
+        const apis = apiSection[0].match(/(?:GET|POST|PUT|DELETE|PATCH)\s+\S+/g) || [];
+        const affected = [];
+        for (const api of apis) {
+          const endpoint = api.split(/\s+/)[1];
+          const parts = endpoint.split('/').filter(Boolean);
+          if (parts.some(p => lower.includes(p.toLowerCase()))) {
+            affected.push(api);
+          }
+        }
+        if (affected.length > 0) {
+          lines.push('Affected APIs:');
+          for (const api of affected) {
+            lines.push(`  - ${api} (INTERFACE.md)`);
+          }
+          deployFlag = true;
+        }
+      }
+    } catch { /* non-critical */ }
+  }
+
+  // Check registry.md for downstream projects
+  if (ctx.exists('registry.md')) {
+    try {
+      const registry = await ctx.readFile('registry.md');
+      // Parse markdown table rows (skip header and separator)
+      const rows = registry.split('\n').filter(l => l.startsWith('|') && !l.includes('---'));
+      const downstream = [];
+
+      for (const row of rows) {
+        const cells = row.split('|').map(c => c.trim()).filter(Boolean);
+        const name = cells[0];
+        if (name && name !== '프로젝트' && name !== 'Project') {
+          downstream.push(name);
+        }
+      }
+
+      if (downstream.length > 0) {
+        lines.push('');
+        lines.push('Downstream projects in registry:');
+        for (const proj of downstream) {
+          lines.push(`  - ${proj}`);
+        }
+      }
+    } catch { /* non-critical */ }
+  }
+
+  // Keyword-based flag detection
+  const securityKeywords = ['auth', 'login', 'session', 'token', 'password', 'permission', 'role', 'oauth', 'jwt', '인증', '세션', '권한'];
+  const deployKeywords = ['api', 'endpoint', 'route', 'schema', 'migration', 'database', 'config'];
+
+  if (securityKeywords.some(k => lower.includes(k))) {
+    securityFlag = true;
+    lines.push('');
+    lines.push('Security-related keywords detected → security pre-analysis recommended');
+  }
+
+  if (deployKeywords.some(k => lower.includes(k))) {
+    deployFlag = true;
+  }
+
+  if (lines.length === 0) {
+    lines.push('No direct API or downstream impact detected.');
+    lines.push('Standard development pipeline recommended.');
+  }
+
+  return {
+    summary: lines.join('\n'),
+    deployFlag,
+    securityFlag,
+  };
+}
+
+// ── Feature decomposition for high complexity ─────────
+
+function generateDecomposition(description) {
+  // Split at logical boundaries
+  const parts = description
+    .split(/(?:,\s*(?:and\s+)?|;\s*|\band\b\s+)/i)
+    .map(p => p.trim())
+    .filter(p => p.length > 3);
+
+  if (parts.length <= 1) {
+    return '<!-- Governor planner will decompose this feature -->';
+  }
+
+  const lines = ['PARALLEL_HINT (preliminary — planner will refine):', ''];
+  parts.forEach((part, i) => {
+    lines.push(`- Sub-task ${i + 1}: ${part}`);
+  });
+
+  return lines.join('\n');
+}