sentix 2.0.1

package/src/commands/version.js

@@ -0,0 +1,218 @@
+/**
+ * sentix version — 버전 관리
+ *
+ * sentix version current    — 현재 버전 표시
+ * sentix version bump       — 버전 범프 + git tag + CHANGELOG
+ * sentix version changelog  — CHANGELOG 미리보기 생성
+ */
+
+import { spawnSync } from 'node:child_process';
+import { registerCommand } from '../registry.js';
+import { parseSemver, bumpSemver } from '../lib/semver.js';
+import { generateForVersion, prependToChangelog } from '../lib/changelog.js';
+
+registerCommand('version', {
+  description: 'Manage project version (bump | current | changelog)',
+  usage: 'sentix version <bump|current|changelog> [major|minor|patch]',
+
+  async run(args, ctx) {
+    const subcommand = args[0];
+
+    if (!subcommand || subcommand === 'current') {
+      await showCurrent(ctx);
+    } else if (subcommand === 'bump') {
+      const type = args[1] || 'patch';
+      if (!['major', 'minor', 'patch'].includes(type)) {
+        ctx.error(`Invalid bump type: ${type} (use major|minor|patch)`);
+        return;
+      }
+      await bumpVersion(type, ctx);
+    } else if (subcommand === 'changelog') {
+      await showChangelog(ctx);
+    } else {
+      ctx.error(`Unknown subcommand: ${subcommand}`);
+      ctx.log('Usage: sentix version <bump|current|changelog> [major|minor|patch]');
+    }
+  },
+});
+
+// ── sentix version current ────────────────────────────
+
+async function showCurrent(ctx) {
+  ctx.log('=== Sentix Version ===\n');
+
+  // Read from package.json
+  let currentVersion = 'unknown';
+  if (ctx.exists('package.json')) {
+    try {
+      const pkg = await ctx.readJSON('package.json');
+      currentVersion = pkg.version || 'unknown';
+    } catch {
+      ctx.warn('Could not read package.json');
+    }
+  }
+  ctx.log(`  Version:  ${currentVersion}`);
+
+  // Check latest git tag
+  const tagResult = spawnSync('git', ['describe', '--tags', '--abbrev=0'], {
+    cwd: ctx.cwd,
+    encoding: 'utf-8',
+    stdio: 'pipe',
+  });
+
+  if (tagResult.status === 0 && tagResult.stdout.trim()) {
+    const latestTag = tagResult.stdout.trim();
+    ctx.log(`  Git Tag:  ${latestTag}`);
+
+    // Check if current version matches the tag
+    const tagVersion = latestTag.replace(/^v/i, '');
+    if (tagVersion !== currentVersion) {
+      ctx.warn(`  Version ${currentVersion} has no matching git tag`);
+    }
+  } else {
+    ctx.log('  Git Tag:  (none)');
+  }
+
+  // Check INTERFACE.md version
+  if (ctx.exists('INTERFACE.md')) {
+    try {
+      const iface = await ctx.readFile('INTERFACE.md');
+      const match = iface.match(/version:\s*(\S+)/);
+      if (match) {
+        ctx.log(`  INTERFACE: ${match[1]}`);
+        if (match[1] !== currentVersion) {
+          ctx.warn('  INTERFACE.md version is out of sync');
+        }
+      }
+    } catch { /* non-critical */ }
+  }
+
+  ctx.log('');
+}
+
+// ── sentix version bump ───────────────────────────────
+
+async function bumpVersion(type, ctx) {
+  // 1. Read current version
+  if (!ctx.exists('package.json')) {
+    ctx.error('package.json not found');
+    return;
+  }
+
+  const pkg = await ctx.readJSON('package.json');
+  const current = pkg.version;
+  let newVersion;
+
+  try {
+    parseSemver(current);
+    newVersion = bumpSemver(current, type);
+  } catch (e) {
+    ctx.error(`Cannot bump version: ${e.message}`);
+    return;
+  }
+
+  ctx.log(`Bumping: ${current} → ${newVersion} (${type})\n`);
+
+  // 2. Update package.json
+  pkg.version = newVersion;
+  await ctx.writeJSON('package.json', pkg);
+  ctx.success('Updated package.json');
+
+  // 3. Update INTERFACE.md version line
+  if (ctx.exists('INTERFACE.md')) {
+    try {
+      let iface = await ctx.readFile('INTERFACE.md');
+      iface = iface.replace(
+        /version:\s*\S+/,
+        `version: ${newVersion}`
+      );
+      await ctx.writeFile('INTERFACE.md', iface);
+      ctx.success('Updated INTERFACE.md');
+    } catch { /* non-critical */ }
+  }
+
+  // 4. Generate changelog entry
+  try {
+    const entry = await generateForVersion(ctx, newVersion);
+    if (entry.trim()) {
+      await prependToChangelog(ctx, entry);
+      ctx.success('Updated CHANGELOG.md');
+    }
+  } catch (e) {
+    ctx.warn(`Changelog generation skipped: ${e.message}`);
+  }
+
+  // 5. Git commit + tag
+  const gitAdd = spawnSync('git', ['add', 'package.json', 'CHANGELOG.md', 'INTERFACE.md'], {
+    cwd: ctx.cwd,
+    encoding: 'utf-8',
+    stdio: 'pipe',
+  });
+
+  if (gitAdd.status === 0) {
+    const commitMsg = `chore: bump version to v${newVersion}`;
+    const gitCommit = spawnSync('git', ['commit', '-m', commitMsg], {
+      cwd: ctx.cwd,
+      encoding: 'utf-8',
+      stdio: 'pipe',
+    });
+
+    if (gitCommit.status === 0) {
+      ctx.success(`Committed: ${commitMsg}`);
+
+      const gitTag = spawnSync('git', ['tag', '-a', `v${newVersion}`, '-m', `Release v${newVersion}`], {
+        cwd: ctx.cwd,
+        encoding: 'utf-8',
+        stdio: 'pipe',
+      });
+
+      if (gitTag.status === 0) {
+        ctx.success(`Tagged: v${newVersion}`);
+      } else {
+        ctx.warn(`Tag creation failed: ${gitTag.stderr?.trim() || 'unknown error'}`);
+      }
+    } else {
+      ctx.warn(`Commit failed: ${gitCommit.stderr?.trim() || 'unknown error'}`);
+    }
+  } else {
+    ctx.warn('Git staging failed — version bumped in files only');
+  }
+
+  ctx.log('');
+  ctx.log('To publish:');
+  ctx.log('  git push && git push --tags');
+
+  // 6. Log event
+  await ctx.appendJSONL('tasks/pattern-log.jsonl', {
+    ts: new Date().toISOString(),
+    event: 'version:bump',
+    from: current,
+    to: newVersion,
+    type,
+  });
+}
+
+// ── sentix version changelog ──────────────────────────
+
+async function showChangelog(ctx) {
+  ctx.log('=== Changelog Preview ===\n');
+
+  let currentVersion = 'next';
+  if (ctx.exists('package.json')) {
+    try {
+      const pkg = await ctx.readJSON('package.json');
+      currentVersion = pkg.version || 'next';
+    } catch { /* use default */ }
+  }
+
+  try {
+    const entry = await generateForVersion(ctx, currentVersion);
+    if (entry.trim()) {
+      ctx.log(entry);
+    } else {
+      ctx.log('(No resolved tickets or completed cycles to report)');
+    }
+  } catch (e) {
+    ctx.error(`Could not generate changelog: ${e.message}`);
+  }
+}

