@team-semicolon/semo-cli 4.2.0 → 4.4.0

package/dist/commands/get.js

@@ -51,11 +51,11 @@ function registerGetCommands(program) {
     // ── semo get projects ───────────────────────────────────────
     getCmd
         .command("projects")
-        .description("프로젝트 목록 조회 (KB 기반)")
-        .option("--active", "활성 프로젝트만 (metadata.status='active')")
+        .description("서비스 인스턴스 목록 조회 (온톨로지 기반)")
+        .option("--active", "활성 서비스만 (status='active')")
         .option("--format <type>", "출력 형식 (table|json|md)", "table")
         .action(async (options) => {
-        const spinner = (0, ora_1.default)("프로젝트 조회 중...").start();
+        const spinner = (0, ora_1.default)("서비스 인스턴스 조회 중...").start();
         const connected = await (0, database_1.isDbConnected)();
         if (!connected) {
             spinner.fail("DB 연결 실패");
@@ -64,29 +64,43 @@ function registerGetCommands(program) {
         }
         try {
             const pool = (0, database_1.getPool)();
-            let entries = await (0, kb_1.kbList)(pool, { domain: "project", limit: 100 });
+            const client = await pool.connect();
+            // Query service instances from ontology + their status from KB
+            const result = await client.query(`
+          SELECT o.domain, o.description,
+                 ks.content as status,
+                 (SELECT COUNT(*)::int FROM semo.knowledge_base k WHERE k.domain = o.domain) as entry_count,
+                 (SELECT k2.content FROM semo.knowledge_base k2 WHERE k2.domain = o.domain AND k2.key = 'po' LIMIT 1) as po
+          FROM semo.ontology o
+          LEFT JOIN semo.knowledge_base ks ON ks.domain = o.domain AND ks.key = 'status'
+          WHERE o.entity_type = 'service'
+          ORDER BY o.domain
+        `);
+            client.release();
+            let rows = result.rows;
             if (options.active) {
-                entries = entries.filter(e => {
-                    const meta = e.metadata;
-                    return meta?.status === "active";
-                });
+                rows = rows.filter((r) => r.status === "active");
             }
             spinner.stop();
             if (options.format === "json") {
-                console.log(JSON.stringify(entries, null, 2));
+                console.log(JSON.stringify(rows, null, 2));
             }
             else if (options.format === "md") {
-                for (const e of entries) {
-                    console.log(`\n## ${e.key}\n`);
-                    console.log(e.content);
+                for (const r of rows) {
+                    console.log(`\n## ${r.domain}\n`);
+                    console.log(`상태: ${r.status || "-"} | 담당: ${r.po || "-"}`);
+                    if (r.description)
+                        console.log(r.description);
                 }
             }
             else {
-                printTable(["key", "content", "updated_at"], entries.map(e => [
-                    e.key,
-                    (e.content || "").substring(0, 60),
-                    e.updated_at ? new Date(e.updated_at).toLocaleString("ko-KR") : "-",
-                ]), "📁 프로젝트 (KB)");
+                printTable(["service", "status", "po", "entries", "description"], rows.map((r) => [
+                    r.domain,
+                    r.status || "-",
+                    r.po || "-",
+                    String(r.entry_count || 0),
+                    (r.description || "").substring(0, 40),
+                ]), "📁 서비스 인스턴스");
             }
         }
         catch (err) {

package/dist/commands/memory.d.ts

@@ -0,0 +1,8 @@
+/**
+ * semo memory sync — L1 (bot workspace) → L2 (KB) 메모리 동기화
+ *
+ * Bot workspace의 일일 메모리 파일(YYYY-MM-DD.md)을 KB memory 도메인으로 싱크.
+ * V1: LLM 요약 없이 raw 저장 (Garden 정책 확정 후 추가 예정)
+ */
+import { Command } from "commander";
+export declare function registerMemoryCommands(program: Command): void;

package/dist/commands/memory.js

@@ -0,0 +1,299 @@
+"use strict";
+/**
+ * semo memory sync — L1 (bot workspace) → L2 (KB) 메모리 동기화
+ *
+ * Bot workspace의 일일 메모리 파일(YYYY-MM-DD.md)을 KB memory 도메인으로 싱크.
+ * V1: LLM 요약 없이 raw 저장 (Garden 정책 확정 후 추가 예정)
+ */
+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.registerMemoryCommands = registerMemoryCommands;
+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 crypto = __importStar(require("crypto"));
+const database_1 = require("../database");
+const kb_1 = require("../kb");
+// ============================================================
+// Constants
+// ============================================================
+const BOT_IDS = [
+    "semiclaw",
+    "workclaw",
+    "reviewclaw",
+    "planclaw",
+    "designclaw",
+    "infraclaw",
+    "growthclaw",
+];
+const MEMORY_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}\.md$/;
+const STATE_DIR = path.join(os.homedir(), ".semo");
+const STATE_FILE = path.join(STATE_DIR, "memory-sync-state.json");
+// ============================================================
+// State Management
+// ============================================================
+function readSyncState() {
+    try {
+        if (fs.existsSync(STATE_FILE)) {
+            return JSON.parse(fs.readFileSync(STATE_FILE, "utf-8"));
+        }
+    }
+    catch {
+        // corrupted state file
+    }
+    return { synced: {} };
+}
+function writeSyncState(state) {
+    fs.mkdirSync(STATE_DIR, { recursive: true });
+    fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+}
+function contentHash(content) {
+    return crypto.createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+// ============================================================
+// File Discovery
+// ============================================================
+function discoverBotMemoryFiles(botId, minAgeDays) {
+    const memoryDir = path.join(os.homedir(), `.openclaw-${botId}`, "workspace", "memory");
+    if (!fs.existsSync(memoryDir))
+        return [];
+    const candidates = [];
+    const cutoffDate = new Date();
+    cutoffDate.setDate(cutoffDate.getDate() - minAgeDays);
+    const files = fs.readdirSync(memoryDir);
+    for (const file of files) {
+        if (!MEMORY_DATE_PATTERN.test(file))
+            continue;
+        const dateStr = file.replace(".md", "");
+        const fileDate = new Date(dateStr + "T23:59:59Z");
+        if (fileDate > cutoffDate)
+            continue; // Too recent
+        const filePath = path.join(memoryDir, file);
+        const content = fs.readFileSync(filePath, "utf-8").trim();
+        if (!content)
+            continue; // Skip empty files
+        candidates.push({
+            sourceType: "bot",
+            sourceId: botId,
+            date: dateStr,
+            filePath,
+            content,
+            hash: contentHash(content),
+        });
+    }
+    return candidates;
+}
+// ============================================================
+// Sync Logic
+// ============================================================
+async function syncMemories(candidates, state, force, dryRun) {
+    let synced = 0;
+    let skipped = 0;
+    const errors = [];
+    if (candidates.length === 0) {
+        return { synced, skipped, errors };
+    }
+    const pool = (0, database_1.getPool)();
+    for (const candidate of candidates) {
+        const stateKey = `${candidate.sourceId}/${candidate.date}`;
+        // Check watermark
+        if (!force) {
+            const existing = state.synced[stateKey];
+            if (existing && existing.hash === candidate.hash) {
+                skipped++;
+                continue;
+            }
+        }
+        if (dryRun) {
+            console.log(chalk_1.default.gray(`  [dry-run] ${stateKey} (${candidate.content.length} chars, hash: ${candidate.hash})`));
+            synced++;
+            continue;
+        }
+        try {
+            const domain = "memory";
+            const flatKey = "memory";
+            const subKey = stateKey; // sourceId/date
+            const metadata = {
+                source_type: candidate.sourceType,
+                source_id: candidate.sourceId,
+                date: candidate.date,
+                content_hash: candidate.hash,
+                original_size: candidate.content.length,
+                synced_at: new Date().toISOString(),
+            };
+            // Generate embedding
+            const text = `memory/${stateKey}: ${candidate.content}`;
+            const embedding = await (0, kb_1.generateEmbedding)(text);
+            const embeddingStr = embedding ? `[${embedding.join(",")}]` : null;
+            const client = await pool.connect();
+            try {
+                await client.query(`INSERT INTO semo.knowledge_base (domain, key, sub_key, content, metadata, created_by, embedding)
+           VALUES ($1, $2, $3, $4, $5, $6, $7::vector)
+           ON CONFLICT (domain, key, sub_key) DO UPDATE SET
+             content = EXCLUDED.content,
+             metadata = EXCLUDED.metadata,
+             embedding = EXCLUDED.embedding`, [
+                    domain,
+                    flatKey,
+                    subKey,
+                    candidate.content,
+                    JSON.stringify(metadata),
+                    "semo-memory-sync",
+                    embeddingStr,
+                ]);
+            }
+            finally {
+                client.release();
+            }
+            // Update watermark
+            state.synced[stateKey] = {
+                hash: candidate.hash,
+                syncedAt: new Date().toISOString(),
+            };
+            synced++;
+        }
+        catch (err) {
+            errors.push(`${stateKey}: ${err}`);
+        }
+    }
+    return { synced, skipped, errors };
+}
+// ============================================================
+// Command Registration
+// ============================================================
+function registerMemoryCommands(program) {
+    const memoryCmd = program
+        .command("memory")
+        .description("메모리 관리 — L1(bot workspace) → L2(KB) 동기화");
+    memoryCmd
+        .command("sync")
+        .description("봇 워크스페이스 메모리를 KB memory 도메인으로 동기화")
+        .option("--source <type>", "소스 타입 (bot | local | all)", "all")
+        .option("--bot <id>", "특정 봇만 동기화")
+        .option("--days <n>", "N일 이상 경과한 메모리만 동기화", "2")
+        .option("--dry-run", "프리뷰만 (실제 동기화 안 함)")
+        .option("--force", "워터마크 무시, 전체 재동기화")
+        .action(async (options) => {
+        const dryRun = !!options.dryRun;
+        const force = !!options.force;
+        const minAgeDays = parseInt(options.days) || 2;
+        const sourceType = options.source;
+        const specificBot = options.bot;
+        const spinner = (0, ora_1.default)(dryRun ? "동기화 대상 탐색 중..." : "메모리 동기화 중...").start();
+        try {
+            const state = readSyncState();
+            let allCandidates = [];
+            // Discover bot memory files
+            if (sourceType === "bot" || sourceType === "all") {
+                const bots = specificBot ? [specificBot] : BOT_IDS;
+                for (const botId of bots) {
+                    const candidates = discoverBotMemoryFiles(botId, minAgeDays);
+                    allCandidates.push(...candidates);
+                }
+            }
+            spinner.text = `${allCandidates.length}개 메모리 파일 발견`;
+            if (allCandidates.length === 0) {
+                spinner.succeed("동기화 대상 메모리 파일 없음");
+                await (0, database_1.closeConnection)();
+                return;
+            }
+            const result = await syncMemories(allCandidates, state, force, dryRun);
+            if (!dryRun) {
+                writeSyncState(state);
+            }
+            if (dryRun) {
+                spinner.succeed(`[dry-run] ${result.synced}건 동기화 예정, ${result.skipped}건 스킵`);
+            }
+            else {
+                spinner.succeed(`${result.synced}건 동기화 완료, ${result.skipped}건 스킵 (변경 없음)`);
+            }
+            if (result.errors.length > 0) {
+                console.log(chalk_1.default.yellow(`  ⚠️ ${result.errors.length}건 오류:`));
+                for (const err of result.errors) {
+                    console.log(chalk_1.default.red(`     ${err}`));
+                }
+            }
+            console.log();
+            await (0, database_1.closeConnection)();
+        }
+        catch (err) {
+            spinner.fail(`메모리 동기화 실패: ${err}`);
+            await (0, database_1.closeConnection)();
+            process.exit(1);
+        }
+    });
+    memoryCmd
+        .command("status")
+        .description("메모리 동기화 상태 확인")
+        .option("--bot <id>", "특정 봇만")
+        .action(async (options) => {
+        const state = readSyncState();
+        const specificBot = options.bot;
+        console.log(chalk_1.default.cyan.bold("\n📝 메모리 동기화 상태\n"));
+        const entries = Object.entries(state.synced);
+        if (entries.length === 0) {
+            console.log(chalk_1.default.yellow("  동기화된 메모리 없음"));
+            console.log();
+            return;
+        }
+        // Group by source
+        const grouped = {};
+        for (const [stKey, val] of entries) {
+            const [sourceId, date] = stKey.split("/");
+            if (specificBot && sourceId !== specificBot)
+                continue;
+            if (!grouped[sourceId])
+                grouped[sourceId] = [];
+            grouped[sourceId].push({ date, ...val });
+        }
+        for (const [sourceId, items] of Object.entries(grouped)) {
+            console.log(chalk_1.default.white(`  ${sourceId}:`));
+            const sorted = items.sort((a, b) => b.date.localeCompare(a.date));
+            const shown = sorted.slice(0, 10);
+            for (const item of shown) {
+                console.log(chalk_1.default.gray(`    ${item.date}  (synced: ${item.syncedAt.split("T")[0]})`));
+            }
+            if (sorted.length > 10) {
+                console.log(chalk_1.default.gray(`    ... +${sorted.length - 10} more`));
+            }
+        }
+        console.log();
+    });
+}

package/dist/commands/skill-sync.js

@@ -88,7 +88,7 @@ function scanSkills(semoSystemDir) {
 async function syncSkillsToDB(client, semoSystemDir) {
     const skills = scanSkills(semoSystemDir);
     for (const skill of skills) {
-        await client.query(`INSERT INTO skill_definitions (name, prompt, package, metadata, is_active, office_id)
+        await client.query(`INSERT INTO semo.skill_definitions (name, prompt, package, metadata, is_active, office_id)
        VALUES ($1, $2, $3, $4, true, NULL)
        ON CONFLICT (name, office_id) DO UPDATE SET
          prompt = EXCLUDED.prompt,

package/dist/commands/test.d.ts

@@ -0,0 +1,11 @@
+/**
+ * semo test — 테스트 관리
+ *
+ * semo test list               — 등록된 스위트 + 최근 실행 상태
+ * semo test run [suite]        — 스위트 실행 + DB 기록
+ * semo test run --all          — 전체 스위트 실행
+ * semo test run --notify       — 실패 시 Slack 알림
+ * semo test history [suite]    — 실행 이력
+ */
+import { Command } from "commander";
+export declare function registerTestCommands(program: Command): void;