sentix 2.0.1

package/src/lib/safety.js

@@ -0,0 +1,146 @@
+/**
+ * safety.js — Safety word hashing and verification
+ *
+ * Stores a SHA-256 hash of the user's safety word in .sentix/safety.toml.
+ * The Governor uses this to gate dangerous operations (memory wipe, data export, rule changes).
+ *
+ * 보안 원칙:
+ *   - 평문은 절대 저장하지 않는다 (SHA-256 해시만 저장)
+ *   - .sentix/safety.toml은 .gitignore에 포함 (PEM 키와 동일 취급)
+ *   - AI가 안전어를 대화에 출력하거나 외부로 전송하는 것은 절대 금지
+ *   - 안전어 해시도 사용자 요청 없이 노출 금지
+ */
+
+import { createHash } from 'node:crypto';
+
+const SAFETY_PATH = '.sentix/safety.toml';
+
+/** SHA-256 hash with a fixed salt to prevent rainbow table lookups */
+const SALT = 'sentix-safety-v1';
+
+export function hashWord(word) {
+  return createHash('sha256')
+    .update(`${SALT}:${word.trim()}`)
+    .digest('hex');
+}
+
+/**
+ * Load the stored safety hash from .sentix/safety.toml
+ * Returns null if not configured.
+ */
+export async function loadSafetyHash(ctx) {
+  if (!ctx.exists(SAFETY_PATH)) return null;
+
+  const content = await ctx.readFile(SAFETY_PATH);
+  const match = content.match(/^hash\s*=\s*"([a-f0-9]{64})"/m);
+  return match ? match[1] : null;
+}
+
+/**
+ * Save the safety hash to .sentix/safety.toml
+ */
+export async function saveSafetyHash(ctx, hash) {
+  const content = `# ┌─────────────────────────────────────────────────────┐
+# │  SENTIX SAFETY WORD — CONFIDENTIAL                  │
+# │                                                      │
+# │  이 파일은 PEM 키와 동일한 보안 수준으로 취급합니다.    │
+# │  !! 절대 git에 커밋하지 마세요 !!                      │
+# │  !! 절대 외부에 공유하지 마세요 !!                      │
+# │  !! 절대 AI 대화에 내용을 붙여넣지 마세요 !!            │
+# │                                                      │
+# │  This file is treated with PEM-key-level security.   │
+# │  !! NEVER commit to git !!                           │
+# │  !! NEVER share externally !!                        │
+# │  !! NEVER paste contents into AI conversations !!    │
+# │                                                      │
+# │  수정: sentix safety set <새 안전어>                   │
+# └─────────────────────────────────────────────────────┘
+
+[safety]
+hash = "${hash}"
+enabled = true
+`;
+  await ctx.writeFile(SAFETY_PATH, content);
+}
+
+/**
+ * Verify a word against the stored hash.
+ * Returns: true (match), false (mismatch), null (no safety word configured)
+ */
+export async function verifyWord(ctx, word) {
+  const stored = await loadSafetyHash(ctx);
+  if (!stored) return null;
+  return hashWord(word) === stored;
+}
+
+/**
+ * Check if safety word is configured
+ */
+export async function isConfigured(ctx) {
+  return (await loadSafetyHash(ctx)) !== null;
+}
+
+/**
+ * Check if safety.toml is accidentally tracked by git
+ */
+export function isGitignored(ctx) {
+  if (!ctx.exists('.gitignore')) return false;
+  // Synchronous check — just verify the path appears in .gitignore
+  // Full verification happens via ctx.readFile in the command layer
+  return true;
+}
+
+/**
+ * Patterns that trigger safety word verification.
+ * These detect potential LLM injection attempts.
+ */
+export const DANGEROUS_PATTERNS = [
+  // ── Memory / learning manipulation ──
+  /잊어|forget|delete.*(memory|lesson|pattern|learning)/i,
+  /기억.*(삭제|지워|초기화)/i,
+  /lessons?\.md.*(삭제|지워|초기화|clear|wipe|reset)/i,
+  /patterns?\.md.*(삭제|지워|초기화|clear|wipe|reset)/i,
+  /(clear|wipe|reset|erase).*(lessons?|patterns?|memory|학습|기억)/i,
+
+  // ── Data exfiltration ──
+  /외부.*(보내|전송|export|send)/i,
+  /(send|export|upload|transmit).*(data|secret|key|token|credential)/i,
+  /(curl|wget|fetch).*\.(io|com|net|org)/i,
+
+  // ── Rule / config manipulation ──
+  /하드\s*룰.*(변경|삭제|무시|수정|disable)/i,
+  /(ignore|disable|bypass|skip).*(rule|hard.?rule|규칙|하드)/i,
+  /config\.toml.*(삭제|수정|변경)/i,
+
+  // ── Safety word tampering ──
+  /safety.*(word|어).*(변경|삭제|무시|disable|remove|change)/i,
+  /안전어.*(변경|삭제|무시|바꿔)/i,
+
+  // ── Safety word extraction (탈취 시도) ──
+  /안전어.*(알려|보여|출력|말해|뭐야|뭔지|무엇)/i,
+  /safety.*(word|어).*(show|tell|reveal|what|print|display)/i,
+  /(what|show|tell|reveal|print|display).*(safety.?word|안전어)/i,
+  /safety\.toml.*(읽어|보여|열어|cat|내용|출력|read|show|print|display)/i,
+  /\.sentix\/safety.*(읽|보|열|cat|show|read|print)/i,
+  /(해시|hash).*(보여|알려|출력|show|tell|reveal|print)/i,
+
+  // ── Scope escape ──
+  /CLAUDE\.md.*(수정|변경|삭제|rewrite|modify)/i,
+  /FRAMEWORK\.md.*(수정|변경|삭제|rewrite|modify)/i,
+
+  // ── Bulk destruction ──
+  /(rm\s+-rf|del\s+\/|rmdir|전부\s*삭제|모두\s*삭제)/i,
+];
+
+/**
+ * Check if a request text matches any dangerous pattern.
+ * Returns the matched pattern description or null.
+ */
+export function detectDangerousRequest(text) {
+  for (const pattern of DANGEROUS_PATTERNS) {
+    if (pattern.test(text)) {
+      return pattern.source;
+    }
+  }
+  return null;
+}

