kibi-cli 0.2.3 → 0.2.6

package/dist/commands/query.js

@@ -15,37 +15,12 @@
  You should have received a copy of the GNU Affero General Public License
  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
-/*
- How to apply this header to source files (examples)
-
- 1) Prepend header to a single file (POSIX shells):
-
-    cat LICENSE_HEADER.txt "$FILE" > "$FILE".with-header && mv "$FILE".with-header "$FILE"
-
- 2) Apply to multiple files (example: the project's main entry files):
-
-    for f in packages/cli/bin/kibi packages/mcp/bin/kibi-mcp packages/cli/src/*.ts packages/mcp/src/*.ts; do
-      if [ -f "$f" ]; then
-        cp "$f" "$f".bak
-        (cat LICENSE_HEADER.txt; echo; cat "$f" ) > "$f".new && mv "$f".new "$f"
-      fi
-    done
-
- 3) Avoid duplicating the header: run a quick guard to only add if missing
-
-    for f in packages/cli/bin/kibi packages/mcp/bin/kibi-mcp; do
-      if [ -f "$f" ]; then
-        if ! head -n 5 "$f" | grep -q "Copyright (C) 2026 Piotr Franczyk"; then
-          cp "$f" "$f".bak
-          (cat LICENSE_HEADER.txt; echo; cat "$f" ) > "$f".new && mv "$f".new "$f"
-        fi
-      fi
-    done
-*/
 import * as path from "node:path";
 import Table from "cli-table3";
 import { PrologProcess } from "../prolog.js";
+import { parseEntityFromBinding, parseEntityFromList, parseListOfLists, parsePrologValue, } from "../prolog/codec.js";
 import relationshipSchema from "../public/schemas/relationship.js";
