sentix 2.0.1

package/src/lib/api-client.js

@@ -0,0 +1,213 @@
+/**
+ * api-client.js — AI API 클라이언트 (제로 의존성)
+ *
+ * Node.js 내장 fetch로 Anthropic/OpenAI/Ollama API를 호출.
+ * Engine mode에서만 사용됨.
+ */
+
+/**
+ * 프로바이더 설정으로 API 클라이언트 생성
+ * @param {object} provider - loadProvider() 결과
+ * @returns {object} { chat(messages, tools) }
+ */
+export function createClient(provider) {
+  switch (provider.name) {
+    case 'claude': return createAnthropicClient(provider);
+    case 'openai': return createOpenAIClient(provider);
+    case 'ollama': return createOllamaClient(provider);
+    default: throw new Error(`Unknown provider: ${provider.name}`);
+  }
+}
+
+// ── Anthropic (Claude API) ────────────────────────────
+
+function createAnthropicClient(provider) {
+  const { api_key, base_url, model } = provider.api;
+  const url = (base_url || 'https://api.anthropic.com') + '/v1/messages';
+
+  return {
+    name: 'claude',
+    async chat(systemPrompt, messages, tools = []) {
+      const body = {
+        model: model || 'claude-sonnet-4-20250514',
+        max_tokens: 16384,
+        system: systemPrompt,
+        messages,
+      };
+
+      if (tools.length > 0) {
+        body.tools = tools.map(t => ({
+          name: t.name,
+          description: t.description,
+          input_schema: t.parameters,
+        }));
+      }
+
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'x-api-key': api_key,
+          'anthropic-version': '2023-06-01',
+        },
+        body: JSON.stringify(body),
+      });
+
+      if (!res.ok) {
+        const error = await res.text();
+        throw new Error(`Anthropic API error (${res.status}): ${error.slice(0, 200)}`);
+      }
+
+      const data = await res.json();
+      return parseAnthropicResponse(data);
+    },
+  };
+}
+
+function parseAnthropicResponse(data) {
+  const content = [];
+  const toolCalls = [];
+
+  for (const block of data.content || []) {
+    if (block.type === 'text') {
+      content.push(block.text);
+    } else if (block.type === 'tool_use') {
+      toolCalls.push({
+        id: block.id,
+        name: block.name,
+        arguments: block.input,
+      });
+    }
+  }
+
+  return {
+    content: content.join('\n'),
+    tool_calls: toolCalls,
+    stop_reason: data.stop_reason,
+    usage: data.usage,
+  };
+}
+
+// ── OpenAI ────────────────────────────────────────────
+
+function createOpenAIClient(provider) {
+  const { api_key, base_url, model } = provider.api;
+  const url = (base_url || 'https://api.openai.com/v1') + '/chat/completions';
+
+  return {
+    name: 'openai',
+    async chat(systemPrompt, messages, tools = []) {
+      const body = {
+        model: model || 'gpt-4o',
+        messages: [
+          { role: 'system', content: systemPrompt },
+          ...messages,
+        ],
+        max_tokens: 16384,
+      };
+
+      if (tools.length > 0) {
+        body.tools = tools.map(t => ({
+          type: 'function',
+          function: {
+            name: t.name,
+            description: t.description,
+            parameters: t.parameters,
+          },
+        }));
+      }
+
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${api_key}`,
+        },
+        body: JSON.stringify(body),
+      });
+
+      if (!res.ok) {
+        const error = await res.text();
+        throw new Error(`OpenAI API error (${res.status}): ${error.slice(0, 200)}`);
+      }
+
+      const data = await res.json();
+      return parseOpenAIResponse(data);
+    },
+  };
+}
+
+function parseOpenAIResponse(data) {
+  const choice = data.choices?.[0];
+  const msg = choice?.message || {};
+  const toolCalls = (msg.tool_calls || []).map(tc => ({
+    id: tc.id,
+    name: tc.function.name,
+    arguments: JSON.parse(tc.function.arguments || '{}'),
+  }));
+
+  return {
+    content: msg.content || '',
+    tool_calls: toolCalls,
+    stop_reason: choice?.finish_reason,
+    usage: data.usage,
+  };
+}
+
+// ── Ollama ────────────────────────────────────────────
+
+function createOllamaClient(provider) {
+  const { base_url, model } = provider.api;
+  const url = (base_url || 'http://localhost:11434') + '/api/chat';
+
+  return {
+    name: 'ollama',
+    async chat(systemPrompt, messages, tools = []) {
+      const body = {
+        model: model || 'qwen2.5-coder:32b',
+        messages: [
+          { role: 'system', content: systemPrompt },
+          ...messages,
+        ],
+        stream: false,
+      };
+
+      if (tools.length > 0) {
+        body.tools = tools.map(t => ({
+          type: 'function',
+          function: {
+            name: t.name,
+            description: t.description,
+            parameters: t.parameters,
+          },
+        }));
+      }
+
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+      });
+
+      if (!res.ok) {
+        const error = await res.text();
+        throw new Error(`Ollama API error (${res.status}): ${error.slice(0, 200)}`);
+      }
+
+      const data = await res.json();
+      const msg = data.message || {};
+      const toolCalls = (msg.tool_calls || []).map(tc => ({
+        id: `ollama-${Date.now()}`,
+        name: tc.function.name,
+        arguments: tc.function.arguments || {},
+      }));
+
+      return {
+        content: msg.content || '',
+        tool_calls: toolCalls,
+        stop_reason: data.done ? 'end_turn' : 'tool_use',
+        usage: { input_tokens: data.prompt_eval_count, output_tokens: data.eval_count },
+      };
+    },
+  };
+}

package/src/lib/changelog.js

@@ -0,0 +1,110 @@
+/**
+ * CHANGELOG.md auto-generation from governor history and ticket index.
+ *
+ * Matches existing format:
+ *   ## [x.y.z] — YYYY-MM-DD
+ *   ### Category
+ *   - entry
+ */
+
+import { loadIndex } from './ticket-index.js';
+
+/**
+ * Build changelog entries from resolved tickets since last version.
+ */
+export async function buildFromTickets(ctx) {
+  const entries = await loadIndex(ctx);
+  const resolved = entries.filter(e =>
+    e.status === 'resolved' || e.status === 'closed'
+  );
+
+  const categories = {
+    'New Features': [],
+    'Bug Fixes': [],
+    'Security Fixes': [],
+    'Improvements': [],
+  };
+
+  for (const ticket of resolved) {
+    const line = `- \`${ticket.id}\`: ${ticket.title}`;
+    if (ticket.type === 'feature') {
+      categories['New Features'].push(line);
+    } else if (ticket.severity === 'critical' && ticket.title.toLowerCase().includes('security')) {
+      categories['Security Fixes'].push(line);
+    } else if (ticket.type === 'bug') {
+      categories['Bug Fixes'].push(line);
+    } else {
+      categories['Improvements'].push(line);
+    }
+  }
+
+  return categories;
+}
+
+/**
+ * Generate a formatted changelog entry string.
+ */
+export function generateChangelogEntry(version, date, categories) {
+  const lines = [`## [${version}] — ${date}`, ''];
+
+  for (const [category, items] of Object.entries(categories)) {
+    if (items.length > 0) {
+      lines.push(`### ${category}`, '');
+      for (const item of items) {
+        lines.push(item);
+      }
+      lines.push('');
+    }
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Prepend a new entry to CHANGELOG.md, preserving existing content.
+ */
+export async function prependToChangelog(ctx, entry) {
+  let existing = '';
+  if (ctx.exists('CHANGELOG.md')) {
+    existing = await ctx.readFile('CHANGELOG.md');
+  }
+
+  // Insert after the "# Changelog" header line
+  const headerLine = '# Changelog';
+  const headerIdx = existing.indexOf(headerLine);
+
+  let content;
+  if (headerIdx !== -1) {
+    const afterHeader = headerIdx + headerLine.length;
+    content = existing.slice(0, afterHeader) + '\n\n' + entry + '\n---\n' + existing.slice(afterHeader).replace(/^\n+/, '\n');
+  } else {
+    content = `${headerLine}\n\n${entry}\n---\n\n${existing}`;
+  }
+
+  await ctx.writeFile('CHANGELOG.md', content);
+}
+
+/**
+ * Generate a changelog entry from governor-state + tickets for a given version.
+ */
+export async function generateForVersion(ctx, version) {
+  const date = new Date().toISOString().slice(0, 10);
+  const categories = await buildFromTickets(ctx);
+
+  // Also check governor-state for the latest request
+  if (ctx.exists('tasks/governor-state.json')) {
+    try {
+      const state = await ctx.readJSON('tasks/governor-state.json');
+      if (state.status === 'completed' && state.request) {
+        const line = `- ${state.request} (cycle: ${state.cycle_id})`;
+        if (!Object.values(categories).flat().length) {
+          categories['Improvements'].push(line);
+        }
+      }
+    } catch {
+      // Non-critical
+    }
+  }
+
+  return generateChangelogEntry(version, date, categories);
+}

package/src/lib/pipeline.js

@@ -0,0 +1,218 @@
+/**
+ * pipeline.js — Framework mode 체인 파이프라인
+ *
+ * sentix run을 단일 Claude Code 호출이 아닌 multi-phase 체인으로 실행.
+ * 각 phase 사이에 검증 게이트와 테스트를 실행하여 단계별 신뢰를 쌓는다.
+ *
+ * Phase 구조:
+ *   1. PLAN — 티켓 생성 + 실행 계획
+ *   2. DEV — 코드 구현 + 테스트 작성
+ *   [gate: verify-gates + npm test]
+ *   3. REVIEW — 자체 리뷰 + 수정
+ *   [gate: verify-gates]
+ *   4. FINALIZE — 버전/학습/README 업데이트
+ */
+
+import { spawnSync } from 'node:child_process';
+import { runGates } from './verify-gates.js';
+
+/**
+ * 체인 파이프라인 실행 (Framework mode)
+ * @param {string} request - 사용자 요청
+ * @param {string} cycleId - 사이클 ID
+ * @param {object} state - governor-state.json
+ * @param {object} ctx - sentix context
+ * @param {object} options - { safetyDirective }
+ * @returns {object} { success, phases, gateResults }
+ */
+export async function runChainedPipeline(request, cycleId, state, ctx, options = {}) {
+  const phases = [];
+  const startTime = Date.now();
+
+  // lessons.md, patterns.md 로드 (있으면)
+  const lessons = ctx.exists('tasks/lessons.md')
+    ? await ctx.readFile('tasks/lessons.md')
+    : '';
+  const patterns = ctx.exists('tasks/patterns.md')
+    ? await ctx.readFile('tasks/patterns.md')
+    : '';
+
+  const learningContext = [
+    lessons.trim() ? `\n--- lessons.md ---\n${lessons.slice(0, 2000)}` : '',
+    patterns.trim() ? `\n--- patterns.md ---\n${patterns.slice(0, 1000)}` : '',
+  ].filter(Boolean).join('\n');
+
+  // ── Phase 1: PLAN ─────────────────────────────────
+  ctx.log('=== Phase 1: PLAN ===\n');
+  state.current_phase = 'plan';
+  await ctx.writeJSON('tasks/governor-state.json', state);
+
+  const planResult = runPhase('plan', [
+    'Read CLAUDE.md first.',
+    options.safetyDirective || '',
+    'You are the PLANNER agent. Your ONLY job is:',
+    `1. Analyze this request: "${request}"`,
+    '2. Create a ticket in tasks/tickets/ using: node bin/sentix.js ticket create "..." or node bin/sentix.js feature add "..."',
+    '3. List the specific files that need to be changed (SCOPE)',
+    '4. Estimate complexity (low/medium/high)',
+    '5. DO NOT write any code. ONLY plan.',
+    learningContext,
+  ].filter(Boolean).join('\n'), ctx);
+
+  phases.push({ name: 'plan', ...planResult });
+  if (!planResult.success) {
+    return { success: false, phases, failedAt: 'plan' };
+  }
+
+  // ── Phase 2: DEV ──────────────────────────────────
+  ctx.log('\n=== Phase 2: DEV ===\n');
+  state.current_phase = 'dev';
+  await ctx.writeJSON('tasks/governor-state.json', state);
+
+  // 가장 최근 티켓 찾기 (planner가 방금 생성한 것)
+  const latestTicket = await getLatestTicket(ctx);
+
+  const devResult = runPhase('dev', [
+    'Read CLAUDE.md first.',
+    options.safetyDirective || '',
+    'You are the DEV agent. Your job:',
+    latestTicket ? `Ticket:\n${latestTicket}` : `Request: "${request}"`,
+    '',
+    '1. Implement the changes described in the ticket',
+    '2. Write or update tests',
+    '3. Run: npm test — ensure all tests pass',
+    '4. Self-verify: check hard rules (no export deletion, no test deletion, scope compliance, <50 net deletions)',
+    '5. DO NOT update version, README, or CHANGELOG — that is the FINALIZE phase',
+    learningContext,
+  ].filter(Boolean).join('\n'), ctx);
+
+  phases.push({ name: 'dev', ...devResult });
+  if (!devResult.success) {
+    return { success: false, phases, failedAt: 'dev' };
+  }
+
+  // ── Mid-pipeline gate: test + verify ──────────────
+  ctx.log('\n=== Gate: Post-DEV Verification ===\n');
+
+  // Auto-run tests
+  const testResult = spawnSync('npm', ['test'], {
+    cwd: ctx.cwd,
+    encoding: 'utf-8',
+    stdio: 'pipe',
+    timeout: 60_000,
+  });
+
+  if (testResult.status === 0) {
+    ctx.success('Tests passed');
+  } else {
+    ctx.warn('Tests failed — REVIEW phase will address this');
+    ctx.log(testResult.stdout?.slice(-500) || '');
+  }
+
+  // Verify gates
+  const midGate = runGates(ctx.cwd);
+  for (const check of midGate.checks) {
+    if (check.passed) {
+      ctx.success(`[${check.rule}] ${check.detail}`);
+    } else {
+      ctx.warn(`[${check.rule}] ${check.detail}`);
+    }
+  }
+
+  const midGateInfo = midGate.passed
+    ? 'All verification gates passed.'
+    : `Gate violations: ${midGate.violations.map(v => v.message).join('; ')}`;
+
+  // ── Phase 3: REVIEW ───────────────────────────────
+  ctx.log('\n=== Phase 3: REVIEW ===\n');
+  state.current_phase = 'review';
+  await ctx.writeJSON('tasks/governor-state.json', state);
+
+  const reviewResult = runPhase('review', [
+    'Read CLAUDE.md first.',
+    'You are the PR-REVIEW agent. Your job:',
+    '',
+    `Test results: ${testResult.status === 0 ? 'ALL PASSED' : 'SOME FAILED — fix them'}`,
+    `Verification gates: ${midGateInfo}`,
+    '',
+    '1. Review the git diff (run: git diff)',
+    '2. If tests failed, fix the failing tests (fix code, not tests)',
+    '3. If gate violations exist, fix them',
+    '4. Ensure code quality and hard rule compliance',
+    '5. Run: npm test — confirm all pass after fixes',
+  ].join('\n'), ctx);
+
+  phases.push({ name: 'review', ...reviewResult });
+
+  // ── Phase 4: FINALIZE ─────────────────────────────
+  ctx.log('\n=== Phase 4: FINALIZE ===\n');
+  state.current_phase = 'finalize';
+  await ctx.writeJSON('tasks/governor-state.json', state);
+
+  const finalResult = runPhase('finalize', [
+    'Read CLAUDE.md first.',
+    'You are finalizing this work cycle. Your job:',
+    '',
+    '1. If any lessons were learned (failures, retries), add them to tasks/lessons.md',
+    '2. If README.md needs updating (new features, changed commands), update it',
+    '3. Create a clear git commit with the changes',
+    '4. Report what was done',
+  ].join('\n'), ctx);
+
+  phases.push({ name: 'finalize', ...finalResult });
+
+  // ── Final gate ────────────────────────────────────
+  const finalGate = runGates(ctx.cwd);
+
+  return {
+    success: true,
+    phases,
+    gateResults: finalGate,
+    duration_seconds: Math.round((Date.now() - startTime) / 1000),
+    test_passed: testResult.status === 0,
+  };
+}
+
+// ── Phase 실행 ────────────────────────────────────────
+
+function runPhase(name, prompt, ctx) {
+  const result = spawnSync('claude', ['-p', prompt], {
+    cwd: ctx.cwd,
+    stdio: 'inherit',
+    timeout: 300_000, // 5분 per phase (전체 10분 대신)
+  });
+
+  if (result.error) {
+    ctx.error(`Phase ${name} failed: ${result.error.message}`);
+    return { success: false, error: result.error.message, exit_code: null };
+  }
+
+  if (result.status !== 0) {
+    ctx.error(`Phase ${name} exited with code ${result.status}`);
+    return { success: false, error: `exit code ${result.status}`, exit_code: result.status };
+  }
+
+  ctx.success(`Phase ${name} completed`);
+  return { success: true, error: null, exit_code: 0 };
+}
+
+// ── 최근 티켓 내용 가져오기 ───────────────────────────
+
+async function getLatestTicket(ctx) {
+  if (!ctx.exists('tasks/tickets/index.json')) return null;
+
+  try {
+    const index = await ctx.readJSON('tasks/tickets/index.json');
+    if (index.length === 0) return null;
+
+    const latest = index[index.length - 1];
+    const ticketPath = `tasks/tickets/${latest.id}.md`;
+    if (ctx.exists(ticketPath)) {
+      return await ctx.readFile(ticketPath);
+    }
+  } catch {
+    // 인덱스 파싱 실패 — 무시
+  }
+
+  return null;
+}

package/src/lib/provider.js

@@ -0,0 +1,129 @@
+/**
+ * provider.js — 프로바이더 설정 로더
+ *
+ * .sentix/config.toml에서 runtime mode와 provider 설정을 읽고,
+ * .sentix/providers/{name}.toml에서 API 설정을 로드한다.
+ *
+ * 간이 TOML 파서 포함 (sentix 서브셋만 지원, 외부 의존성 없음).
+ */
+
+/**
+ * 런타임 모드 가져오기 (config.toml → [runtime].mode)
+ * @param {object} ctx
+ * @returns {Promise<string>} 'framework' | 'engine'
+ */
+export async function getRuntimeMode(ctx) {
+  if (!ctx.exists('.sentix/config.toml')) return 'framework';
+  const config = parseToml(await ctx.readFile('.sentix/config.toml'));
+  return config.runtime?.mode || 'framework';
+}
+
+/**
+ * 프로바이더 설정 로드
+ * @param {object} ctx
+ * @returns {Promise<object>} { name, type, api, limits }
+ */
+export async function loadProvider(ctx) {
+  const config = parseToml(await ctx.readFile('.sentix/config.toml'));
+  const providerName = config.provider?.default || 'claude';
+  const providerPath = `.sentix/providers/${providerName}.toml`;
+
+  if (!ctx.exists(providerPath)) {
+    throw new Error(`Provider config not found: ${providerPath}`);
+  }
+
+  const providerConfig = parseToml(await ctx.readFile(providerPath));
+
+  // API 키 환경변수 검증
+  const apiKeyEnv = providerConfig.api?.api_key_env;
+  const apiKey = apiKeyEnv ? process.env[apiKeyEnv] : null;
+
+  return {
+    name: providerName,
+    type: providerConfig.provider?.type || 'cli',
+    api: {
+      base_url: providerConfig.api?.base_url || '',
+      api_key: apiKey,
+      api_key_env: apiKeyEnv || '',
+      model: providerConfig.api?.model || '',
+    },
+    limits: {
+      max_parallel: parseInt(providerConfig.limits?.max_parallel_agents) || 4,
+      timeout_seconds: parseInt(providerConfig.limits?.timeout_seconds) || 600,
+      max_retries: parseInt(providerConfig.limits?.max_retries) || 3,
+    },
+  };
+}
+
+// ── 간이 TOML 파서 (sentix 서브셋) ──────────────────
+
+/**
+ * sentix에서 사용하는 TOML 서브셋만 파싱.
+ * 지원: [section], [section.sub], key = "value", key = number, key = true/false
+ * 미지원: 인라인 테이블, 배열, 멀티라인 문자열
+ */
+export function parseToml(content) {
+  const result = {};
+  let currentSection = null;
+
+  for (const rawLine of content.split('\n')) {
+    const line = rawLine.trim();
+
+    // 빈 줄, 주석
+    if (!line || line.startsWith('#')) continue;
+
+    // 섹션 헤더: [section] 또는 [section.sub]
+    const sectionMatch = line.match(/^\[([^\]]+)\]$/);
+    if (sectionMatch) {
+      currentSection = sectionMatch[1];
+      // 중첩 객체 생성
+      const parts = currentSection.split('.');
+      let obj = result;
+      for (const part of parts) {
+        if (!obj[part]) obj[part] = {};
+        obj = obj[part];
+      }
+      continue;
+    }
+
+    // key = value
+    const kvMatch = line.match(/^(\w+)\s*=\s*(.+)$/);
+    if (kvMatch) {
+      const [, key, rawValue] = kvMatch;
+      const value = parseTomlValue(rawValue.trim());
+
+      if (currentSection) {
+        const parts = currentSection.split('.');
+        let obj = result;
+        for (const part of parts) {
+          if (!obj[part]) obj[part] = {};
+          obj = obj[part];
+        }
+        obj[key] = value;
+      } else {
+        result[key] = value;
+      }
+    }
+  }
+
+  return result;
+}
+
+function parseTomlValue(raw) {
+  // 따옴표 문자열
+  if ((raw.startsWith('"') && raw.endsWith('"')) || (raw.startsWith("'") && raw.endsWith("'"))) {
+    return raw.slice(1, -1);
+  }
+  // 불리언
+  if (raw === 'true') return true;
+  if (raw === 'false') return false;
+  // 숫자
+  const num = Number(raw);
+  if (!isNaN(num) && raw !== '') return num;
+  // 인라인 주석 제거
+  const commentIdx = raw.indexOf('#');
+  if (commentIdx > 0) {
+    return parseTomlValue(raw.slice(0, commentIdx).trim());
+  }
+  return raw;
+}