@team-semicolon/semo-cli 4.1.5 → 4.3.0

package/dist/commands/get.js

@@ -2,11 +2,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>]
  */
 var __importDefault = (this && this.__importDefault) || function (mod) {
@@ -52,69 +51,42 @@ function registerGetCommands(program) {
     // ── semo get projects ───────────────────────────────────────
     getCmd
         .command("projects")
-        .description("프로젝트 목록 조회")
-        .option("--active", "활성 프로젝트만")
+        .description("프로젝트 목록 조회 (KB 기반)")
+        .option("--active", "활성 프로젝트만 (metadata.status='active')")
         .option("--format <type>", "출력 형식 (table|json|md)", "table")
         .action(async (options) => {
         const spinner = (0, ora_1.default)("프로젝트 조회 중...").start();
         const connected = await (0, database_1.isDbConnected)();
         if (!connected) {
-            // Fallback: show KB entries with domain=project
-            try {
-                const pool = (0, database_1.getPool)();
-                const { shared } = await (0, kb_1.kbList)(pool, { domain: "project", limit: 100 });
-                spinner.stop();
-                if (options.format === "json") {
-                    console.log(JSON.stringify(shared, null, 2));
-                }
-                else {
-                    printTable(["key", "content"], shared.map(e => [e.key, e.content.substring(0, 80)]), "📁 프로젝트 (KB 기반)");
-                }
-            }
-            catch {
-                spinner.fail("DB 연결 실패");
-            }
+            spinner.fail("DB 연결 실패");
             await (0, database_1.closeConnection)();
-            return;
+            process.exit(1);
         }
         try {
             const pool = (0, database_1.getPool)();
-            const client = await pool.connect();
-            let query = `
-          SELECT id, name, display_name, status, description, updated_at::text
-          FROM semo.projects
-        `;
-            const params = [];
+            let entries = await (0, kb_1.kbList)(pool, { domain: "project", limit: 100 });
             if (options.active) {
-                query += " WHERE status = 'active'";
-            }
-            query += " ORDER BY updated_at DESC";
-            let rows = [];
-            try {
-                const result = await client.query(query, params);
-                rows = result.rows;
-            }
-            catch {
-                // semo.projects table may not exist — fallback to KB
-                client.release();
-                const { shared } = await (0, kb_1.kbList)(pool, { domain: "project", limit: 100 });
-                spinner.stop();
-                if (options.format === "json") {
-                    console.log(JSON.stringify(shared, null, 2));
-                }
-                else {
-                    printTable(["key", "content"], shared.map(e => [e.key, e.content.substring(0, 80)]), "📁 프로젝트 (KB 기반)");
-                }
-                await (0, database_1.closeConnection)();
-                return;
+                entries = entries.filter(e => {
+                    const meta = e.metadata;
+                    return meta?.status === "active";
+                });
             }
-            client.release();
             spinner.stop();
             if (options.format === "json") {
-                console.log(JSON.stringify(rows, null, 2));
+                console.log(JSON.stringify(entries, null, 2));
+            }
+            else if (options.format === "md") {
+                for (const e of entries) {
+                    console.log(`\n## ${e.key}\n`);
+                    console.log(e.content);
+                }
             }
             else {
-                printTable(["ID", "이름", "상태", "설명"], rows.map(r => [r.id, r.display_name || r.name, r.status || "-", (r.description || "").substring(0, 60)]), "📁 프로젝트");
+                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)");
             }
         }
         catch (err) {
@@ -217,11 +189,11 @@ function registerGetCommands(program) {
                 entries = result.rows;
             }
             else {
-                const { shared } = await (0, kb_1.kbList)(pool, {
+                const kbEntries = await (0, kb_1.kbList)(pool, {
                     domain: options.domain,
                     limit,
                 });
-                entries = shared;
+                entries = kbEntries;
             }
             spinner.stop();
             if (options.format === "json") {
@@ -301,70 +273,6 @@ function registerGetCommands(program) {
             await (0, database_1.closeConnection)();
         }
     });
-    // ── semo get tasks ──────────────────────────────────────────
-    getCmd
-        .command("tasks")
-        .description("태스크 조회 (semo.tasks)")
-        .option("--project <name>", "프로젝트 필터")
-        .option("--status <s>", "상태 필터 (open|in_progress|done)")
-        .option("--limit <n>", "최대 결과 수", "20")
-        .option("--format <type>", "출력 형식 (table|json)", "table")
-        .action(async (options) => {
-        const spinner = (0, ora_1.default)("태스크 조회 중...").start();
-        const connected = await (0, database_1.isDbConnected)();
-        if (!connected) {
-            spinner.fail("DB 연결 실패");
-            await (0, database_1.closeConnection)();
-            process.exit(1);
-        }
-        try {
-            const pool = (0, database_1.getPool)();
-            const client = await pool.connect();
-            let query = "SELECT id, title, status, project_id, assignee_name, updated_at::text FROM semo.tasks";
-            const params = [];
-            const conditions = [];
-            let idx = 1;
-            if (options.project) {
-                conditions.push(`project_id = $${idx++}`);
-                params.push(options.project);
-            }
-            if (options.status) {
-                conditions.push(`status = $${idx++}`);
-                params.push(options.status);
-            }
-            if (conditions.length > 0) {
-                query += " WHERE " + conditions.join(" AND ");
-            }
-            query += ` ORDER BY updated_at DESC LIMIT $${idx++}`;
-            params.push(parseInt(options.limit));
-            let rows = [];
-            try {
-                const result = await client.query(query, params);
-                rows = result.rows;
-            }
-            catch {
-                client.release();
-                spinner.warn("semo.tasks 테이블이 없거나 접근 불가");
-                await (0, database_1.closeConnection)();
-                return;
-            }
-            client.release();
-            spinner.stop();
-            if (options.format === "json") {
-                console.log(JSON.stringify(rows, null, 2));
-            }
-            else {
-                printTable(["id", "title", "status", "assignee"], rows.map(r => [r.id, (r.title || "").substring(0, 50), r.status, r.assignee_name || "-"]), "📋 태스크");
-            }
-        }
-        catch (err) {
-            spinner.fail(`조회 실패: ${err}`);
-            process.exit(1);
-        }
-        finally {
-            await (0, database_1.closeConnection)();
-        }
-    });
     // ── semo get sessions ───────────────────────────────────────
     getCmd
         .command("sessions")

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,297 @@
+"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 key = stateKey;
+            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 = `${key}: ${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, 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,
+             embedding = EXCLUDED.embedding`, [
+                    domain,
+                    key,
+                    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 [key, val] of entries) {
+            const [sourceId, date] = key.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/sessions.d.ts

@@ -23,7 +23,8 @@
  *   { "agent:main:slack:channel:xxx": { updatedAt: <unix ms>, ... }, ... }
  */
 import { Command } from "commander";
-export declare function syncBotSessions(botIds: string[], client: any): Promise<{
+import { PoolClient } from "pg";
+export declare function syncBotSessions(botIds: string[], client: PoolClient): Promise<{
     total: number;
 }>;
 export declare function registerSessionsCommands(program: Command): void;