sentix 2.0.21 → 2.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sentix",
-  "version": "2.0.21",
+  "version": "2.1.0",
   "description": "Autonomous multi-agent DevSecOps pipeline CLI",
   "type": "module",
   "bin": {

package/src/commands/update.js

@@ -20,14 +20,29 @@ const sentixRoot = resolve(__dirname, '..', '..');
 
 // 동기화 대상: 프레임워크 공통 파일 (모든 프로젝트가 동일해야 하는 것)
 const SYNC_FILES = [
+  // CI/CD
   { 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: 'scripts/pre-commit.js',                dst: 'scripts/pre-commit.js' },
+
+  // 프레임워크 문서
   { 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/agent-methods.md',                dst: 'docs/agent-methods.md' },
   { src: 'docs/severity.md',                     dst: 'docs/severity.md' },
   { src: 'docs/architecture.md',                 dst: 'docs/architecture.md' },
+
+  // Claude Code 네이티브 에이전트
+  { src: '.claude/settings.json',                dst: '.claude/settings.json' },
+  { src: '.claude/agents/planner.md',            dst: '.claude/agents/planner.md' },
+  { src: '.claude/agents/dev.md',                dst: '.claude/agents/dev.md' },
+  { src: '.claude/agents/pr-review.md',          dst: '.claude/agents/pr-review.md' },
+  { src: '.claude/agents/dev-fix.md',            dst: '.claude/agents/dev-fix.md' },
+  { src: '.claude/agents/security.md',           dst: '.claude/agents/security.md' },
 ];
 
 registerCommand('update', {

package/src/commands/version.js

@@ -6,14 +6,14 @@
  * sentix version changelog  — CHANGELOG 미리보기 생성
  */
 
-import { spawnSync } from 'node:child_process';
+import { spawnSync, execSync } from 'node:child_process';
 import { registerCommand } from '../registry.js';
 import { parseSemver, bumpSemver } from '../lib/semver.js';
-import { generateForVersion, prependToChangelog } from '../lib/changelog.js';
+import { generateForVersion, prependToChangelog, detectBumpType } from '../lib/changelog.js';
 
 registerCommand('version', {
   description: 'Manage project version (bump | current | changelog)',
-  usage: 'sentix version <bump|current|changelog> [major|minor|patch]',
+  usage: 'sentix version <bump|current|changelog> [auto|major|minor|patch]',
 
   async run(args, ctx) {
     const subcommand = args[0];
@@ -21,9 +21,13 @@ registerCommand('version', {
     if (!subcommand || subcommand === 'current') {
       await showCurrent(ctx);
     } else if (subcommand === 'bump') {
-      const type = args[1] || 'patch';
+      let type = args[1] || 'auto';
+      if (type === 'auto') {
+        type = autoDetectBumpType(ctx);
+        ctx.log(`Auto-detected bump type: ${type}\n`);
+      }
       if (!['major', 'minor', 'patch'].includes(type)) {
-        ctx.error(`Invalid bump type: ${type} (use major|minor|patch)`);
+        ctx.error(`Invalid bump type: ${type} (use auto|major|minor|patch)`);
         return;
       }
       await bumpVersion(type, ctx);
@@ -31,11 +35,37 @@ registerCommand('version', {
       await showChangelog(ctx);
     } else {
       ctx.error(`Unknown subcommand: ${subcommand}`);
-      ctx.log('Usage: sentix version <bump|current|changelog> [major|minor|patch]');
+      ctx.log('Usage: sentix version <bump|current|changelog> [auto|major|minor|patch]');
     }
   },
 });
 
+// ── Auto-detect bump type from commits ───────────────
+
+function autoDetectBumpType(ctx) {
+  try {
+    // Get commits since last tag
+    let range = '';
+    try {
+      const lastTag = execSync('git describe --tags --abbrev=0 HEAD~1 2>/dev/null', {
+        cwd: ctx.cwd, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'],
+      }).trim();
+      if (lastTag) range = `${lastTag}..HEAD`;
+    } catch {
+      range = 'HEAD~20..HEAD';
+    }
+
+    const log = execSync(`git log ${range} --pretty=format:"%s" 2>/dev/null`, {
+      cwd: ctx.cwd, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+
+    const messages = log ? log.split('\n') : [];
+    return detectBumpType(messages);
+  } catch {
+    return 'patch';
+  }
+}
+
 // ── sentix version current ────────────────────────────
 
 async function showCurrent(ctx) {

package/src/lib/changelog.js

@@ -1,62 +1,173 @@
 /**
- * CHANGELOG.md auto-generation from governor history and ticket index.
+ * CHANGELOG.md auto-generation from git commits + ticket index.
  *
- * Matches existing format:
+ * Format:
  *   ## [x.y.z] — YYYY-MM-DD
  *   ### Category
  *   - entry
+ *
+ * Commit convention:
+ *   feat: → New Features
+ *   fix:  → Bug Fixes
+ *   ci:   → CI/CD
+ *   docs: → Documentation
+ *   chore: → Improvements
+ *   refactor: → Improvements
  */
 
+import { execSync } from 'node:child_process';
 import { loadIndex } from './ticket-index.js';
 
 /**
- * Build changelog entries from resolved tickets since last version.
+ * Parse conventional commit messages from git log since last tag.
  */
-export async function buildFromTickets(ctx) {
-  const entries = await loadIndex(ctx);
-  const resolved = entries.filter(e =>
-    e.status === 'resolved' || e.status === 'closed'
-  );
+function getCommitsSinceLastTag(cwd) {
+  // Find last tag
+  let range = '';
+  try {
+    const lastTag = execSync('git describe --tags --abbrev=0 HEAD~1 2>/dev/null', {
+      cwd, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+    if (lastTag) range = `${lastTag}..HEAD`;
+  } catch {
+    // No previous tag — use all commits (limit 50)
+    range = 'HEAD~50..HEAD';
+  }
+
+  try {
+    const log = execSync(`git log ${range} --pretty=format:"%s" 2>/dev/null`, {
+      cwd, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+    return log ? log.split('\n') : [];
+  } catch {
+    return [];
+  }
+}
 
+/**
+ * Categorize commit messages by conventional commit prefix.
+ */
+function categorizeCommits(messages) {
   const categories = {
     'New Features': [],
     'Bug Fixes': [],
     'Security Fixes': [],
+    'CI/CD': [],
+    'Documentation': [],
     '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);
+  for (const msg of messages) {
+    // Skip version bump commits
+    if (msg.startsWith('chore: bump version')) continue;
+    if (msg.startsWith('Merge pull request')) continue;
+
+    const cleaned = msg.replace(/^"(.*)"$/, '$1');
+
+    if (/^feat(\(.+?\))?:\s/.test(cleaned)) {
+      categories['New Features'].push(`- ${cleaned.replace(/^feat(\(.+?\))?:\s*/, '')}`);
+    } else if (/^fix(\(.+?\))?:\s/.test(cleaned)) {
+      categories['Bug Fixes'].push(`- ${cleaned.replace(/^fix(\(.+?\))?:\s*/, '')}`);
+    } else if (/^security(\(.+?\))?:\s/.test(cleaned)) {
+      categories['Security Fixes'].push(`- ${cleaned.replace(/^security(\(.+?\))?:\s*/, '')}`);
+    } else if (/^ci(\(.+?\))?:\s/.test(cleaned)) {
+      categories['CI/CD'].push(`- ${cleaned.replace(/^ci(\(.+?\))?:\s*/, '')}`);
+    } else if (/^docs(\(.+?\))?:\s/.test(cleaned)) {
+      categories['Documentation'].push(`- ${cleaned.replace(/^docs(\(.+?\))?:\s*/, '')}`);
+    } else if (/^(chore|refactor|perf|style)(\(.+?\))?:\s/.test(cleaned)) {
+      categories['Improvements'].push(`- ${cleaned.replace(/^(chore|refactor|perf|style)(\(.+?\))?:\s*/, '')}`);
+    } else if (cleaned.trim()) {
+      categories['Improvements'].push(`- ${cleaned}`);
     }
   }
 
   return categories;
 }
 
+/**
+ * Auto-detect bump type from commit messages.
+ *
+ * Rules:
+ *   BREAKING CHANGE or feat!: → major
+ *   feat: → minor
+ *   fix:/ci:/docs:/chore: → patch
+ */
+export function detectBumpType(messages) {
+  let hasBreaking = false;
+  let hasFeat = false;
+
+  for (const msg of messages) {
+    if (msg.includes('BREAKING CHANGE') || /^[a-z]+!:/.test(msg)) {
+      hasBreaking = true;
+    }
+    if (/^feat(\(.+?\))?:\s/.test(msg)) {
+      hasFeat = true;
+    }
+  }
+
+  if (hasBreaking) return 'major';
+  if (hasFeat) return 'minor';
+  return 'patch';
+}
+
+/**
+ * Build changelog entries from git commits + resolved tickets.
+ */
+export async function buildFromTickets(ctx) {
+  // Start with commit-based categories
+  const commits = getCommitsSinceLastTag(ctx.cwd);
+  const categories = categorizeCommits(commits);
+
+  // Merge ticket-based entries
+  try {
+    const entries = await loadIndex(ctx);
+    const resolved = entries.filter(e =>
+      e.status === 'resolved' || e.status === 'closed'
+    );
+
+    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);
+      }
+    }
+  } catch {
+    // ticket index not available — commits only
+  }
+
+  return categories;
+}
+
 /**
  * Generate a formatted changelog entry string.
  */
 export function generateChangelogEntry(version, date, categories) {
   const lines = [`## [${version}] — ${date}`, ''];
 
+  let hasContent = false;
   for (const [category, items] of Object.entries(categories)) {
     if (items.length > 0) {
+      hasContent = true;
       lines.push(`### ${category}`, '');
-      for (const item of items) {
+      // Deduplicate
+      const unique = [...new Set(items)];
+      for (const item of unique) {
         lines.push(item);
       }
       lines.push('');
     }
   }
 
+  if (!hasContent) {
+    lines.push('- Maintenance release', '');
+  }
+
   return lines.join('\n');
 }
 
@@ -85,26 +196,10 @@ export async function prependToChangelog(ctx, entry) {
 }
 
 /**
- * Generate a changelog entry from governor-state + tickets for a given version.
+ * Generate a changelog entry from git commits + 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

@@ -14,6 +14,8 @@
  */
 
 import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
 import { runGates } from './verify-gates.js';
 
 /**
@@ -191,27 +193,59 @@ export async function runChainedPipeline(request, cycleId, state, ctx, options =
   };
 }
 
+// ── 에이전트 이름 → phase 이름 매핑 ────────────────────
+
+const AGENT_MAP = {
+  plan: 'planner',
+  dev: 'dev',
+  review: 'pr-review',
+  finalize: null,  // finalize는 전용 에이전트 없음
+};
+
 // ── Phase 실행 ────────────────────────────────────────
 
 function runPhase(name, prompt, ctx) {
-  const result = spawnSync('claude', ['-p', prompt], {
+  const args = ['-p', prompt, '--output-format', 'json'];
+
+  // .claude/agents/ 에 에이전트가 있으면 --agent 플래그 추가
+  const agentName = AGENT_MAP[name];
+  if (agentName && existsSync(join(ctx.cwd, '.claude', 'agents', `${agentName}.md`))) {
+    args.push('--agent', agentName);
+  }
+
+  const result = spawnSync('claude', args, {
     cwd: ctx.cwd,
-    stdio: 'inherit',
-    timeout: 300_000, // 5분 per phase (전체 10분 대신)
+    encoding: 'utf-8',
+    stdio: 'pipe',
+    timeout: 300_000, // 5분 per phase
   });
 
   if (result.error) {
     ctx.error(`Phase ${name} failed: ${result.error.message}`);
-    return { success: false, error: result.error.message, exit_code: null };
+    return { success: false, error: result.error.message, exit_code: null, output: 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 };
+    // stderr가 있으면 출력
+    if (result.stderr?.trim()) {
+      ctx.log(result.stderr.slice(-500));
+    }
+    return { success: false, error: `exit code ${result.status}`, exit_code: result.status, output: null };
+  }
+
+  // JSON 출력 파싱
+  let output = null;
+  try {
+    output = JSON.parse(result.stdout);
+    ctx.success(`Phase ${name} completed (${output.usage?.output_tokens || '?'} tokens)`);
+  } catch {
+    // JSON 파싱 실패 — 텍스트 그대로 사용
+    output = { content: result.stdout };
+    ctx.success(`Phase ${name} completed`);
   }
 
-  ctx.success(`Phase ${name} completed`);
-  return { success: true, error: null, exit_code: 0 };
+  return { success: true, error: null, exit_code: 0, output };
 }
 
 // ── 최근 티켓 내용 가져오기 ───────────────────────────