@team-semicolon/semo-cli 4.7.3 → 4.8.0

package/dist/index.js

@@ -1665,7 +1665,7 @@ kbCmd
 });
 kbCmd
     .command("upsert <domain> <key> [sub_key]")
-    .description("KB 항목 쓰기 (upsert) — 임베딩 자동 생성 + 스키마 검증")
+    .description("KB 항목 쓰기 (upsert) — 임베딩 자동 생성 + 스키마 검증 (key는 kebab-case만 허용)")
     .requiredOption("--content <text>", "항목 본문")
     .option("--metadata <json>", "추가 메타데이터 (JSON 문자열)")
     .option("--created-by <name>", "작성자 식별자", "semo-cli")
@@ -1702,12 +1702,69 @@ kbCmd
         process.exit(1);
     }
 });
+kbCmd
+    .command("delete <domain> <key> [sub_key]")
+    .description("KB 항목 삭제 (domain + key + sub_key)")
+    .option("--yes", "확인 프롬프트 건너뛰기 (크론/스크립트용)")
+    .action(async (domain, key, subKey, options) => {
+    try {
+        const pool = (0, database_1.getPool)();
+        // 삭제 전 항목 확인
+        const entry = await (0, kb_1.kbGet)(pool, domain, key, subKey);
+        if (!entry) {
+            console.log(chalk_1.default.yellow(`\n  항목 없음: ${domain}/${key}${subKey ? '/' + subKey : ''}\n`));
+            await (0, database_1.closeConnection)();
+            process.exit(1);
+        }
+        // 확인 프롬프트 (--yes가 없으면)
+        if (!options.yes) {
+            const fullPath = `${domain}/${entry.key}${entry.sub_key ? '/' + entry.sub_key : ''}`;
+            console.log(chalk_1.default.cyan(`\n📄 삭제 대상: ${fullPath}`));
+            console.log(chalk_1.default.gray(`  version: ${entry.version} | created_by: ${entry.created_by} | updated: ${entry.updated_at}`));
+            console.log(chalk_1.default.gray(`  content: ${entry.content.substring(0, 120)}${entry.content.length > 120 ? '...' : ''}\n`));
+            const { createInterface } = await import("readline");
+            const rl = createInterface({ input: process.stdin, output: process.stdout });
+            const answer = await new Promise((resolve) => {
+                rl.question(chalk_1.default.yellow("  정말 삭제하시겠습니까? (y/N): "), resolve);
+            });
+            rl.close();
+            if (answer.toLowerCase() !== "y") {
+                console.log(chalk_1.default.gray("  취소됨.\n"));
+                await (0, database_1.closeConnection)();
+                return;
+            }
+        }
+        const result = await (0, kb_1.kbDelete)(pool, domain, key, subKey);
+        if (result.deleted) {
+            const fullPath = `${domain}/${result.entry.key}${result.entry.sub_key ? '/' + result.entry.sub_key : ''}`;
+            console.log(chalk_1.default.green(`✔ KB 삭제 완료: ${fullPath}`));
+        }
+        else {
+            console.log(chalk_1.default.red(`✖ KB 삭제 실패: ${result.error}`));
+            process.exit(1);
+        }
+        await (0, database_1.closeConnection)();
+    }
+    catch (err) {
+        console.error(chalk_1.default.red(`삭제 실패: ${err}`));
+        await (0, database_1.closeConnection)();
+        process.exit(1);
+    }
+});
 kbCmd
     .command("ontology")
     .description("온톨로지 조회 — 도메인/타입/스키마/라우팅 테이블")