package/src/lib/semver.js

@@ -0,0 +1,40 @@
+/**
+ * Minimal semver utilities — zero external dependencies.
+ *
+ * parse("2.0.1")          → { major:2, minor:0, patch:1 }
+ * bump("2.0.1", "minor")  → "2.1.0"
+ * compare("2.0.1","2.1.0") → -1
+ */
+
+export function parseSemver(version) {
+  const clean = String(version).replace(/^v/i, '');
+  const [major, minor, patch] = clean.split('.').map(Number);
+  if ([major, minor, patch].some(n => !Number.isFinite(n) || n < 0)) {
+    throw new Error(`Invalid semver: ${version}`);
+  }
+  return { major, minor, patch };
+}
+
+export function bumpSemver(version, type) {
+  const v = parseSemver(version);
+  switch (type) {
+    case 'major': return `${v.major + 1}.0.0`;
+    case 'minor': return `${v.major}.${v.minor + 1}.0`;
+    case 'patch': return `${v.major}.${v.minor}.${v.patch + 1}`;
+    default: throw new Error(`Unknown bump type: ${type} (use major|minor|patch)`);
+  }
+}
+
+export function compareSemver(a, b) {
+  const va = parseSemver(a);
+  const vb = parseSemver(b);
+  for (const key of ['major', 'minor', 'patch']) {
+    if (va[key] < vb[key]) return -1;
+    if (va[key] > vb[key]) return 1;
+  }
+  return 0;
+}
+
+export function formatSemver(v) {
+  return `${v.major}.${v.minor}.${v.patch}`;
+}

