@team-semicolon/semo-cli 4.1.4 → 4.2.0

package/dist/commands/context.js

@@ -1,9 +1,11 @@
 "use strict";
 /**
- * semo context — DB ↔ .claude/memory/ 동기화
+ * semo context — 스킬/캐시/크론잡 동기화
  *
- * sync: Core DB → .claude/memory/*.md (KB domains, bot_status, ontology, projects)
- * push: .claude/memory/decisions.md → DB (semo.knowledge_base WHERE domain='decision')
+ * sync: DB → 글로벌 캐시 (skills/commands/agents) + 스킬 DB 동기화 + 크론잡
+ * push: .claude/memory/<domain>.md → DB (deprecated — kb_upsert MCP 도구로 대체)
+ *
+ * [v4.2.0] KB→md 파일 생성 제거 — semo-kb MCP 서버로 통일
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -42,24 +44,29 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncCronJobs = syncCronJobs;
 exports.registerContextCommands = registerContextCommands;
 const chalk_1 = __importDefault(require("chalk"));
 const ora_1 = __importDefault(require("ora"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const os = __importStar(require("os"));
 const database_1 = require("../database");
 const kb_1 = require("../kb");
+const skill_sync_1 = require("./skill-sync");
+const global_cache_1 = require("../global-cache");
 // ============================================================
 // Memory file mapping
 // ============================================================
 const MEMORY_DIR = ".claude/memory";
 // --out-dir 로 override 가능 (OpenClaw 봇 workspace 경로 지원)
+// 기본값: ~/.claude/memory/ (글로벌 — 모든 프로젝트에서 공유)
 function resolveMemoryDir(outDir) {
     if (outDir) {
         // 절대경로 또는 ~ 경로 처리
         return outDir.replace(/^~/, require("os").homedir());
     }
-    return path.join(process.cwd(), MEMORY_DIR);
+    return path.join(require("os").homedir(), MEMORY_DIR);
 }
 const KB_DOMAIN_MAP = {
     team: "team.md",
@@ -75,78 +82,82 @@ function ensureMemoryDir(resolvedDir) {
     fs.mkdirSync(resolvedDir, { recursive: true });
     return resolvedDir;
 }
-function kbEntriesToMarkdown(domain, entries) {
-    if (entries.length === 0) {
-        return `# ${domain}\n\n_No entries._\n`;
-    }
-    const lines = [`# ${domain}\n`, `> 자동 생성: semo context sync (${new Date().toISOString()})\n`];
-    for (const entry of entries) {
-        lines.push(`\n## ${entry.key}\n`);
-        lines.push(entry.content);
-        if (entry.metadata && Object.keys(entry.metadata).length > 0) {
-            lines.push(`\n_metadata: ${JSON.stringify(entry.metadata)}_`);
-        }
-        lines.push("");
-    }
-    return lines.join("\n");
-}
-function botStatusToMarkdown(rows) {
-    if (rows.length === 0) {
-        return "# Bots\n\n_No bot status data._\n";
+function parseCronJobsFile(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, "utf-8");
+        const data = JSON.parse(content);
+        const jobs = data.jobs || [];
+        return jobs.map((job) => ({
+            jobId: job.jobId || job.id,
+            name: job.name || "",
+            schedule: job.schedule || {},
+            enabled: job.enabled !== false,
+            lastRun: job.lastRun || null,
+            nextRun: job.nextRun || null,
+            sessionTarget: job.sessionTarget || "main",
+            payload: job.payload || null,
+        }));
     }
-    const lines = [
-        "# Bots\n",
-        `> 자동 생성: semo context sync (${new Date().toISOString()})\n`,
-        "| Bot | 이름 | 역할 | Status | Last Active | Sessions |",
-        "|-----|------|------|--------|-------------|----------|",
-    ];
-    for (const bot of rows) {
-        const status = bot.status === "online" ? "🟢 online" : "🔴 offline";
-        const lastActive = bot.last_active ? new Date(bot.last_active).toLocaleString("ko-KR") : "-";
-        const displayName = [bot.emoji, bot.name].filter(Boolean).join(" ") || bot.bot_id;
-        lines.push(`| ${bot.bot_id} | ${displayName} | ${bot.role || "-"} | ${status} | ${lastActive} | ${bot.session_count} |`);
+    catch {
+        return [];
     }
-    return lines.join("\n") + "\n";
 }
-function ontologyToMarkdown(domains) {
-    if (domains.length === 0) {
-        return "# Ontology\n\n_No ontology domains._\n";
+function getOpenClawBotIds() {
+    const homeDir = os.homedir();
+    try {
+        return fs.readdirSync(homeDir)
+            .filter(f => f.startsWith(".openclaw-"))
+            .map(f => f.replace(".openclaw-", ""));
     }
-    const lines = [
-        "# Ontology\n",
-        `> 자동 생성: semo context sync (${new Date().toISOString()})\n`,
-    ];
-    for (const d of domains) {
-        lines.push(`\n## ${d.domain} (v${d.version})\n`);
-        if (d.description)
-            lines.push(`${d.description}\n`);
-        lines.push("```json");
-        lines.push(JSON.stringify(d.schema, null, 2));
-        lines.push("```\n");
+    catch {
+        return [];
     }
-    return lines.join("\n");
 }
-async function fetchBotStatus(pool) {
+/**
+ * Collect cron jobs from all ~/.openclaw-* directories and upsert to semo.bot_cron_jobs.
+ * Uses DELETE + INSERT per bot (same pattern as sync-agent).
+ */
+async function syncCronJobs(pool) {
+    const homeDir = os.homedir();
+    const botIds = getOpenClawBotIds();
+    let totalJobs = 0;
+    let syncedBots = 0;
     const client = await pool.connect();
     try {
-        const result = await client.query(`
-      SELECT bot_id, name, emoji, role, status, last_active::text, session_count
-      FROM semo.bot_status
-      ORDER BY bot_id
-    `);
-        return result.rows;
-    }
-    catch {
-        return [];
+        for (const botId of botIds) {
+            const cronPath = path.join(homeDir, `.openclaw-${botId}`, "cron", "jobs.json");
+            const jobs = parseCronJobsFile(cronPath);
+            // Always delete old entries (handles removed jobs)
+            await client.query("DELETE FROM semo.bot_cron_jobs WHERE bot_id = $1", [botId]);
+            for (const job of jobs) {
+                await client.query(`INSERT INTO semo.bot_cron_jobs
+             (bot_id, job_id, name, schedule, enabled, last_run, next_run, session_target, payload, synced_at)
+           VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, NOW())`, [
+                    botId,
+                    job.jobId,
+                    job.name,
+                    JSON.stringify(job.schedule),
+                    job.enabled,
+                    job.lastRun,
+                    job.nextRun,
+                    job.sessionTarget,
+                    job.payload ? JSON.stringify(job.payload) : null,
+                ]);
+            }
+            totalJobs += jobs.length;
+            if (jobs.length > 0)
+                syncedBots++;
+        }
     }
     finally {
         client.release();
     }
+    return { bots: syncedBots, jobs: totalJobs };
 }
 // ============================================================
 // Markdown → KBEntry parser (for push)
 // ============================================================