-    .option("--action <type>", "조회 동작 (list|show|services|types|instances|schema|routing-table)", "list")
-    .option("--domain <name>", "action=show 시 도메인")
-    .option("--type <name>", "action=schema 시 타입 키")
+    .option("--action <type>", "동작 (list|show|services|types|instances|schema|routing-table|register|add-key|remove-key)", "list")
+    .option("--domain <name>", "action=show|register 시 도메인")
+    .option("--type <name>", "action=schema|register|add-key|remove-key 시 타입 키")
+    .option("--key <name>", "action=add-key|remove-key 시 스키마 키")
+    .option("--key-type <type>", "action=add-key 시 키 유형 (singleton|collection)", "singleton")
+    .option("--required", "action=add-key 시 필수 여부")
+    .option("--hint <text>", "action=add-key 시 값 힌트")
+    .option("--description <text>", "action=register|add-key 시 설명")
+    .option("--service <name>", "action=register 시 서비스 그룹")
+    .option("--tags <tags>", "action=register 시 태그 (쉼표 구분)")
+    .option("--no-init", "action=register 시 필수 KB entry 자동 생성 건너뛰기")
     .option("--format <type>", "출력 형식 (json|table)", "table")
     .action(async (options) => {
     try {
@@ -1852,8 +1909,91 @@ kbCmd
                 console.log();
             }
         }
+        else if (action === "register") {
+            if (!options.domain) {
+                console.log(chalk_1.default.red("--domain 옵션이 필요합니다."));
+                process.exit(1);
+            }
+            if (!options.type) {
+                console.log(chalk_1.default.red("--type 옵션이 필요합니다. (예: --type service, --type team, --type person)"));
+                const types = await (0, kb_1.ontoListTypes)(pool);
+                console.log(chalk_1.default.gray(`사용 가능한 타입: ${types.map(t => t.type_key).join(", ")}`));
+                process.exit(1);
+            }
+            const tags = options.tags ? options.tags.split(",").map((t) => t.trim()) : undefined;
+            const result = await (0, kb_1.ontoRegister)(pool, {
+                domain: options.domain,
+                entity_type: options.type,
+                description: options.description,
+                service: options.service,
+                tags,
+                init_required: options.init !== false,
+            });
+            if (options.format === "json") {
+                console.log(JSON.stringify(result, null, 2));
+            }
+            else {
+                if (result.success) {
+                    console.log(chalk_1.default.green(`\n✅ 도메인 '${options.domain}' 등록 완료 (타입: ${options.type})`));
+                    if (result.created_entries && result.created_entries.length > 0) {
+                        console.log(chalk_1.default.gray(`  초기 KB entry ${result.created_entries.length}건 생성:`));
+                        for (const e of result.created_entries) {
+                            console.log(chalk_1.default.gray(`    - ${e.key}`));
+                        }
+                    }
+                    console.log(chalk_1.default.gray(`\n  다음 단계: semo kb upsert ${options.domain} <key> --content "..." 으로 데이터 입력\n`));
+                }
+                else {
+                    console.log(chalk_1.default.red(`\n❌ 등록 실패: ${result.error}\n`));
+                    process.exit(1);
+                }
+            }
+        }
+        else if (action === "add-key") {
+            if (!options.type) {
+                console.log(chalk_1.default.red("--type 옵션이 필요합니다. (예: --type service)"));
+                process.exit(1);
+            }
+            if (!options.key) {
+                console.log(chalk_1.default.red("--key 옵션이 필요합니다. (예: --key slack_channel)"));
+                process.exit(1);
+            }
+            const result = await (0, kb_1.ontoAddKey)(pool, {
+                type_key: options.type,
+                scheme_key: options.key,
+                description: options.description,
+                key_type: options.keyType,
+                required: options.required || false,
+                value_hint: options.hint,
+            });
+            if (result.success) {
+                console.log(chalk_1.default.green(`\n✅ 스키마 키 추가 완료: ${options.type}.${options.key} (${options.keyType})\n`));
+            }
+            else {
+                console.log(chalk_1.default.red(`\n❌ 스키마 키 추가 실패: ${result.error}\n`));
+                process.exit(1);
+            }
+        }
+        else if (action === "remove-key") {
+            if (!options.type) {
+                console.log(chalk_1.default.red("--type 옵션이 필요합니다."));
+                process.exit(1);
+            }
+            if (!options.key) {
+                console.log(chalk_1.default.red("--key 옵션이 필요합니다."));
+                process.exit(1);
+            }
+            const result = await (0, kb_1.ontoRemoveKey)(pool, options.type, options.key);
+            if (result.success) {
+                console.log(chalk_1.default.green(`\n✅ 스키마 키 삭제 완료: ${options.type}.${options.key}\n`));
+            }
+            else {
+                console.log(chalk_1.default.red(`\n❌ 스키마 키 삭제 실패: ${result.error}\n`));
+                process.exit(1);
+            }
+        }
         else {
-            console.log(chalk_1.default.red(`알 수 없는 action: '${action}'. 사용 가능: list, show, services, types, instances, schema, routing-table`));
+            console.log(chalk_1.default.red(`알 수 없는 action: '${action}'. 사용 가능: list, show, services, types, instances, schema, routing-table, register, add-key, remove-key`));
             process.exit(1);
         }
         await (0, database_1.closeConnection)();
@@ -2033,6 +2173,54 @@ ontoCmd
         process.exit(1);
     }
 });
