@crewx/shared 0.0.1

package/__tests__/skill-tracer.test.ts

@@ -0,0 +1,37 @@
+import { describe, it, expect } from 'vitest';
+import path from 'path';
+import fs from 'fs';
+
+describe('shared/skill-tracer', () => {
+  const sharedDir = path.resolve(__dirname, '..');
+
+  it('should be requireable from shared package', () => {
+    const tracer = require(path.join(sharedDir, 'skill-tracer.js'));
+    expect(tracer).toBeDefined();
+    expect(typeof tracer.trace).toBe('function');
+    expect(typeof tracer.run).toBe('function');
+    expect(typeof tracer.getDbPath).toBe('function');
+    expect(typeof tracer.getTracesDbPath).toBe('function');
+  });
+
+  it('should have package.json with correct name', () => {
+    const pkg = JSON.parse(fs.readFileSync(path.join(sharedDir, 'package.json'), 'utf-8'));
+    expect(pkg.name).toBe('@crewx/shared');
+    expect(pkg.main).toBe('skill-tracer.js');
+  });
+
+  it('re-export wrapper at skills/lib should work', () => {
+    const wrapperPath = path.resolve(__dirname, '../../../../skills/lib/skill-tracer.js');
+    const tracer = require(wrapperPath);
+    expect(tracer).toBeDefined();
+    expect(typeof tracer.trace).toBe('function');
+    expect(typeof tracer.run).toBe('function');
+  });
+
+  it('getDbPath should default to ~/.crewx/crewx.db', () => {
+    const tracer = require(path.join(sharedDir, 'skill-tracer.js'));
+    const dbPath = tracer.getDbPath();
+    expect(dbPath).toContain('.crewx');
+    expect(dbPath).toContain('crewx.db');
+  });
+});

package/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "@crewx/shared",
+  "version": "0.0.1",
+  "main": "skill-tracer.js",
+  "description": "Shared utilities for CrewX built-in packages"
+}

package/skill-tracer.js