package/src/context.js

@@ -0,0 +1,104 @@
+/**
+ * Sentix Context Object
+ *
+ * Passed to every command and plugin as `ctx`.
+ * Provides filesystem helpers and logging utilities.
+ * Zero external dependencies — uses only Node.js built-ins.
+ */
+
+import { readFile, writeFile, appendFile, mkdir, rename } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { resolve, dirname, join } from 'node:path';
+import { randomBytes } from 'node:crypto';
+
+const useColor = process.env.NO_COLOR === undefined && process.stdout.isTTY;
+
+function color(code, text) {
+  return useColor ? `\x1b[${code}m${text}\x1b[0m` : text;
+}
+
+/**
+ * Create a context object for command/plugin execution.
+ * @param {string} cwd - Current working directory
+ * @returns {object} ctx
+ */
+export function createContext(cwd) {
+  return {
+    cwd,
+
+    /**
+     * Read a file relative to cwd.
+     * @param {string} path
+     * @returns {Promise<string>}
+     */
+    async readFile(path) {
+      return readFile(resolve(cwd, path), 'utf-8');
+    },
+
+    /**
+     * Write a file relative to cwd. Creates parent directories.
+     * @param {string} path
+     * @param {string} content
+     */
+    async writeFile(path, content) {
+      const full = resolve(cwd, path);
+      await mkdir(dirname(full), { recursive: true });
+      await writeFile(full, content, 'utf-8');
+    },
+
+    /**
+     * Read a JSON file relative to cwd.
+     * @param {string} path
+     * @returns {Promise<object>}
+     */
+    async readJSON(path) {
+      const raw = await readFile(resolve(cwd, path), 'utf-8');
+      return JSON.parse(raw);
+    },
+
+    /**
+     * Write a JSON file atomically (write-to-temp-then-rename).
+     * Prevents corruption if process crashes mid-write.
+     * @param {string} path
+     * @param {object} data
+     */
+    async writeJSON(path, data) {
+      const full = resolve(cwd, path);
+      const dir = dirname(full);
+      await mkdir(dir, { recursive: true });
+
+      const tmpName = `.${randomBytes(6).toString('hex')}.tmp`;
+      const tmpPath = join(dir, tmpName);
+      const content = JSON.stringify(data, null, 2) + '\n';
+
+      await writeFile(tmpPath, content, 'utf-8');
+      await rename(tmpPath, full);
+    },
+
+    /**
+     * Append a JSON line to a JSONL file.
+     * @param {string} path
+     * @param {object} data
+     */
+    async appendJSONL(path, data) {
+      const full = resolve(cwd, path);
+      await mkdir(dirname(full), { recursive: true });
+      await appendFile(full, JSON.stringify(data) + '\n', 'utf-8');
+    },
+
+    /**
+     * Check if a file exists relative to cwd.
+     * @param {string} path
+     * @returns {boolean}
+     */
+    exists(path) {
+      return existsSync(resolve(cwd, path));
+    },
+
+    // ── Logging (respects NO_COLOR and non-TTY) ─────
+    log(msg)     { console.log(msg); },
+    success(msg) { console.log(`${color('32', '✓')} ${msg}`); },
+    warn(msg)    { console.log(`${color('33', '⚠')} ${msg}`); },
+    error(msg)   { console.error(`${color('31', '✗')} ${msg}`); },
+  };
+}