+ontoCmd
+    .command("register <domain>")
+    .description("새 온톨로지 도메인 등록")
+    .requiredOption("--type <type>", "엔티티 타입 (예: service, team, person, bot)")
+    .option("--description <text>", "도메인 설명")
+    .option("--service <name>", "서비스 그룹")
+    .option("--tags <tags>", "태그 (쉼표 구분)")
+    .option("--no-init", "필수 KB entry 자동 생성 건너뛰기")
+    .option("--format <type>", "출력 형식 (json|table)", "table")
+    .action(async (domain, options) => {
+    try {
+        const pool = (0, database_1.getPool)();
+        const tags = options.tags ? options.tags.split(",").map((t) => t.trim()) : undefined;
+        const result = await (0, kb_1.ontoRegister)(pool, {
+            domain,
+            entity_type: options.type,
+            description: options.description,
+            service: options.service,
+            tags,
+            init_required: options.init !== false,
+        });
+        if (options.format === "json") {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            if (result.success) {
+                console.log(chalk_1.default.green(`\n✅ 도메인 '${domain}' 등록 완료 (타입: ${options.type})`));
+                if (result.created_entries && result.created_entries.length > 0) {
+                    console.log(chalk_1.default.gray(`  초기 KB entry ${result.created_entries.length}건 생성:`));
+                    for (const e of result.created_entries) {
+                        console.log(chalk_1.default.gray(`    - ${e.key}`));
+                    }
+                }
+                console.log(chalk_1.default.gray(`\n  다음 단계: semo kb upsert ${domain} <key> --content "..." 으로 데이터 입력\n`));
+            }
+            else {
+                console.log(chalk_1.default.red(`\n❌ 등록 실패: ${result.error}\n`));
+                process.exit(1);
+            }
+        }
+        await (0, database_1.closeConnection)();
+    }
+    catch (err) {
+        console.error(chalk_1.default.red(`등록 실패: ${err}`));
+        await (0, database_1.closeConnection)();
+        process.exit(1);
+    }
+});
 // === 신규 v4 커맨드 그룹 등록 ===
 (0, context_1.registerContextCommands)(program);
 (0, bots_1.registerBotsCommands)(program);

package/dist/kb.d.ts

@@ -135,6 +135,15 @@ export declare function kbDigest(pool: Pool, since: string, domain?: string): Pr
  * Get a single KB entry by domain + key + sub_key
  */
 export declare function kbGet(pool: Pool, domain: string, rawKey: string, rawSubKey?: string): Promise<KBEntry | null>;