package/src/lib/similarity.js

@@ -0,0 +1,58 @@
+/**
+ * Zero-dependency text similarity using trigram Jaccard coefficient.
+ * Used for duplicate ticket detection against lessons.md and existing tickets.
+ */
+
+export const DUPLICATE_THRESHOLD = 0.65;
+
+export function tokenize(text) {
+  return String(text)
+    .toLowerCase()
+    .replace(/[^\w\s가-힣]/g, ' ')
+    .split(/\s+/)
+    .filter(Boolean);
+}
+
+export function trigrams(tokens) {
+  const set = new Set();
+  for (let i = 0; i <= tokens.length - 3; i++) {
+    set.add(`${tokens[i]} ${tokens[i + 1]} ${tokens[i + 2]}`);
+  }
+  // Also include bigrams for short texts
+  for (let i = 0; i <= tokens.length - 2; i++) {
+    set.add(`${tokens[i]} ${tokens[i + 1]}`);
+  }
+  return set;
+}
+
+export function similarity(textA, textB) {
+  const a = trigrams(tokenize(textA));
+  const b = trigrams(tokenize(textB));
+
+  if (a.size === 0 && b.size === 0) return 1;
+  if (a.size === 0 || b.size === 0) return 0;
+
+  let intersection = 0;
+  for (const gram of a) {
+    if (b.has(gram)) intersection++;
+  }
+
+  // Jaccard = |A ∩ B| / |A ∪ B|
+  const union = a.size + b.size - intersection;
+  return union === 0 ? 0 : intersection / union;
+}
+
+/**
+ * Find best match above threshold from a list of candidates.
+ * @returns {{ text: string, score: number } | null}
+ */
+export function findBestMatch(query, candidates) {
+  let best = null;
+  for (const text of candidates) {
+    const score = similarity(query, text);
+    if (score >= DUPLICATE_THRESHOLD && (!best || score > best.score)) {
+      best = { text, score };
+    }
+  }
+  return best;
+}

package/src/lib/ticket-index.js