-function parseDecisionsMarkdown(content) {
+function parseMarkdownSections(content, domain) {
     const entries = [];
     // Split by h2 sections
     const sections = content.split(/\n##\s+/);
@@ -159,7 +170,7 @@ function parseDecisionsMarkdown(content) {
         const body = section.substring(firstNewline + 1).trim();
         if (key && body) {
             entries.push({
-                domain: "decision",
+                domain,
                 key,
                 content: body,
                 created_by: "claude-context-push",
@@ -168,22 +179,21 @@ function parseDecisionsMarkdown(content) {
     }
     return entries;
 }
+// [v4.2.0] digestToMarkdown 제거 — MCP kb_digest로 대체
 // ============================================================
 // Commands
 // ============================================================
 function registerContextCommands(program) {
     const ctxCmd = program
         .command("context")
-        .description("Core DB ↔ .claude/memory/ 컨텍스트 동기화");
+        .description("스킬/캐시/크론잡 동기화 (KB는 semo-kb MCP 서버)");
     // ── semo context sync ──────────────────────────────────────
     ctxCmd
         .command("sync")
-        .description("Core DB → .claude/memory/ 파일 생성")
-        .option("--bot <name>", "봇 ID (bot_status 필터)")
-        .option("--domain <name>", "특정 KB 도메인만")
-        .option("--no-bots", "bot_status 동기화 건너뜀")
-        .option("--no-ontology", "ontology 동기화 건너뜀")
-        .option("--out-dir <path>", "메모리 파일 출력 경로 (기본: .claude/memory/). OpenClaw 봇 workspace 지원용")
+        .description("스킬/에이전트/캐시 동기화 + 크론잡 (KB는 semo-kb MCP 서버 사용)")
+        .option("--no-skills", "스킬 파일 → DB 동기화 건너뜀")
+        .option("--out-dir <path>", "캐시 파일 출력 경로 (기본: .claude/memory/)")
+        .option("--no-global-cache", "글로벌 캐시(skills/commands/agents) 동기화 건너뜀")
         .action(async (options) => {
         const spinner = (0, ora_1.default)("context sync 시작...").start();
         const connected = await (0, database_1.isDbConnected)();
@@ -194,40 +204,75 @@ function registerContextCommands(program) {
         }
         const pool = (0, database_1.getPool)();
         const memDir = ensureMemoryDir(resolveMemoryDir(options.outDir));
-        let written = 0;
         try {
-            // 1. KB domains → memory/*.md
-            const domains = options.domain ? [options.domain] : Object.keys(KB_DOMAIN_MAP);
-            for (const domain of domains) {
-                spinner.text = `KB 동기화: ${domain}...`;
+            // [v4.2.0] KB→md 파일 생성 제거 — MCP kb_search/kb_list/kb_bot_status/kb_ontology로 대체
+            // 기존 memory/*.md (team, projects, decisions, infra, process, bots, ontology) 파일은
+            // semo-kb MCP 서버가 실시간 DB 조회로 대체합니다.
+            // 1. 스킬 파일 → skill_definitions DB 동기화
+            if (options.skills !== false) {
+                const semoSystemDir = path.join(process.cwd(), "semo-system");
+                if (fs.existsSync(semoSystemDir)) {
+                    spinner.text = "skills 동기화...";
+                    const client = await pool.connect();
+                    try {
+                        await client.query("BEGIN");
+                        await (0, skill_sync_1.syncSkillsToDB)(client, semoSystemDir);
+                        await client.query("COMMIT");
+                    }
+                    catch {
+                        await client.query("ROLLBACK").catch(() => { });
+                        // 스킬 동기화 실패는 무시 — context sync의 핵심은 memory/ 파일
+                    }
+                    finally {
+                        client.release();
+                    }
+                }
+            }
+            // 2. DB → 글로벌 캐시 (skills/commands/agents → ~/.claude/)
+            if (options.globalCache !== false) {
+                spinner.text = "글로벌 캐시 동기화 (skills/commands/agents)...";
                 try {
-                    const { shared } = await (0, kb_1.kbList)(pool, { domain, limit: 1000 });
-                    const filename = KB_DOMAIN_MAP[domain] || `${domain}.md`;
-                    const content = kbEntriesToMarkdown(domain, shared);
-                    fs.writeFileSync(path.join(memDir, filename), content);
-                    written++;
+                    const cacheResult = await (0, global_cache_1.syncGlobalCache)();
+                    console.log(chalk_1.default.green(`  ✓ 글로벌 캐시: skills(${cacheResult.skills}) commands(${cacheResult.commands}) agents(${cacheResult.agents})`));
                 }
-                catch {
-                    // domain may not exist — skip silently
+                catch (cacheErr) {
+                    // DB 실패 시 기존 파일 유지 (비치명적)
+                    console.log(chalk_1.default.yellow(`  ⚠ 글로벌 캐시 동기화 실패 (기존 파일 유지): ${cacheErr}`));
                 }
             }
-            // 2. bot_status → memory/bots.md
-            if (options.bots !== false) {
-                spinner.text = "bot_status 동기화...";
-                const botRows = await fetchBotStatus(pool);
-                const botsContent = botStatusToMarkdown(botRows);
-                fs.writeFileSync(path.join(memDir, "bots.md"), botsContent);
-                written++;
+            // 3. 크론잡 동기화 (local → DB)
+            try {
+                spinner.text = "크론잡 동기화...";
+                const cronResult = await syncCronJobs(pool);
+                if (cronResult.jobs > 0) {
+                    console.log(chalk_1.default.green(`  ✓ 크론잡: ${cronResult.bots}개 봇, ${cronResult.jobs}개 잡 동기화`));
+                }
+            }
+            catch {
+                // 크론잡 동기화 실패는 비치명적
+            }
+            // [v4.2.0] KB Digest 제거 — MCP kb_digest로 대체
+            // 4. MCP 서버 자동 등록 (.claude/settings.json)
+            try {
+                const semoRoot = process.cwd();
+                const settingsPath = path.join(memDir, "..", "settings.json");
+                if (fs.existsSync(settingsPath)) {
+                    const settings = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+                    if (!settings.mcpServers?.["semo-kb"]) {
+                        settings.mcpServers = settings.mcpServers || {};
+                        settings.mcpServers["semo-kb"] = {
+                            command: "node",
+                            args: [path.join(semoRoot, "packages/mcp-kb/dist/index.js")],
+                        };
+                        fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+                        console.log(chalk_1.default.green("  ✓ semo-kb MCP 서버 자동 등록"));
+                    }
+                }
             }
-            // 3. ontology → memory/ontology.md
-            if (options.ontology !== false) {
-                spinner.text = "ontology 동기화...";
-                const domains2 = await (0, kb_1.ontoList)(pool);
-                const ontoContent = ontologyToMarkdown(domains2);
-                fs.writeFileSync(path.join(memDir, "ontology.md"), ontoContent);
-                written++;
+            catch {
+                // MCP 자동 등록 실패는 비치명적
             }
-            spinner.succeed(`context sync 완료 — ${written}개 파일 업데이트`);
+            spinner.succeed("context sync 완료 — 스킬/캐시/크론잡 동기화");
             console.log(chalk_1.default.gray(`  저장 위치: ${memDir}`));
         }
         catch (err) {
@@ -240,28 +285,35 @@ function registerContextCommands(program) {
     // ── semo context push ──────────────────────────────────────
     ctxCmd
         .command("push")
-        .description(".claude/memory/decisions.md → Core DB (semo.knowledge_base)")
-        .option("--domain <name>", "push할 도메인 (기본: decision)", "decision")
+        .description(".claude/memory/<domain>.md → Core DB (semo.knowledge_base)")
+        .option("--domain <name>", "push할 도메인 (쉼표 구분 가능, 기본: decision)", "decision")
         .option("--dry-run", "실제 push 없이 변경사항만 미리보기")
         .option("--out-dir <path>", "메모리 파일 경로 (기본: .claude/memory/). OpenClaw 봇 workspace 지원용")
         .action(async (options) => {
+        console.log(chalk_1.default.yellow("⚠️  [deprecated] context push는 kb_upsert MCP 도구로 대체 예정입니다."));
+        console.log(chalk_1.default.yellow("   봇/세션에서는 semo-kb MCP 서버의 kb_upsert 도구를 직접 사용하세요.\n"));
+        const domains = options.domain.split(",").map((d) => d.trim()).filter(Boolean);
         const memDir = resolveMemoryDir(options.outDir);
-        const filename = KB_DOMAIN_MAP[options.domain] || `${options.domain}.md`;
-        const filePath = path.join(memDir, filename);
-        if (!fs.existsSync(filePath)) {
-            console.log(chalk_1.default.red(`\n❌ 파일 없음: ${MEMORY_DIR}/${filename}`));
-            console.log(chalk_1.default.gray("  semo context sync 먼저 실행하세요."));
-            process.exit(1);
+        // 각 도메인별 엔트리 수집
+        const allEntries = [];
+        for (const domain of domains) {
+            const filename = KB_DOMAIN_MAP[domain] || `${domain}.md`;
+            const filePath = path.join(memDir, filename);
+            if (!fs.existsSync(filePath)) {
+                console.log(chalk_1.default.yellow(`⚠️  파일 없음 (건너뜀): ${MEMORY_DIR}/${filename}`));
+                continue;
+            }
+            const content = fs.readFileSync(filePath, "utf-8");
+            const entries = parseMarkdownSections(content, domain);
+            allEntries.push(...entries);
         }
-        const content = fs.readFileSync(filePath, "utf-8");
-        const entries = parseDecisionsMarkdown(content);
-        if (entries.length === 0) {
+        if (allEntries.length === 0) {
             console.log(chalk_1.default.yellow("⚠️  push할 항목이 없습니다."));
             return;
         }
-        console.log(chalk_1.default.cyan(`\n📤 context push: ${options.domain} (${entries.length}건)\n`));
+        console.log(chalk_1.default.cyan(`\n📤 context push: ${domains.join(", ")} (${allEntries.length}건)\n`));
         if (options.dryRun) {
-            for (const e of entries) {
+            for (const e of allEntries) {
                 console.log(chalk_1.default.gray(`  [dry-run] ${e.domain}/${e.key}`));
             }
             return;
@@ -277,14 +329,41 @@ function registerContextCommands(program) {
         let upserted = 0;
         const errors = [];
         try {
+            // Domain validation: check all domains against ontology
+            const ontologyResult = await client.query("SELECT domain FROM semo.ontology");
+            const knownDomains = new Set(ontologyResult.rows.map((r) => r.domain));
+            const validEntries = [];
+            for (const entry of allEntries) {
+                if (knownDomains.has(entry.domain)) {
+                    validEntries.push(entry);
+                }
+                else {
+                    errors.push(`${entry.domain}/${entry.key}: 미등록 도메인 '${entry.domain}' (등록된 도메인: ${Array.from(knownDomains).join(', ')})`);
+                }
+            }
+            if (validEntries.length === 0 && errors.length > 0) {
+                spinner.fail("모든 엔트리가 도메인 검증에 실패했습니다.");
+                errors.forEach(e => console.log(chalk_1.default.red(`  ❌ ${e}`)));
+                client.release();
+                await (0, database_1.closeConnection)();
+                return;
+            }
+            // Generate embeddings for all valid entries
+            spinner.text = "임베딩 생성 중...";
+            const texts = validEntries.map(e => `${e.key}: ${e.content}`);
+            const embeddings = await (0, kb_1.generateEmbeddings)(texts);
             await client.query("BEGIN");
-            for (const entry of entries) {
+            for (let i = 0; i < validEntries.length; i++) {
+                const entry = validEntries[i];
                 try {
-                    await client.query(`INSERT INTO semo.knowledge_base (domain, key, content, metadata, created_by)
-               VALUES ($1, $2, $3, $4, $5)
+                    const embedding = embeddings[i];
+                    const embeddingStr = embedding ? `[${embedding.join(",")}]` : null;
+                    await client.query(`INSERT INTO semo.knowledge_base (domain, key, content, metadata, created_by, embedding)
+               VALUES ($1, $2, $3, $4, $5, $6::vector)
                ON CONFLICT (domain, key) DO UPDATE SET
                  content = EXCLUDED.content,
-                 metadata = EXCLUDED.metadata`, [entry.domain, entry.key, entry.content, JSON.stringify(entry.metadata || {}), entry.created_by]);
+                 metadata = EXCLUDED.metadata,
+                 embedding = COALESCE(EXCLUDED.embedding, semo.knowledge_base.embedding)`, [entry.domain, entry.key, entry.content, JSON.stringify(entry.metadata || {}), entry.created_by, embeddingStr]);
                     upserted++;
                 }
                 catch (err) {
@@ -292,7 +371,7 @@ function registerContextCommands(program) {
                 }
             }
             await client.query("COMMIT");
-            spinner.succeed(`push 완료: ${upserted}건 업서트`);
+            spinner.succeed(`push 완료: ${upserted}건 업서트 (임베딩 ${process.env.OPENAI_API_KEY ? '생성됨' : '건너뜀'})`);
             if (errors.length > 0) {
                 errors.forEach(e => console.log(chalk_1.default.red(`  ❌ ${e}`)));
             }

package/dist/commands/db.d.ts

@@ -0,0 +1,9 @@
+/**
+ * semo db — 데이터베이스 관리
+ *
+ * semo db migrate          — 마이그레이션 실행
+ * semo db migrate --status — 적용된 마이그레이션 목록
+ * semo db migrate --dry-run — 미적용 마이그레이션 미리보기
+ */
+import { Command } from "commander";
+export declare function registerDbCommands(program: Command): void;

package/dist/commands/db.js

@@ -0,0 +1,189 @@
+"use strict";
+/**
+ * semo db — 데이터베이스 관리
+ *
+ * semo db migrate          — 마이그레이션 실행
+ * semo db migrate --status — 적용된 마이그레이션 목록
+ * semo db migrate --dry-run — 미적용 마이그레이션 미리보기
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerDbCommands = registerDbCommands;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const database_1 = require("../database");
+// ============================================================
+// Migration runner
+// ============================================================
+const MIGRATIONS_DIR = path.resolve(__dirname, "..", "..", "migrations");
+/**
+ * schema_migrations 테이블이 없으면 생성
+ */
+async function ensureMigrationsTable() {
+    const pool = (0, database_1.getPool)();
+    await pool.query(`
+    CREATE TABLE IF NOT EXISTS semo.schema_migrations (
+      version TEXT PRIMARY KEY,
+      applied_at TIMESTAMPTZ DEFAULT NOW()
+    );
+  `);
+}
+/**
+ * 이미 적용된 마이그레이션 버전 목록
+ */
+async function getAppliedMigrations() {
+    const pool = (0, database_1.getPool)();
+    const { rows } = await pool.query(`SELECT version, applied_at::text FROM semo.schema_migrations ORDER BY version`);
+    return rows;
+}
+/**
+ * migrations/ 디렉터리에서 SQL 파일 목록 (정렬)
+ */
+function getMigrationFiles() {
+    if (!fs.existsSync(MIGRATIONS_DIR))
+        return [];
+    return fs
+        .readdirSync(MIGRATIONS_DIR)
+        .filter((f) => f.endsWith(".sql"))
+        .sort();
+}
+/**
+ * 단일 마이그레이션 실행 (트랜잭션)
+ */
+async function runMigration(filename) {
+    const pool = (0, database_1.getPool)();
+    const client = await pool.connect();
+    const filePath = path.join(MIGRATIONS_DIR, filename);
+    const sql = fs.readFileSync(filePath, "utf-8");
+    const version = filename.replace(/\.sql$/, "");
+    try {
+        await client.query("BEGIN");
+        await client.query(sql);
+        await client.query(`INSERT INTO semo.schema_migrations (version) VALUES ($1)`, [version]);
+        await client.query("COMMIT");
+    }
+    catch (err) {
+        await client.query("ROLLBACK");
+        throw err;
+    }
+    finally {
+        client.release();
+    }
+}
+// ============================================================
+// Command registration
+// ============================================================
+function registerDbCommands(program) {
+    const dbCmd = program
+        .command("db")
+        .description("데이터베이스 관리");
+    dbCmd
+        .command("migrate")
+        .description("마이그레이션 실행")
+        .option("--status", "적용된 마이그레이션 목록만 표시")
+        .option("--dry-run", "미적용 마이그레이션 미리보기 (실행하지 않음)")
+        .action(async (options) => {
+        const connected = await (0, database_1.isDbConnected)();
+        if (!connected) {
+            console.error(chalk_1.default.red("DB 연결 실패"));
+            await (0, database_1.closeConnection)();
+            process.exit(1);
+        }
+        try {
+            await ensureMigrationsTable();
+            const applied = await getAppliedMigrations();
+            const appliedSet = new Set(applied.map((r) => r.version));
+            const allFiles = getMigrationFiles();
+            // --status: 적용 상태만 출력
+            if (options.status) {
+                if (applied.length === 0) {
+                    console.log(chalk_1.default.yellow("적용된 마이그레이션 없음"));
+                }
+                else {
+                    console.log(chalk_1.default.cyan("적용된 마이그레이션:"));
+                    for (const r of applied) {
+                        console.log(`  ${chalk_1.default.green("✓")} ${r.version}  ${chalk_1.default.gray(r.applied_at)}`);
+                    }
+                }
+                const pending = allFiles.filter((f) => !appliedSet.has(f.replace(/\.sql$/, "")));
+                if (pending.length > 0) {
+                    console.log(chalk_1.default.yellow(`\n미적용: ${pending.length}개`));
+                    for (const f of pending) {
+                        console.log(`  ${chalk_1.default.yellow("○")} ${f}`);
+                    }
+                }
+                await (0, database_1.closeConnection)();
+                return;
+            }
+            // 미적용 마이그레이션 필터
+            const pending = allFiles.filter((f) => !appliedSet.has(f.replace(/\.sql$/, "")));
+            if (pending.length === 0) {
+                console.log(chalk_1.default.green("모든 마이그레이션이 적용됨"));
+                await (0, database_1.closeConnection)();
+                return;
+            }
+            // --dry-run: 미리보기만
+            if (options.dryRun) {
+                console.log(chalk_1.default.cyan(`미적용 마이그레이션 ${pending.length}개:`));
+                for (const f of pending) {
+                    console.log(`  ${chalk_1.default.yellow("○")} ${f}`);
+                }
+                await (0, database_1.closeConnection)();
+                return;
+            }
+            // 실행
+            const spinner = (0, ora_1.default)(`마이그레이션 실행 중 (${pending.length}개)`).start();
+            for (const file of pending) {
+                spinner.text = `적용 중: ${file}`;
+                await runMigration(file);
+                spinner.text = `${chalk_1.default.green("✓")} ${file}`;
+                console.log(`  ${chalk_1.default.green("✓")} ${file}`);
+            }
+            spinner.succeed(`마이그레이션 완료 (${pending.length}개 적용)`);
+        }
+        catch (err) {
+            console.error(chalk_1.default.red(`마이그레이션 실패: ${err}`));
+            process.exit(1);
+        }
+        finally {
+            await (0, database_1.closeConnection)();
+        }
+    });
+}

package/dist/commands/get.d.ts

@@ -1,11 +1,10 @@
 /**
  * semo get <resource> — 세션 중 실시간 DB 쿼리
  *
- * semo get projects  [--active]
+ * semo get projects  [--active] [--format table|json|md]
  * semo get bots      [--status online|offline]
  * semo get kb        [--domain <d>] [--key <k>] [--search <text>]
  * semo get ontology  [--domain <d>]
- * semo get tasks     [--project <p>] [--status <s>]
  * semo get sessions  [--bot <n>]
  */
 import { Command } from "commander";