package/src/dev-server.js

@@ -0,0 +1,154 @@
+/**
+ * Sentix Dev Server — 로컬 테스트용
+ *
+ * Governor 상태, Memory Layer, 에이전트 메트릭스를 JSON API로 제공.
+ * 대시보드 개발 시 백엔드로 사용.
+ *
+ * Usage: node src/dev-server.js [port]
+ */
+
+import { createServer } from 'node:http';
+import { readFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+const PORT = parseInt(process.argv[2] || '4400', 10);
+const CWD = process.cwd();
+
+function filePath(rel) {
+  return resolve(CWD, rel);
+}
+
+async function readJSON(path) {
+  try {
+    const full = filePath(path);
+    if (!existsSync(full)) return null;
+    return JSON.parse(await readFile(full, 'utf-8'));
+  } catch { return null; }
+}
+
+async function readText(path) {
+  try {
+    const full = filePath(path);
+    if (!existsSync(full)) return null;
+    return await readFile(full, 'utf-8');
+  } catch { return null; }
+}
+
+async function readJSONL(path) {
+  const text = await readText(path);
+  if (!text) return [];
+  return text.trim().split('\n').filter(Boolean).map(line => {
+    try { return JSON.parse(line); } catch { return null; }
+  }).filter(Boolean);
+}
+
+const routes = {
+  '/': async () => ({
+    name: 'sentix-dev-server',
+    version: '2.0.1',
+    endpoints: Object.keys(routes),
+  }),
+
+  '/api/status': async () => ({
+    governor: await readJSON('tasks/governor-state.json'),
+    lessons: (await readText('tasks/lessons.md'))?.split('\n').filter(l => l.startsWith('- ')).length || 0,
+    patterns: (await readText('tasks/patterns.md'))?.split('\n').filter(l => l.startsWith('- ')).length || 0,
+    patternLogEntries: (await readJSONL('tasks/pattern-log.jsonl')).length,
+    metricsEntries: (await readJSONL('tasks/agent-metrics.jsonl')).length,
+  }),
+
+  '/api/governor': async () => await readJSON('tasks/governor-state.json') || { status: 'idle' },
+
+  '/api/lessons': async () => {
+    const text = await readText('tasks/lessons.md');
+    if (!text) return { entries: [] };
+    const entries = text.split('\n').filter(l => l.startsWith('- ')).map(l => l.slice(2));
+    return { count: entries.length, entries };
+  },
+
+  '/api/patterns': async () => {
+    const text = await readText('tasks/patterns.md');
+    if (!text) return { entries: [] };
+    const entries = text.split('\n').filter(l => l.startsWith('- ')).map(l => l.slice(2));
+    return { count: entries.length, entries };
+  },
+
+  '/api/predictions': async () => await readText('tasks/predictions.md') || '',
+
+  '/api/metrics': async () => {
+    const entries = await readJSONL('tasks/agent-metrics.jsonl');
+    const byAgent = {};
+    for (const e of entries) {
+      const agent = e.agent || 'unknown';
+      if (!byAgent[agent]) byAgent[agent] = [];
+      byAgent[agent].push(e);
+    }
+    return { totalRecords: entries.length, byAgent };
+  },
+
+  '/api/security': async () => await readText('tasks/security-report.md') || '',
+
+  '/api/roadmap': async () => await readText('tasks/roadmap.md') || '',
+
+  '/api/pattern-log': async () => {
+    const entries = await readJSONL('tasks/pattern-log.jsonl');
+    return { count: entries.length, entries: entries.slice(-100) }; // last 100
+  },
+
+  '/api/tickets': async () => {
+    const index = await readJSON('tasks/tickets/index.json');
+    if (!index) return { count: 0, tickets: [] };
+    return { count: index.length, tickets: index };
+  },
+
+  '/api/version': async () => {
+    const pkg = await readJSON('package.json');
+    return {
+      current: pkg?.version || 'unknown',
+      name: pkg?.name || 'unknown',
+    };
+  },
+
+  '/api/features': async () => {
+    const index = await readJSON('tasks/tickets/index.json');
+    if (!index) return { count: 0, features: [] };
+    const features = index.filter(t => t.type === 'feature');
+    return { count: features.length, features };
+  },
+
+  '/health': async () => ({ ok: true, ts: new Date().toISOString() }),
+};
+
+const server = createServer(async (req, res) => {
+  const url = new URL(req.url, `http://localhost:${PORT}`);
+  const handler = routes[url.pathname];
+
+  res.setHeader('Access-Control-Allow-Origin', '*');
+  res.setHeader('Content-Type', 'application/json');
+
+  if (!handler) {
+    res.writeHead(404);
+    res.end(JSON.stringify({ error: 'Not found', available: Object.keys(routes) }));
+    return;
+  }
+
+  try {
+    const data = await handler();
+    res.writeHead(200);
+    res.end(typeof data === 'string' ? JSON.stringify({ content: data }) : JSON.stringify(data, null, 2));
+  } catch (err) {
+    res.writeHead(500);
+    res.end(JSON.stringify({ error: err.message }));
+  }
+});
+
+server.listen(PORT, () => {
+  console.log(`Sentix dev server running at http://localhost:${PORT}`);
+  console.log('');
+  console.log('Endpoints:');
+  for (const path of Object.keys(routes)) {
+    console.log(`  http://localhost:${PORT}${path}`);
+  }
+  console.log('');
+});

package/src/lib/agent-loop.js

@@ -0,0 +1,110 @@
+/**
+ * agent-loop.js — Agentic loop (Engine mode)
+ *
+ * AI에게 프롬프트를 보내고, 도구 호출을 처리하고, 결과를 돌려주는 루프.
+ * Claude Code가 내부적으로 하는 일을 sentix 코드로 구현한 것.
+ */
+
+import { TOOLS, executeTool } from './tools.js';
+
+/**
+ * Agentic loop 실행
+ * @param {object} client - createClient() 결과
+ * @param {string} systemPrompt - 에이전트 시스템 프롬프트
+ * @param {string} userMessage - 사용자 요청
+ * @param {object} ctx - sentix context
+ * @param {object} [options] - { maxTurns, onToolCall }
+ * @returns {Promise<object>} { content, turns, tool_calls_total, usage }
+ */
+export async function runAgentLoop(client, systemPrompt, userMessage, ctx, options = {}) {
+  const maxTurns = options.maxTurns || 50;
+  const onToolCall = options.onToolCall || (() => {});
+
+  const messages = [{ role: 'user', content: userMessage }];
+  let totalToolCalls = 0;
+  let totalUsage = { input_tokens: 0, output_tokens: 0 };
+
+  for (let turn = 0; turn < maxTurns; turn++) {
+    const response = await client.chat(systemPrompt, messages, TOOLS);
+
+    // 토큰 사용량 집계
+    if (response.usage) {
+      totalUsage.input_tokens += response.usage.input_tokens || 0;
+      totalUsage.output_tokens += response.usage.output_tokens || 0;
+    }
+
+    // 도구 호출 없음 → 최종 응답
+    if (response.tool_calls.length === 0) {
+      return {
+        content: response.content,
+        turns: turn + 1,
+        tool_calls_total: totalToolCalls,
+        usage: totalUsage,
+      };
+    }
+
+    // 도구 호출 처리
+    // AI의 응답을 assistant 메시지로 추가 (Anthropic 포맷)
+    if (client.name === 'claude') {
+      // Anthropic: content 배열로 구성
+      const contentBlocks = [];
+      if (response.content) {
+        contentBlocks.push({ type: 'text', text: response.content });
+      }
+      for (const tc of response.tool_calls) {
+        contentBlocks.push({
+          type: 'tool_use',
+          id: tc.id,
+          name: tc.name,
+          input: tc.arguments,
+        });
+      }
+      messages.push({ role: 'assistant', content: contentBlocks });
+
+      // 도구 결과를 user 메시지로 추가 (Anthropic tool_result 포맷)
+      const toolResults = [];
+      for (const tc of response.tool_calls) {
+        totalToolCalls++;
+        onToolCall(tc.name, tc.arguments);
+
+        const result = await executeTool(tc.name, tc.arguments, ctx);
+        toolResults.push({
+          type: 'tool_result',
+          tool_use_id: tc.id,
+          content: typeof result === 'string' ? result : JSON.stringify(result),
+        });
+      }
+      messages.push({ role: 'user', content: toolResults });
+    } else {
+      // OpenAI/Ollama: 표준 tool_calls 포맷
+      messages.push({
+        role: 'assistant',
+        content: response.content || null,
+        tool_calls: response.tool_calls.map(tc => ({
+          id: tc.id,
+          type: 'function',
+          function: { name: tc.name, arguments: JSON.stringify(tc.arguments) },
+        })),
+      });
+
+      for (const tc of response.tool_calls) {
+        totalToolCalls++;
+        onToolCall(tc.name, tc.arguments);
+
+        const result = await executeTool(tc.name, tc.arguments, ctx);
+        messages.push({
+          role: 'tool',
+          tool_call_id: tc.id,
+          content: typeof result === 'string' ? result : JSON.stringify(result),
+        });
+      }
+    }
+  }
+
+  return {
+    content: '[Agent loop reached max turns]',
+    turns: maxTurns,
+    tool_calls_total: totalToolCalls,
+    usage: totalUsage,
+  };
+}