+/**
+ * Delete a single KB entry by domain/key/sub_key.
+ * Returns the deleted entry content for confirmation, or null if not found.
+ */
+export declare function kbDelete(pool: Pool, domain: string, rawKey: string, rawSubKey?: string): Promise<{
+    deleted: boolean;
+    entry?: KBEntry;
+    error?: string;
+}>;
 /**
  * Upsert a single KB entry with domain/key validation and embedding generation
  */
@@ -198,6 +207,52 @@ export declare function ontoListServices(pool: Pool): Promise<ServiceInfo[]>;
  * List service instances (entity_type = 'service')
  */
 export declare function ontoListInstances(pool: Pool): Promise<ServiceInstance[]>;
+export interface OntoRegisterOptions {
+    domain: string;
+    entity_type: string;
+    description?: string;
+    service?: string;
+    tags?: string[];
+    init_required?: boolean;
+}
+export interface OntoRegisterResult {
+    success: boolean;
+    error?: string;
+    created_entries?: Array<{
+        key: string;
+        sub_key: string;
+    }>;
+}
+/**
+ * Register a new ontology domain with optional initial required KB entries.
+ *
+ * 1. Validate entity_type exists in ontology_types
+ * 2. Check domain doesn't already exist
+ * 3. INSERT into semo.ontology
+ * 4. If init_required (default true), create KB entries for required keys in kb_type_schema
+ */
+export declare function ontoRegister(pool: Pool, opts: OntoRegisterOptions): Promise<OntoRegisterResult>;
+/**
+ * Add a key to a type schema
+ */
+export declare function ontoAddKey(pool: Pool, opts: {
+    type_key: string;
+    scheme_key: string;
+    description?: string;
+    key_type?: "singleton" | "collection";
+    required?: boolean;
+    value_hint?: string;
+}): Promise<{
+    success: boolean;
+    error?: string;
+}>;
+/**
+ * Remove a key from a type schema
+ */
+export declare function ontoRemoveKey(pool: Pool, typeKey: string, schemeKey: string): Promise<{
+    success: boolean;
+    error?: string;
+}>;
 /**
  * Write ontology schemas to local cache
  */

package/dist/kb.js

@@ -55,11 +55,15 @@ exports.ontoListTypes = ontoListTypes;
 exports.ontoValidate = ontoValidate;
 exports.kbDigest = kbDigest;
 exports.kbGet = kbGet;
+exports.kbDelete = kbDelete;
 exports.kbUpsert = kbUpsert;
 exports.ontoListSchema = ontoListSchema;
 exports.ontoRoutingTable = ontoRoutingTable;
 exports.ontoListServices = ontoListServices;
 exports.ontoListInstances = ontoListInstances;
+exports.ontoRegister = ontoRegister;
+exports.ontoAddKey = ontoAddKey;
+exports.ontoRemoveKey = ontoRemoveKey;
 exports.ontoPullToLocal = ontoPullToLocal;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -682,6 +686,37 @@ async function kbGet(pool, domain, rawKey, rawSubKey) {
         client.release();
     }
 }
+/**
+ * Delete a single KB entry by domain/key/sub_key.
+ * Returns the deleted entry content for confirmation, or null if not found.
+ */
+async function kbDelete(pool, domain, rawKey, rawSubKey) {
+    let key;
+    let subKey;
+    if (rawSubKey !== undefined) {
+        key = rawKey;
+        subKey = rawSubKey;
+    }
+    else {
+        const split = splitKey(rawKey);
+        key = split.key;
+        subKey = split.subKey;
+    }
+    const client = await pool.connect();
+    try {
+        const result = await client.query(`DELETE FROM semo.knowledge_base
+       WHERE domain = $1 AND key = $2 AND sub_key = $3
+       RETURNING domain, key, sub_key, content, metadata, created_by, version,
+                 created_at::text, updated_at::text`, [domain, key, subKey]);
+        if (result.rows.length === 0) {
+            return { deleted: false, error: `항목 없음: ${domain}/${combineKey(key, subKey)}` };
+        }
+        return { deleted: true, entry: result.rows[0] };
+    }
+    finally {
+        client.release();
+    }
+}
 /**
  * Upsert a single KB entry with domain/key validation and embedding generation
  */