+import { VALID_ENTITY_TYPES } from "../query/service.js";
 import { resolveActiveBranch } from "../utils/branch-resolver.js";
 const REL_TYPES = relationshipSchema.properties.type.enum;
 export async function queryCommand(type, options) {
@@ -109,23 +84,11 @@ export async function queryCommand(type, options) {
         // Query entities mode
         else if (type || options.source) {
             // Validate type if provided
-            if (type) {
-                const validTypes = [
-                    "req",
-                    "scenario",
-                    "test",
-                    "adr",
-                    "flag",
-                    "event",
-                    "symbol",
-                    "fact",
-                ];
-                if (!validTypes.includes(type)) {
-                    await prolog.query("kb_detach");
-                    await prolog.terminate();
-                    console.error(`Error: Invalid type '${type}'. Valid types: ${validTypes.join(", ")}`);
-                    process.exit(1);
-                }
+            if (type && !VALID_ENTITY_TYPES.includes(type)) {
+                await prolog.query("kb_detach");
+                await prolog.terminate();
+                console.error(`Error: Invalid type '${type}'. Valid types: ${VALID_ENTITY_TYPES.join(", ")}`);
+                process.exit(1);
             }
             let goal;
             if (options.source) {
@@ -206,250 +169,6 @@ export async function queryCommand(type, options) {
         process.exit(1);
     }
 }
-/**
- * Parse a Prolog list of lists into a JavaScript array.
- * Input: "[[a,b,c],[d,e,f]]"
- * Output: [["a", "b", "c"], ["d", "e", "f"]]
- */
-function parseListOfLists(listStr) {
-    // Clean input
-    const cleaned = listStr.trim().replace(/^\[/, "").replace(/\]$/, "");
-    if (cleaned === "") {
-        return [];
-    }
-    const results = [];
-    let depth = 0;
-    let inQuotes = false;
-    let current = "";
-    let currentList = [];
-    for (let i = 0; i < cleaned.length; i++) {
-        const char = cleaned[i];
-        const prevChar = i > 0 ? cleaned[i - 1] : "";
-        if (char === '"' && prevChar !== "\\") {
-            inQuotes = !inQuotes;
-            current += char;
-            continue;
-        }
-        if (inQuotes) {
-            current += char;
-            continue;
-        }
-        if (char === "[") {
-            depth++;
-            if (depth > 1)
-                current += char;
-        }
-        else if (char === "]") {
-            depth--;
-            if (depth === 0) {
-                if (current) {
-                    currentList.push(current.trim());
-                    current = "";
-                }
-                if (currentList.length > 0) {
-                    results.push(currentList);
-                    currentList = [];
-                }
-            }
-            else {
-                current += char;
-            }
-        }
-        else if (char === "," && depth === 1) {
-            if (current) {
-                currentList.push(current.trim());
-                current = "";
-            }
-        }
-        else if (char === "," && depth === 0) {
-            // Skip comma between lists
-        }
-        else {
-            current += char;
-        }
-    }
-    return results;
-}
-/**
- * Parse a single entity from Prolog binding format.
- * Input: "[abc123, req, [id=abc123, title=\"Test\", ...]]"
- */
-function parseEntityFromBinding(bindingStr) {
-    const cleaned = bindingStr.trim().replace(/^\[/, "").replace(/\]$/, "");
-    const parts = splitTopLevel(cleaned, ",");
-    if (parts.length < 3) {
-        return {};
-    }
-    const id = parts[0].trim();
-    const type = parts[1].trim();
-    const propsStr = parts.slice(2).join(",").trim();
-    const props = parsePropertyList(propsStr);
-    return { id, type, ...props };
-}
-/**
- * Parse entity from array returned by parseListOfLists.
- * Input: ["abc123", "req", "[id=abc123, title=\"Test\", ...]"]
- */
-function parseEntityFromList(data) {
-    if (data.length < 3) {
-        return {};
-    }
-    const id = data[0].trim();
-    const type = data[1].trim();
-    const propsStr = data[2].trim();
-    const props = parsePropertyList(propsStr);
-    return { id, type, ...props };
-}
-/**
- * Parse Prolog property list into JavaScript object.
- * Input: "[id=abc123, title=^^(\"User Auth\", xsd:string), status='file:///path/approved', tags=^^(\"[security,auth]\", xsd:string)]"
- * Output: { id: "abc123", title: "User Auth", status: "approved", tags: ["security", "auth"] }
- */
-function parsePropertyList(propsStr) {
-    const props = {};
-    // Remove outer brackets
-    let cleaned = propsStr.trim();
-    if (cleaned.startsWith("[")) {
-        cleaned = cleaned.substring(1);
-    }
-    if (cleaned.endsWith("]")) {
-        cleaned = cleaned.substring(0, cleaned.length - 1);
-    }
-    // Split by top-level commas
-    const pairs = splitTopLevel(cleaned, ",");
-    for (const pair of pairs) {
-        const eqIndex = pair.indexOf("=");
-        if (eqIndex === -1)
-            continue;
-        const key = pair.substring(0, eqIndex).trim();
-        const value = pair.substring(eqIndex + 1).trim();
-        if (key === "..." || value === "..." || value === "...|...") {
-            continue;
-        }
-        const parsed = parsePrologValue(value);
-        props[key] = parsed;
-    }
-    return props;
-}
-/**
- * Parse a single Prolog value, handling typed literals and URIs.
- * Examples:
- * - ^^("value", 'http://...#string') -> "value"
- * - 'file:///path/to/id' -> "id" (extract last segment)
- * - "string" -> "string"
- * - atom -> "atom"
- * - [a,b,c] -> ["a", "b", "c"]
- */
-function parsePrologValue(value) {
-    value = value.trim();
-    if (value.startsWith("^^(")) {
-        const innerStart = value.indexOf("(") + 1;
-        let depth = 1;
-        let innerEnd = innerStart;
-        for (let i = innerStart; i < value.length; i++) {
-            if (value[i] === "(")
-                depth++;
-            if (value[i] === ")") {
-                depth--;
-                if (depth === 0) {
-                    innerEnd = i;
-                    break;
-                }
-            }
-        }
-        const innerContent = value.substring(innerStart, innerEnd);
-        const parts = splitTopLevel(innerContent, ",");
-        if (parts.length >= 2) {
-            let literalValue = parts[0].trim();
-            if (literalValue.startsWith('"') && literalValue.endsWith('"')) {
-                literalValue = literalValue.substring(1, literalValue.length - 1);
-            }
-            if (literalValue.startsWith("[") && literalValue.endsWith("]")) {
-                const listContent = literalValue.substring(1, literalValue.length - 1);
-                if (listContent === "") {
-                    return [];
-                }
-                return listContent.split(",").map((item) => item.trim());
-            }
-            return literalValue;
-        }
-    }
-    if (value.startsWith("file:///")) {
-        const cleaned = value;
-        const lastSlash = cleaned.lastIndexOf("/");
-        if (lastSlash !== -1) {
-            return cleaned.substring(lastSlash + 1);
-        }
-        return cleaned;
-    }
-    // Handle quoted string
-    if (value.startsWith('"') && value.endsWith('"')) {
-        return value.substring(1, value.length - 1);
-    }
-    // Handle quoted atom (may contain file URLs that need extraction)
-    if (value.startsWith("'") && value.endsWith("'")) {
-        const unquoted = value.substring(1, value.length - 1);
-        // Check if unquoted value is a file URL
-        if (unquoted.startsWith("file:///")) {
-            const lastSlash = unquoted.lastIndexOf("/");
-            if (lastSlash !== -1) {
-                return unquoted.substring(lastSlash + 1);
-            }
-        }
-        return unquoted;
-    }
-    // Handle list
-    if (value.startsWith("[") && value.endsWith("]")) {
-        const listContent = value.substring(1, value.length - 1);
-        if (listContent === "") {
-            return [];
-        }
-        const items = listContent.split(",").map((item) => {
-            return parsePrologValue(item.trim());
-        });
-        return items;
-    }
-    // Return as-is
-    return value;
-}
-/**
- * Split a string by delimiter at the top level (not inside brackets or quotes).
- */
-function splitTopLevel(str, delimiter) {
-    const results = [];
-    let current = "";
-    let depth = 0;
-    let inQuotes = false;
-    for (let i = 0; i < str.length; i++) {
-        const char = str[i];
-        const prevChar = i > 0 ? str[i - 1] : "";
-        if (char === '"' && prevChar !== "\\") {
-            inQuotes = !inQuotes;
-            current += char;
-        }
-        else if (!inQuotes && (char === "[" || char === "(")) {
-            depth++;
-            current += char;
-        }
-        else if (!inQuotes && (char === "]" || char === ")")) {
-            depth--;
-            current += char;
-        }
-        else if (!inQuotes && depth === 0 && char === delimiter) {
-            if (current) {
-                results.push(current);
-                current = "";
-            }
-        }
-        else {
-            current += char;
-        }
-    }
-    if (current) {
-        results.push(current);
-    }
-    return results;
-}
 /**
  * Output results as a formatted table.
  */

package/dist/commands/sync/cache.d.ts

@@ -0,0 +1,13 @@
+export type SyncCache = {
+    version: number;
+    hashes: Record<string, string>;
+    seenAt: Record<string, string>;
+};
+export declare const SYNC_CACHE_VERSION = 1;
+export declare const SYNC_CACHE_TTL_MS: number;
+export declare function toCacheKey(filePath: string): string;
+export declare function hashFile(filePath: string): string;
+export declare function readSyncCache(cachePath: string): SyncCache;
+export declare function writeSyncCache(cachePath: string, cache: SyncCache): void;
+export declare function copySyncCache(livePath: string, stagingPath: string): void;
+//# sourceMappingURL=cache.d.ts.map

package/dist/commands/sync/cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../../src/commands/sync/cache.ts"],"names":[],"mappings":"AAsBA,MAAM,MAAM,SAAS,GAAG;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAChC,CAAC;AAEF,eAAO,MAAM,kBAAkB,IAAI,CAAC;AACpC,eAAO,MAAM,iBAAiB,QAA2B,CAAC;AAE1D,wBAAgB,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEnD;AAED,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAGjD;AAED,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAiC1D;AAED,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,IAAI,CAYxE;AAED,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI,CAQzE"}

package/dist/commands/sync/cache.js

@@ -0,0 +1,76 @@
+/*
+ Kibi — repo-local, per-branch, queryable long-term memory for software projects
+ Copyright (C) 2026 Piotr Franczyk
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import * as path from "node:path";
+export const SYNC_CACHE_VERSION = 1;
+export const SYNC_CACHE_TTL_MS = 30 * 24 * 60 * 60 * 1000;
+export function toCacheKey(filePath) {
+    return path.relative(process.cwd(), filePath).split(path.sep).join("/");
+}
+export function hashFile(filePath) {
+    const content = readFileSync(filePath);
+    return createHash("sha256").update(content).digest("hex");
+}
+export function readSyncCache(cachePath) {
+    if (!existsSync(cachePath)) {
+        return {
+            version: SYNC_CACHE_VERSION,
+            hashes: {},
+            seenAt: {},
+        };
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(cachePath, "utf8"));
+        if (parsed.version !== SYNC_CACHE_VERSION) {
+            return {
+                version: SYNC_CACHE_VERSION,
+                hashes: {},
+                seenAt: {},
+            };
+        }
+        return {
+            version: SYNC_CACHE_VERSION,
+            hashes: parsed.hashes ?? {},
+            seenAt: parsed.seenAt ?? {},
+        };
+    }
+    catch {
+        return {
+            version: SYNC_CACHE_VERSION,
+            hashes: {},
+            seenAt: {},
+        };
+    }
+}
+export function writeSyncCache(cachePath, cache) {
+    const cacheDir = path.dirname(cachePath);
+    if (!existsSync(cacheDir)) {
+        mkdirSync(cacheDir, { recursive: true });
+    }
+    writeFileSync(cachePath, `${JSON.stringify(cache, null, 2)}
+`, "utf8");
+}
+export function copySyncCache(livePath, stagingPath) {
+    const liveCachePath = path.join(livePath, "sync-cache.json");
+    const stagingCachePath = path.join(stagingPath, "sync-cache.json");
+    if (existsSync(liveCachePath)) {
+        const cacheContent = readFileSync(liveCachePath, "utf8");
+        writeFileSync(stagingCachePath, cacheContent, "utf8");
+    }
+}

package/dist/commands/sync/discovery.d.ts

@@ -0,0 +1,8 @@
+import type { KbConfigPaths } from "../../utils/config.js";
+export declare function normalizeMarkdownPath(pattern: string | undefined): string | null;
+export declare function discoverSourceFiles(cwd: string, paths: KbConfigPaths): Promise<{
+    markdownFiles: string[];
+    manifestFiles: string[];
+    relationshipsDir: string;
+}>;
+//# sourceMappingURL=discovery.d.ts.map

package/dist/commands/sync/discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../../src/commands/sync/discovery.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAE3D,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,MAAM,GAAG,SAAS,GAC1B,MAAM,GAAG,IAAI,CAIf;AAED,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,aAAa,GACnB,OAAO,CAAC;IACT,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,gBAAgB,EAAE,MAAM,CAAC;CAC1B,CAAC,CA0BD"}

package/dist/commands/sync/discovery.js

@@ -0,0 +1,50 @@
+/*
+ Kibi — repo-local, per-branch, queryable long-term memory for software projects
+ Copyright (C) 2026 Piotr Franczyk
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+import * as path from "node:path";
+import fg from "fast-glob";
+import { getRelationshipsDir } from "../../extractors/relationships.js";
+export function normalizeMarkdownPath(pattern) {
+    if (!pattern)
+        return null;
+    if (pattern.includes("*"))
+        return pattern;
+    return `${pattern}/**/*.md`;
+}
+export async function discoverSourceFiles(cwd, paths) {
+    const markdownPatterns = [
+        normalizeMarkdownPath(paths.requirements),
+        normalizeMarkdownPath(paths.scenarios),
+        normalizeMarkdownPath(paths.tests),
+        normalizeMarkdownPath(paths.adr),
+        normalizeMarkdownPath(paths.flags),
+        normalizeMarkdownPath(paths.events),
+        normalizeMarkdownPath(paths.facts),
+    ].filter((p) => Boolean(p));
+    const markdownFiles = await fg(markdownPatterns, {
+        cwd,
+        absolute: true,
+    });
+    const manifestFiles = paths.symbols
+        ? await fg(paths.symbols, {
+            cwd,
+            absolute: true,
+        })
+        : [];
+    const relationshipsDir = getRelationshipsDir(path.join(cwd, ".kb"));
+    return { markdownFiles, manifestFiles, relationshipsDir };
+}

package/dist/commands/sync/extraction.d.ts

@@ -0,0 +1,11 @@
+import { type ExtractionResult } from "../../extractors/markdown.js";
+export interface ExtractionOutput {
+    results: ExtractionResult[];
+    failedCacheKeys: Set<string>;
+    errors: {
+        file: string;
+        message: string;
+    }[];
+}
+export declare function processExtractions(changedMarkdownFiles: string[], changedManifestFiles: string[], validateOnly: boolean): Promise<ExtractionOutput>;
+//# sourceMappingURL=extraction.d.ts.map

package/dist/commands/sync/extraction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extraction.d.ts","sourceRoot":"","sources":["../../../src/commands/sync/extraction.ts"],"names":[],"mappings":"AAmBA,OAAO,EACL,KAAK,gBAAgB,EAGtB,MAAM,8BAA8B,CAAC;AAGtC,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,gBAAgB,EAAE,CAAC;IAC5B,eAAe,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC7B,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CAC7C;AAED,wBAAsB,kBAAkB,CACtC,oBAAoB,EAAE,MAAM,EAAE,EAC9B,oBAAoB,EAAE,MAAM,EAAE,EAC9B,YAAY,EAAE,OAAO,GACpB,OAAO,CAAC,gBAAgB,CAAC,CAoD3B"}

package/dist/commands/sync/extraction.js

@@ -0,0 +1,69 @@
+/*
+ Kibi — repo-local, per-branch, queryable long-term memory for software projects
+ Copyright (C) 2026 Piotr Franczyk
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+import { extractFromManifest } from "../../extractors/manifest.js";
+import { FrontmatterError, extractFromMarkdown, } from "../../extractors/markdown.js";
+import { toCacheKey } from "./cache.js";
+export async function processExtractions(changedMarkdownFiles, changedManifestFiles, validateOnly) {
+    const results = [];
+    const failedCacheKeys = new Set();
+    const errors = [];
+    for (const file of changedMarkdownFiles) {
+        try {
+            results.push(extractFromMarkdown(file));
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            // Handle INVALID_AUTHORING diagnostics for embedded entities
+            if (error instanceof FrontmatterError &&
+                error.classification === "Embedded Entity Violation") {
+                const embeddedTypes = message.includes("scenario") && message.includes("test")
+                    ? ["scenario", "test"]
+                    : message.includes("scenario")
+                        ? ["scenario"]
+                        : message.includes("test")
+                            ? ["test"]
+                            : ["entity"];
+                // Note: diagnostics are created by the caller
+            }
+            if (validateOnly) {
+                errors.push({ file, message });
+            }
+            else {
+                console.warn(`Warning: Failed to extract from ${file}: ${message}`);
+            }
+            failedCacheKeys.add(toCacheKey(file));
+        }
+    }
+    for (const file of changedManifestFiles) {
+        try {
+            const manifestResults = extractFromManifest(file);
+            results.push(...manifestResults);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (validateOnly) {
+                errors.push({ file, message });
+            }
+            else {
+                console.warn(`Warning: Failed to extract from ${file}: ${message}`);
+            }
+            failedCacheKeys.add(toCacheKey(file));
+        }
+    }
+    return { results, failedCacheKeys, errors };
+}

package/dist/commands/sync/manifest.d.ts

@@ -0,0 +1,5 @@
+import { type ManifestSymbolEntry } from "../../extractors/symbols-coordinator.js";
+export declare function refreshManifestCoordinates(manifestPath: string, workspaceRoot: string): Promise<void>;
+export declare function hasAllGeneratedCoordinates(entry: ManifestSymbolEntry): boolean;
+export declare function isEligibleForCoordinateRefresh(sourceFile: string | undefined, workspaceRoot: string): boolean;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/commands/sync/manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../../src/commands/sync/manifest.ts"],"names":[],"mappings":"AAqBA,OAAO,EACL,KAAK,mBAAmB,EAEzB,MAAM,yCAAyC,CAAC;AA6BjD,wBAAsB,0BAA0B,CAC9C,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,IAAI,CAAC,CAyEf;AAED,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,mBAAmB,GACzB,OAAO,CAST;AAED,wBAAgB,8BAA8B,CAC5C,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,aAAa,EAAE,MAAM,GACpB,OAAO,CAST"}