@@ -0,0 +1,137 @@
+/**
+ * Ticket Index — CRUD operations for tasks/tickets/index.json
+ *
+ * Manages ticket lifecycle: open → in_progress → review → resolved → closed
+ * Zero external dependencies.
+ */
+
+import { createHash } from 'node:crypto';
+
+const INDEX_PATH = 'tasks/tickets/index.json';
+
+const VALID_TRANSITIONS = {
+  open:        ['in_progress'],
+  in_progress: ['review', 'open'],
+  review:      ['resolved', 'in_progress'],
+  resolved:    ['closed'],
+  closed:      [],
+};
+
+const SEVERITY_ORDER = { critical: 0, warning: 1, suggestion: 2 };
+
+// ── CRUD ──────────────────────────────────────────────
+
+export async function loadIndex(ctx) {
+  if (!ctx.exists(INDEX_PATH)) return [];
+  try {
+    return await ctx.readJSON(INDEX_PATH);
+  } catch {
+    return [];
+  }
+}
+
+export async function saveIndex(ctx, entries) {
+  await ctx.writeJSON(INDEX_PATH, entries);
+}
+
+export async function nextTicketId(ctx, prefix) {
+  const entries = await loadIndex(ctx);
+  const matching = entries
+    .filter(e => e.id.startsWith(`${prefix}-`))
+    .map(e => parseInt(e.id.split('-')[1], 10))
+    .filter(n => Number.isFinite(n));
+
+  const next = matching.length > 0 ? Math.max(...matching) + 1 : 1;
+  return `${prefix}-${String(next).padStart(3, '0')}`;
+}
+
+export async function addTicket(ctx, entry) {
+  const entries = await loadIndex(ctx);
+  entries.push(entry);
+  await saveIndex(ctx, entries);
+  return entry;
+}
+
+export async function updateTicket(ctx, id, updates) {
+  const entries = await loadIndex(ctx);
+  const idx = entries.findIndex(e => e.id === id);
+  if (idx === -1) return null;
+
+  // Validate status transition if status is being changed
+  if (updates.status && updates.status !== entries[idx].status) {
+    const allowed = VALID_TRANSITIONS[entries[idx].status] || [];
+    if (!allowed.includes(updates.status)) {
+      throw new Error(
+        `Invalid transition: ${entries[idx].status} → ${updates.status} (allowed: ${allowed.join(', ') || 'none'})`
+      );
+    }
+  }
+
+  entries[idx] = {
+    ...entries[idx],
+    ...updates,
+    updated_at: new Date().toISOString(),
+  };
+  await saveIndex(ctx, entries);
+  return entries[idx];
+}
+
+export async function findTicket(ctx, id) {
+  const entries = await loadIndex(ctx);
+  return entries.find(e => e.id === id) || null;
+}
+
+export async function findByStatus(ctx, status) {
+  const entries = await loadIndex(ctx);
+  return entries.filter(e => e.status === status);
+}
+
+export async function findByType(ctx, type) {
+  const entries = await loadIndex(ctx);
+  return entries.filter(e => e.type === type);
+}
+
+// ── Severity auto-classification ──────────────────────
+
+const CRITICAL_KEYWORDS = ['crash', 'security', 'data loss', 'corruption', 'undefined is not', 'econnrefused', 'injection', 'vulnerability', '보안', '데이터 손실', '크래시'];
+const WARNING_KEYWORDS = ['slow', 'wrong', 'broken', 'error', 'fail', 'incorrect', 'bug', '오류', '에러', '느림', '실패'];
+
+export function classifySeverity(description) {
+  const lower = description.toLowerCase();
+  if (CRITICAL_KEYWORDS.some(k => lower.includes(k))) return 'critical';
+  if (WARNING_KEYWORDS.some(k => lower.includes(k))) return 'warning';
+  return 'suggestion';
+}
+
+// ── Helpers ───────────────────────────────────────────
+
+export function descriptionHash(text) {
+  return createHash('sha256').update(text).digest('hex').slice(0, 8);
+}
+
+export function sortBySeverity(entries) {
+  return [...entries].sort((a, b) => {
+    const sa = SEVERITY_ORDER[a.severity] ?? 3;
+    const sb = SEVERITY_ORDER[b.severity] ?? 3;
+    if (sa !== sb) return sa - sb;
+    return new Date(b.created_at) - new Date(a.created_at);
+  });
+}
+
+/**
+ * Create a standard TicketEntry object.
+ */
+export function createTicketEntry({ id, type, title, severity, description }) {
+  return {
+    id,
+    type,
+    title,
+    severity: severity || 'suggestion',
+    status: 'open',
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
+    description_hash: descriptionHash(description || title),
+    related_cycle: null,
+    file_path: `tasks/tickets/${id}.md`,
+  };
+}

package/src/lib/tools.js