@@ -0,0 +1,432 @@
+/**
+ * skill-tracer.js - 스킬 실행 추적 라이브러리 (PoC)
+ *
+ * 스킬에서 직접 node skill.js 실행해도 로깅됨
+ * - usage.log: 텍스트 파일 로그 (경량)
+ * - crewx.db: SQLite DB 로그 (상세)
+ */
+
+// Lazy-load better-sqlite3 to allow graceful degradation if not installed
+let Database;
+try {
+  Database = require('better-sqlite3');
+} catch {
+  Database = null;
+}
+
+const os = require('os');
+const path = require('path');
+const fs = require('fs');
+const { randomUUID, createHash } = require('crypto');
+
+/**
+ * crewx.db 경로 찾기
+ */
+function getDbPath() {
+  if (process.env.CREWX_TRACES_DB || process.env.CREWX_DB) {
+    return process.env.CREWX_TRACES_DB || process.env.CREWX_DB;
+  }
+
+  return path.join(os.homedir(), '.crewx', 'crewx.db');
+}
+
+// Backward-compatible alias
+const getTracesDbPath = getDbPath;
+
+/**
+ * crewx.db 연결 및 테이블 확인
+ * Returns null if better-sqlite3 is unavailable or DB cannot be opened.
+ */
+function getDb() {
+  if (!Database) return null;
+
+  const dbPath = getDbPath();
+  const dir = path.dirname(dbPath);
+
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+
+  const db = new Database(dbPath);
+  db.pragma('journal_mode = WAL');
+
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS tasks (
+      id TEXT PRIMARY KEY,
+      agent_id TEXT NOT NULL,
+      user_id TEXT,
+      prompt TEXT NOT NULL,
+      mode TEXT NOT NULL DEFAULT 'execute',
+      status TEXT NOT NULL DEFAULT 'running',
+      result TEXT,
+      error TEXT,
+      started_at TEXT NOT NULL,
+      completed_at TEXT,
+      duration_ms INTEGER,
+      metadata TEXT,
+      project_id TEXT,
+      project_name TEXT
+    )
+  `);
+
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS spans (
+      id TEXT PRIMARY KEY,
+      task_id TEXT,
+      parent_span_id TEXT,
+      name TEXT NOT NULL,
+      kind TEXT NOT NULL DEFAULT 'internal',
+      status TEXT NOT NULL DEFAULT 'ok',
+      started_at TEXT NOT NULL,
+      completed_at TEXT,
+      duration_ms INTEGER,
+      input TEXT,
+      output TEXT,
+      error TEXT,
+      attributes TEXT,
+      FOREIGN KEY (task_id) REFERENCES tasks(id) ON DELETE SET NULL,
+      FOREIGN KEY (parent_span_id) REFERENCES spans(id) ON DELETE SET NULL
+    )
+  `);
+
+  ensureProjectColumns(db);
+  ensureSpansTaskIdNullable(db);
+
+  return db;
+}
+
+function ensureProjectColumns(db) {
+  try {
+    const columns = db.prepare('PRAGMA table_info(tasks)').all().map((col) => col.name);
+    if (!columns.includes('project_id')) {
+      db.exec(`ALTER TABLE tasks ADD COLUMN project_id TEXT`);
+    }
+    if (!columns.includes('project_name')) {
+      db.exec(`ALTER TABLE tasks ADD COLUMN project_name TEXT`);
+    }
+    db.exec(`CREATE INDEX IF NOT EXISTS idx_tasks_project_id ON tasks(project_id)`);
+  } catch {
+    // Best-effort; ignore failures
+  }
+}
+
+function ensureSpansTaskIdNullable(db) {
+  try {
+    const columns = db.prepare('PRAGMA table_info(spans)').all();
+    const taskIdColumn = columns.find((col) => col.name === 'task_id');
+    if (!taskIdColumn || taskIdColumn.notnull === 0) {
+      return;
+    }
+
+    db.exec('PRAGMA foreign_keys = OFF');
+    db.exec('BEGIN');
+    db.exec(`
+      CREATE TABLE spans_backup (
+        id TEXT PRIMARY KEY,
+        task_id TEXT,
+        parent_span_id TEXT,
+        name TEXT NOT NULL,
+        kind TEXT NOT NULL DEFAULT 'internal',
+        status TEXT NOT NULL DEFAULT 'ok',
+        started_at TEXT NOT NULL,
+        completed_at TEXT,
+        duration_ms INTEGER,
+        input TEXT,
+        output TEXT,
+        error TEXT,
+        attributes TEXT,
+        FOREIGN KEY (task_id) REFERENCES tasks(id) ON DELETE SET NULL,
+        FOREIGN KEY (parent_span_id) REFERENCES spans_backup(id) ON DELETE SET NULL
+      )
+    `);
+    db.exec(`
+      INSERT INTO spans_backup (
+        id, task_id, parent_span_id, name, kind, status, started_at,
+        completed_at, duration_ms, input, output, error, attributes
+      )
+      SELECT
+        id, task_id, parent_span_id, name, kind, status, started_at,
+        completed_at, duration_ms, input, output, error, attributes
+      FROM spans
+    `);
+    db.exec('DROP TABLE spans');
+    db.exec('ALTER TABLE spans_backup RENAME TO spans');
+    db.exec('COMMIT');
+    db.exec('PRAGMA foreign_keys = ON');
+  } catch {
+    try {
+      db.exec('ROLLBACK');
+    } catch {
+      // Best-effort rollback
+    }
+    try {
+      db.exec('PRAGMA foreign_keys = ON');
+    } catch {
+      // Best-effort; ignore failures
+    }
+  }
+}
+
+function resolveProjectContext() {
+  const projectPath = path.resolve(process.cwd());
+  return {
+    projectId: createHash('sha256').update(normalizeProjectPath(projectPath)).digest('hex'),
+    projectName: resolveProjectName(projectPath),
+  };
+}
+
+function normalizeProjectPath(projectPath) {
+  let resolved = path.resolve(projectPath);
+  if (process.platform === 'win32') {
+    resolved = resolved.replace(/\\/g, '/');
+    resolved = resolved.replace(/^([A-Z]):/, (match, drive) => `${drive.toLowerCase()}:`);
+  }
+
+  if (resolved.length > 1 && !/^[a-zA-Z]:\/$/.test(resolved)) {
+    resolved = resolved.replace(/\/+$/, '');
+  }
+
+  return resolved;
+}
+
+function resolveProjectName(projectPath) {
+  const gitConfigPath = path.join(projectPath, '.git', 'config');
+  if (fs.existsSync(gitConfigPath)) {
+    try {
+      const config = fs.readFileSync(gitConfigPath, 'utf-8');
+      const match = config.match(/\[remote\s+"[^"]+"\][^\[]*?url\s*=\s*(.+)/m);
+      if (match && match[1]) {
+        return extractRepoName(match[1].trim());
+      }
+    } catch {
+      // Fall back to basename
+    }
+  }
+
+  return path.basename(projectPath);
+}
+
+function extractRepoName(remoteUrl) {
+  const cleaned = remoteUrl.replace(/\.git$/i, '');
+  const parts = cleaned.split(/[/:]/).filter(Boolean);
+  return parts[parts.length - 1] || 'unknown';
+}
+
+/**
+ * 로컬 타임스탬프 (usage.log용)
+ */
+function getLocalTimestamp() {
+  const now = new Date();
+  const y = now.getFullYear();
+  const m = String(now.getMonth() + 1).padStart(2, '0');
+  const d = String(now.getDate()).padStart(2, '0');
+  const h = String(now.getHours()).padStart(2, '0');
+  const min = String(now.getMinutes()).padStart(2, '0');
+  const s = String(now.getSeconds()).padStart(2, '0');
+  return `${y}-${m}-${d} ${h}:${min}:${s}`;
+}
+
+/**
+ * usage.log에 기록
+ */
+function logToUsageFile(logPath, skillName, command) {
+  const timestamp = getLocalTimestamp();
+  const line = `${timestamp} | [${skillName}] ${command}\n`;
+  fs.appendFileSync(logPath, line);
+}
+
+/**
+ * 스킬 실행 추적 시작
+ *
+ * @param {string} skillName - 스킬 이름 (예: 'memory-v2')
+ * @param {string} command - 실행 명령어 (예: 'save agent1 test')
+ * @param {object} [options] - 옵션
+ * @param {string} [options.agentId] - 에이전트 ID
+ * @param {string} [options.usageLog] - usage.log 파일 경로 (지정하면 파일 로그도 남김)
+ * @param {boolean} [options.tracesDb=true] - crewx.db 기록 여부
+ * @returns {{ taskId: string, ok: (result?: string) => void, fail: (error: string) => void }}
+ */
+function trace(skillName, command, options = {}) {
+  const {
+    agentId,
+    usageLog,
+    tracesDb = true
+  } = typeof options === 'string' ? { agentId: options } : options;
+
+  // usage.log 기록 (항상, 중복 상관없이)
+  if (usageLog) {
+    logToUsageFile(usageLog, skillName, command);
+  }
+
+  // CREWX_NO_TRACE=1: skip trace recording (usage log still recorded above)
+  if (process.env.CREWX_NO_TRACE === '1') {
+    return {
+      taskId: 'no-trace',
+      ok: () => {},
+      fail: () => {},
+      _skipped: true
+    };
+  }
+
+  // crewx.db 기록 비활성화된 경우
+  if (!tracesDb) {
+    return {
+      taskId: 'no-trace',
+      ok: () => {},
+      fail: () => {},
+      _skipped: true
+    };
+  }
+
+  let db;
+  try {
+    db = getDb();
+  } catch {
+    db = null;
+  }
+
+  if (!db) {
+    return {
+      taskId: null,
+      ok: () => {},
+      fail: () => {},
+      _skipped: true
+    };
+  }
+  const now = new Date().toISOString();
+  const resolvedAgentId = agentId || process.env.CREWX_AGENT_ID || 'direct';
+
+  // crewx skill x로 실행된 경우 → spans 테이블에 child span으로 기록
+  const parentTaskId = process.env.CREWX_TASK_ID;
+  if (parentTaskId && parentTaskId.trim() !== '') {
+    const spanId = randomUUID();
+    const attributes = JSON.stringify({
+      skill: skillName,
+      agent_id: resolvedAgentId,
+      tracer_version: '0.3.0'
+    });
+
+    db.prepare(`
+      INSERT INTO spans (id, task_id, name, kind, status, started_at, input, attributes)
+      VALUES (?, ?, ?, 'internal', 'ok', ?, ?, ?)
+    `).run(spanId, parentTaskId, `[skill:${skillName}] ${command}`, now, command, attributes);
+
+    return {
+      taskId: parentTaskId,
+      spanId,
+      ok: (result) => {
+        const completedAt = new Date().toISOString();
+        db.prepare(`
+          UPDATE spans
+          SET status = 'ok',
+              output = ?,
+              completed_at = ?,
+              duration_ms = CAST((julianday(?) - julianday(started_at)) * 86400000 AS INTEGER)
+          WHERE id = ?
+        `).run(result || null, completedAt, completedAt, spanId);
+        db.close();
+      },
+      fail: (error) => {
+        const completedAt = new Date().toISOString();
+        db.prepare(`
+          UPDATE spans
+          SET status = 'error',
+              error = ?,
+              completed_at = ?,
+              duration_ms = CAST((julianday(?) - julianday(started_at)) * 86400000 AS INTEGER)
+          WHERE id = ?
+        `).run(error, completedAt, completedAt, spanId);
+        db.close();
+      },
+      _skipped: false
+    };
+  }
+
+  // 직접 호출 (독립 실행) → spans 테이블에 task_id=NULL로 기록
+  const spanId = randomUUID();
+  const attributes = JSON.stringify({
+    skill: skillName,
+    agent_id: resolvedAgentId,
+    direct_call: true,
+    tracer_version: '0.3.0'
+  });
+
+  db.prepare(`
+    INSERT INTO spans (id, task_id, name, kind, status, started_at, input, attributes)
+    VALUES (?, NULL, ?, 'internal', 'ok', ?, ?, ?)
+  `).run(spanId, `[skill:${skillName}] ${command}`, now, command, attributes);
+
+  return {
+    taskId: null,
+    spanId,
+    ok: (result) => {
+      const completedAt = new Date().toISOString();
+      db.prepare(`
+        UPDATE spans
+        SET status = 'ok',
+            output = ?,
+            completed_at = ?,
+            duration_ms = CAST((julianday(?) - julianday(started_at)) * 86400000 AS INTEGER)
+        WHERE id = ?
+      `).run(result || null, completedAt, completedAt, spanId);
+      db.close();
+    },
+    fail: (error) => {
+      const completedAt = new Date().toISOString();
+      db.prepare(`
+        UPDATE spans
+        SET status = 'error',
+            error = ?,
+            completed_at = ?,
+            duration_ms = CAST((julianday(?) - julianday(started_at)) * 86400000 AS INTEGER)
+        WHERE id = ?
+      `).run(error, completedAt, completedAt, spanId);
+      db.close();
+    },
+    _skipped: false
+  };
+}
+
+/**
+ * 스킬 실행 래퍼 (권장)
+ * try/catch, trace 시작/종료 자동 처리
+ *
+ * @param {string} skillName - 스킬 이름
+ * @param {() => Promise<any>} fn - 실행할 함수
+ * @param {object} [options] - 옵션
+ * @param {string} [options.usageLog] - usage.log 파일 경로
+ * @param {boolean} [options.tracesDb=true] - crewx.db 기록 여부
+ * @returns {Promise<any>}
+ *
+ * @example
+ * // 둘 다 기록
+ * run('memory-v2', main, {
+ *   usageLog: path.join(__dirname, 'usage.log'),
+ *   tracesDb: true
+ * });
+ *
+ * // usage.log만
+ * run('memory-v2', main, {
+ *   usageLog: path.join(__dirname, 'usage.log'),
+ *   tracesDb: false
+ * });
+ *
+ * // crewx.db만 (기본)
+ * run('memory-v2', main);
+ */
+async function run(skillName, fn, options = {}) {
+  const command = process.argv.slice(2).join(' ');
+  const t = trace(skillName, command, options);
+
+  try {
+    const result = await fn();
+    const resultStr = result !== undefined ? JSON.stringify(result) : null;
+    t.ok(resultStr);
+    return result;
+  } catch (e) {
+    t.fail(e.message || String(e));
+    throw e;
+  }
+}
+
+module.exports = { trace, run, getDbPath, getTracesDbPath };

package/test-tracer.js

@@ -0,0 +1,54 @@
+/**
+ * skill-tracer 테스트
+ */
+
+const { trace, run, getDbPath } = require('./skill-tracer');
+
+console.log('=== skill-tracer PoC Test ===\n');
+console.log('crewx.db path:', getDbPath());
+
+// 테스트 1: trace() 수동 사용
+console.log('\n[Test 1] trace() 수동 사용');
+const t = trace('test-skill', 'manual test command', 'test-agent');
+console.log('taskId:', t.taskId);
+console.log('skipped:', t._skipped);
+t.ok('test result');
+console.log('-> 완료\n');
+
+// 테스트 2: run() 래퍼 사용 (성공)
+console.log('[Test 2] run() 래퍼 - 성공 케이스');
+run('test-skill', async () => {
+  console.log('-> 함수 실행 중...');
+  return { status: 'success', data: 123 };
+}).then(() => {
+  console.log('-> 완료\n');
+
+  // 테스트 3: run() 래퍼 사용 (실패)
+  console.log('[Test 3] run() 래퍼 - 실패 케이스');
+  return run('test-skill', async () => {
+    throw new Error('의도적 에러');
+  }).catch(e => {
+    console.log('-> 에러 캡처됨:', e.message);
+    console.log('-> 완료\n');
+  });
+}).then(() => {
+  // 결과 확인
+  console.log('=== crewx.db 확인 ===');
+  const Database = require('better-sqlite3');
+  const db = new Database(getDbPath());
+  const rows = db.prepare(`
+    SELECT id, agent_id, prompt, status, duration_ms
+    FROM tasks
+    WHERE prompt LIKE '%test-skill%'
+    ORDER BY started_at DESC
+    LIMIT 5
+  `).all();
+
+  console.log('\n최근 test-skill 기록:');
+  rows.forEach(r => {
+    console.log(`  [${r.status}] ${r.prompt.substring(0, 50)}... (${r.duration_ms}ms)`);
+  });
+
+  db.close();
+  console.log('\n=== 테스트 완료 ===');
+});