sentix 2.0.22 → 2.2.0

package/package.json

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

package/src/commands/init.js

@@ -504,8 +504,16 @@ function generateGovernorDirective() {
 # Sentix Governor — 필수 준수 사항
 
 > **이 프로젝트는 Sentix 프레임워크로 관리된다.**
-> **아래 규칙은 어떤 역할(/frontend, /backend 등)에서든 반드시 따라야 한다.**
-> 상세 설계: FRAMEWORK.md, 세부 규칙: docs/
+> **아래 규칙은 어떤 역할(/frontend, /backend 등)에서든, 어떤 worktree에서든 반드시 따라야 한다.**
+
+## 세션 시작 시 필수 읽기 (순서대로)
+
+\`\`\`
+1. CLAUDE.md (이 파일)
+2. FRAMEWORK.md — 5-Layer 아키텍처, 에이전트 정의
+3. docs/agent-methods.md — 에이전트별 메서드 순서 (필수 준수)
+4. .sentix/rules/hard-rules.md — 파괴 방지 6개 규칙
+\`\`\`
 
 ## 코드 수정 전 필수 절차
 
@@ -517,6 +525,22 @@ function generateGovernorDirective() {
 4. 티켓 없이 코드 수정 금지 — sentix ticket create 또는 sentix feature add 사용
 \`\`\`
 
+## 에이전트 메서드 순서 (docs/agent-methods.md 필수 참조)
+
+\`\`\`
+planner: analyze() → research() → scope() → estimate() → emit()
+  → WHAT/WHERE만 정의. HOW(구현 방법) 금지.
+
+dev: snapshot() → implement() → test() → verify() → report()
+  → 구현 방법은 dev가 결정. 품질 판단은 pr-review에 위임.
+
+pr-review: diff() → validate() → grade() → calibrate() → verdict()
+  → 회의적 판정. 의심스러우면 REJECTED.
+
+dev-fix: diagnose() → fix() → test() → learn() → report()
+  → LESSON_LEARNED 필수.
+\`\`\`
+
 ## 파괴 방지 하드 룰 6개
 
 1. 작업 전 테스트 스냅샷 필수
@@ -549,7 +573,7 @@ sentix ticket create "설명"    # 버그 티켓 생성
 sentix feature add "설명"      # 기능 티켓 생성
 sentix status                  # 상태 확인
 sentix doctor                  # 설치 진단
-sentix update                  # 프레임워크 최신화
+sentix update                  # 프레임워크 최신화 (worktree도 root 포함)
 \`\`\`
 `;
 }

package/src/commands/update.js

@@ -11,8 +11,9 @@
 
 import { registerCommand } from '../registry.js';
 import { VERSION } from '../version.js';
-import { readFileSync, existsSync } from 'node:fs';
+import { readFileSync, existsSync, writeFileSync, mkdirSync } from 'node:fs';
 import { resolve, dirname } from 'node:path';
+import { execSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -20,16 +21,129 @@ 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' },
 ];
 
+// ── Worktree 감지: 현재 위치 + main working tree ────────
+
+function getUpdateTargets(ctx) {
+  const cwd = resolve(ctx.cwd);
+  const targets = [cwd];
+
+  try {
+    // git worktree인지 확인
+    const gitCommonDir = execSync('git rev-parse --git-common-dir', {
+      cwd, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+
+    const mainGitDir = resolve(cwd, gitCommonDir);
+
+    // main working tree 경로 찾기
+    const worktreeList = execSync('git worktree list --porcelain', {
+      cwd, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    const mainMatch = worktreeList.match(/^worktree (.+)$/m);
+    if (mainMatch) {
+      const mainRoot = mainMatch[1].trim();
+      const resolvedMain = resolve(mainRoot);
+      if (resolvedMain !== cwd && existsSync(resolvedMain)) {
+        targets.push(resolvedMain);
+        ctx.log(`Worktree detected → also updating main: ${resolvedMain}`);
+      }
+    }
+  } catch {
+    // git 없거나 worktree 아님 — 현재 디렉토리만
+  }
+
+  return targets;
+}
+
+// ── 파일 동기화 실행 ─────────────────────────────────────
+
+async function syncFiles(targetDir, dryRun, ctx) {
+  const results = { updated: [], created: [], skipped: [], unchanged: [] };
+
+  for (const { src, dst } of SYNC_FILES) {
+    const srcPath = resolve(sentixRoot, src);
+    const dstPath = resolve(targetDir, dst);
+
+    if (!existsSync(srcPath)) {
+      results.skipped.push({ file: dst, reason: 'source not found' });
+      continue;
+    }
+
+    const srcContent = readFileSync(srcPath, 'utf-8');
+
+    if (existsSync(dstPath)) {
+      const dstContent = readFileSync(dstPath, 'utf-8');
+
+      if (srcContent === dstContent) {
+        results.unchanged.push(dst);
+        continue;
+      }
+
+      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})`);
+
+      if (!dryRun) {
+        mkdirSync(dirname(dstPath), { recursive: true });
+        writeFileSync(dstPath, srcContent);
+        ctx.success(`Updated: ${dst}`);
+      }
+      results.updated.push(dst);
+    } else {
+      ctx.log(`${dryRun ? '[DRY] ' : ''}Creating: ${dst}`);
+      if (!dryRun) {
+        mkdirSync(dirname(dstPath), { recursive: true });
+        writeFileSync(dstPath, srcContent);
+        ctx.success(`Created: ${dst}`);
+      }
+      results.created.push(dst);
+    }
+  }
+
+  // 요약
+  const totalChanges = results.updated.length + results.created.length;
+  if (results.updated.length > 0) {
+    ctx.log(`Updated: ${results.updated.length} — ${results.updated.join(', ')}`);
+  }
+  if (results.created.length > 0) {
+    ctx.log(`Created: ${results.created.length} — ${results.created.join(', ')}`);
+  }
+  if (totalChanges === 0) {
+    ctx.success('Already up to date.');
+  } else if (!dryRun) {
+    ctx.success(`${totalChanges} file(s) updated to sentix v${VERSION}.`);
+  }
+}
+
 registerCommand('update', {
   description: 'Update framework files to the latest sentix version',
   usage: 'sentix update [--dry]',
@@ -39,9 +153,6 @@ registerCommand('update', {
 
     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)) {
@@ -49,95 +160,22 @@ registerCommand('update', {
       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: [] };
+    // 업데이트 대상 디렉토리 수집 (현재 + worktree면 root도)
+    const targets = getUpdateTargets(ctx);
 
-    for (const { src, dst } of SYNC_FILES) {
-      const srcPath = resolve(sentixRoot, src);
+    for (const target of targets) {
+      ctx.log(`\n--- target: ${target} ---`);
+      if (dryRun) ctx.warn('DRY RUN\n');
 
-      // 원본 파일이 없으면 스킵
-      if (!existsSync(srcPath)) {
-        results.skipped.push({ file: dst, reason: 'source not found' });
+      // sentix가 초기화된 프로젝트인지 확인
+      const hasConfig = existsSync(resolve(target, '.sentix/config.toml'));
+      const hasClaude = existsSync(resolve(target, 'CLAUDE.md'));
+      if (!hasConfig && !hasClaude) {
+        ctx.warn(`Not a sentix project: ${target} — skipping`);
         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');
+      await syncFiles(target, dryRun, ctx);
     }
   },
 });

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);
 }