@@ -0,0 +1,142 @@
+/**
+ * tools.js — Engine mode 도구 정의 + 실행 핸들러
+ *
+ * AI가 사용할 도구를 정의하고, 도구 호출을 실행한다.
+ * 화이트리스트 기반 — 허용된 명령만 실행 가능.
+ */
+
+import { execSync } from 'node:child_process';
+import { readdirSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+// AI에게 제공하는 도구 목록 (Anthropic tool_use 포맷)
+export const TOOLS = [
+  {
+    name: 'read_file',
+    description: 'Read the contents of a file',
+    parameters: {
+      type: 'object',
+      properties: { path: { type: 'string', description: 'File path relative to project root' } },
+      required: ['path'],
+    },
+  },
+  {
+    name: 'write_file',
+    description: 'Write content to a file (creates parent dirs)',
+    parameters: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'File path relative to project root' },
+        content: { type: 'string', description: 'File content to write' },
+      },
+      required: ['path', 'content'],
+    },
+  },
+  {
+    name: 'list_files',
+    description: 'List files in a directory',
+    parameters: {
+      type: 'object',
+      properties: { path: { type: 'string', description: 'Directory path (default: .)' } },
+    },
+  },
+  {
+    name: 'search_files',
+    description: 'Search for a text pattern in files (grep)',
+    parameters: {
+      type: 'object',
+      properties: {
+        pattern: { type: 'string', description: 'Search pattern (regex)' },
+        path: { type: 'string', description: 'Directory to search (default: .)' },
+      },
+      required: ['pattern'],
+    },
+  },
+  {
+    name: 'run_command',
+    description: 'Run a whitelisted shell command (npm test, git status, git diff, etc.)',
+    parameters: {
+      type: 'object',
+      properties: { command: { type: 'string', description: 'Command to run' } },
+      required: ['command'],
+    },
+  },
+  {
+    name: 'git_diff',
+    description: 'Show git diff of current changes',
+    parameters: {
+      type: 'object',
+      properties: { staged: { type: 'boolean', description: 'Show staged changes only' } },
+    },
+  },
+];
+
+// 허용된 명령 화이트리스트 (접두사 매칭)
+const COMMAND_WHITELIST = [
+  'npm test', 'npm run test', 'npm run lint', 'npm run build',
+  'node bin/sentix.js',
+  'git status', 'git diff', 'git log', 'git add', 'git commit',
+  'ls', 'cat', 'head', 'tail', 'wc', 'find', 'grep',
+];
+
+/**
+ * 도구 호출 실행
+ * @param {string} name - 도구 이름
+ * @param {object} args - 도구 인자
+ * @param {object} ctx - sentix context
+ * @returns {Promise<string>} 실행 결과
+ */
+export async function executeTool(name, args, ctx) {
+  switch (name) {
+    case 'read_file':
+      return ctx.readFile(args.path);
+
+    case 'write_file':
+      await ctx.writeFile(args.path, args.content);
+      return `File written: ${args.path}`;
+
+    case 'list_files': {
+      const dir = resolve(ctx.cwd, args.path || '.');
+      const files = readdirSync(dir, { withFileTypes: true });
+      return files.map(f => f.isDirectory() ? f.name + '/' : f.name).join('\n');
+    }
+
+    case 'search_files': {
+      const searchPath = args.path || '.';
+      const result = execSync(
+        `grep -rn "${args.pattern.replace(/"/g, '\\"')}" ${searchPath} --include="*.js" --include="*.ts" --include="*.md" --include="*.json" 2>/dev/null | head -50`,
+        { cwd: ctx.cwd, encoding: 'utf-8', stdio: 'pipe', timeout: 10000 }
+      );
+      return result || 'No matches found';
+    }
+
+    case 'run_command': {
+      if (!isAllowedCommand(args.command)) {
+        return `DENIED: Command not in whitelist. Allowed prefixes: ${COMMAND_WHITELIST.join(', ')}`;
+      }
+      try {
+        return execSync(args.command, {
+          cwd: ctx.cwd,
+          encoding: 'utf-8',
+          stdio: 'pipe',
+          timeout: 60000,
+        });
+      } catch (err) {
+        return `Command failed (exit ${err.status}): ${err.stderr?.slice(0, 500) || err.message}`;
+      }
+    }
+
+    case 'git_diff': {
+      const cmd = args.staged ? 'git diff --staged' : 'git diff';
+      return execSync(cmd, { cwd: ctx.cwd, encoding: 'utf-8', stdio: 'pipe', timeout: 10000 });
+    }
+
+    default:
+      return `Unknown tool: ${name}`;
+  }
+}
+
+function isAllowedCommand(cmd) {
+  const trimmed = cmd.trim();
+  return COMMAND_WHITELIST.some(prefix => trimmed.startsWith(prefix));
+}