@@ -713,6 +748,22 @@ async function kbUpsert(pool, entry) {
     finally {
         client.release();
     }
+    // Naming convention check: kebab-case only
+    const warnings = [];
+    if (/_/.test(key)) {
+        const suggested = key.replace(/_/g, "-");
+        return {
+            success: false,
+            error: `키 '${key}'에 snake_case가 포함되어 있습니다. kebab-case를 사용하세요: '${suggested}'`,
+        };
+    }
+    if (/_/.test(subKey)) {
+        const suggested = subKey.replace(/_/g, "-");
+        return {
+            success: false,
+            error: `sub_key '${subKey}'에 snake_case가 포함되어 있습니다. kebab-case를 사용하세요: '${suggested}'`,
+        };
+    }
     // Key validation against type schema
     {
         const schemaClient = await pool.connect();
@@ -886,6 +937,142 @@ async function ontoListInstances(pool) {
         client.release();
     }
 }
+/**
+ * Register a new ontology domain with optional initial required KB entries.
+ *
+ * 1. Validate entity_type exists in ontology_types
+ * 2. Check domain doesn't already exist
+ * 3. INSERT into semo.ontology
+ * 4. If init_required (default true), create KB entries for required keys in kb_type_schema
+ */
+async function ontoRegister(pool, opts) {
+    const client = await pool.connect();
+    try {
+        // 1. Validate entity_type
+        const typeCheck = await client.query("SELECT type_key FROM semo.ontology_types WHERE type_key = $1", [opts.entity_type]);
+        if (typeCheck.rows.length === 0) {
+            const known = await client.query("SELECT type_key FROM semo.ontology_types ORDER BY type_key");
+            const knownTypes = known.rows.map((r) => r.type_key);
+            return {
+                success: false,
+                error: `타입 '${opts.entity_type}'은(는) 존재하지 않습니다. 사용 가능한 타입: [${knownTypes.join(", ")}]`,
+            };
+        }
+        // 2. Check domain doesn't already exist
+        const existCheck = await client.query("SELECT domain FROM semo.ontology WHERE domain = $1", [opts.domain]);
+        if (existCheck.rows.length > 0) {
+            return { success: false, error: `도메인 '${opts.domain}'은(는) 이미 등록되어 있습니다.` };
+        }
+        // 3. INSERT into ontology
+        await client.query(`INSERT INTO semo.ontology (domain, entity_type, description, service, tags, schema)
+       VALUES ($1, $2, $3, $4, $5, $6)`, [
+            opts.domain,
+            opts.entity_type,
+            opts.description || null,
+            opts.service || "_global",
+            opts.tags || [opts.entity_type],
+            JSON.stringify({}),
+        ]);
+        // 4. Create required KB entries
+        const createdEntries = [];
+        const initRequired = opts.init_required !== false;
+        if (initRequired) {
+            const schemaResult = await client.query(`SELECT scheme_key, scheme_description, COALESCE(key_type, 'singleton') as key_type, value_hint
+         FROM semo.kb_type_schema
+         WHERE type_key = $1 AND required = true
+         ORDER BY sort_order`, [opts.entity_type]);
+            for (const s of schemaResult.rows) {
+                if (s.key_type === "collection")
+                    continue; // collection은 sub_key가 필요하므로 스킵
+                const placeholder = s.value_hint
+                    ? `(미입력 — hint: ${s.value_hint})`
+                    : `(미입력)`;
+                const text = `${s.scheme_key}: ${placeholder}`;
+                const embedding = await generateEmbedding(text);
+                const embeddingStr = embedding ? `[${embedding.join(",")}]` : null;
+                try {
+                    await client.query(`INSERT INTO semo.knowledge_base (domain, key, sub_key, content, metadata, created_by, embedding)
+             VALUES ($1, $2, '', $3, '{}', 'semo-cli:onto-register', $4::vector)
+             ON CONFLICT (domain, key, sub_key) DO NOTHING`, [opts.domain, s.scheme_key, placeholder, embeddingStr]);
+                    createdEntries.push({ key: s.scheme_key, sub_key: "" });
+                }
+                catch {
+                    // 개별 entry 실패는 무시 — 도메인 등록 자체는 성공
+                }
+            }
+        }
+        return { success: true, created_entries: createdEntries };
+    }
+    catch (err) {
+        return { success: false, error: String(err) };
+    }
+    finally {
+        client.release();
+    }
+}
+/**
+ * Add a key to a type schema
+ */
+async function ontoAddKey(pool, opts) {
+    const client = await pool.connect();
+    try {
+        // Naming convention: kebab-case only
+        if (/_/.test(opts.scheme_key)) {
+            const suggested = opts.scheme_key.replace(/_/g, "-");
+            return { success: false, error: `키 '${opts.scheme_key}'에 snake_case가 포함되어 있습니다. kebab-case를 사용하세요: '${suggested}'` };
+        }
+        // Check type exists
+        const typeCheck = await client.query("SELECT DISTINCT type_key FROM semo.kb_type_schema WHERE type_key = $1", [opts.type_key]);
+        if (typeCheck.rows.length === 0) {
+            // Check if this type exists in ontology at all
+            const ontoCheck = await client.query("SELECT DISTINCT entity_type FROM semo.ontology WHERE entity_type = $1", [opts.type_key]);
+            if (ontoCheck.rows.length === 0) {
+                return { success: false, error: `타입 '${opts.type_key}'이(가) 존재하지 않습니다.` };
+            }
+        }
+        // Check duplicate
+        const dupCheck = await client.query("SELECT id FROM semo.kb_type_schema WHERE type_key = $1 AND scheme_key = $2", [opts.type_key, opts.scheme_key]);
+        if (dupCheck.rows.length > 0) {
+            return { success: false, error: `키 '${opts.scheme_key}'은(는) '${opts.type_key}' 타입에 이미 존재합니다.` };
+        }
+        // Get max sort_order
+        const maxOrder = await client.query("SELECT COALESCE(MAX(sort_order), 0) + 10 as next_order FROM semo.kb_type_schema WHERE type_key = $1", [opts.type_key]);
+        const sortOrder = maxOrder.rows[0].next_order;
+        await client.query(`INSERT INTO semo.kb_type_schema (type_key, scheme_key, scheme_description, key_type, required, value_hint, sort_order)
+       VALUES ($1, $2, $3, $4, $5, $6, $7)`, [
+            opts.type_key,
+            opts.scheme_key,
+            opts.description || opts.scheme_key,
+            opts.key_type || "singleton",
+            opts.required || false,
+            opts.value_hint || null,
+            sortOrder,
+        ]);
+        return { success: true };
+    }
+    catch (err) {
+        return { success: false, error: String(err) };
+    }
+    finally {
+        client.release();
+    }
+}
+/**
+ * Remove a key from a type schema
+ */
+async function ontoRemoveKey(pool, typeKey, schemeKey) {
+    const client = await pool.connect();
+    try {
+        const result = await client.query("DELETE FROM semo.kb_type_schema WHERE type_key = $1 AND scheme_key = $2 RETURNING id", [typeKey, schemeKey]);
+        if (result.rows.length === 0) {
+            return { success: false, error: `키 '${schemeKey}'은(는) '${typeKey}' 타입에 존재하지 않습니다.` };
+        }
+        return { success: true };
+    }
+    finally {
+        client.release();
+    }
+}
 /**
  * Write ontology schemas to local cache
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-semicolon/semo-cli",
-  "version": "4.7.3",
+  "version": "4.8.0",
   "description": "SEMO CLI - AI Agent Orchestration Framework Installer",
   "main": "dist/index.js",
   "bin": {