@seele00/seele 0.1.63 → 0.1.64

package/server/dist/conversations/knowledge.js

@@ -1,380 +0,0 @@
-import { existsSync, readdirSync, readFileSync, } from "node:fs";
-import path from "node:path";
-import { randomInt } from "node:crypto";
-import { getConversationWorkspaceDatabase, } from "./store.js";
-import { runInTransaction } from "../storage/sqlite.js";
-const KNOWLEDGE_ROOT = ".seele/knowledge";
-const KNOWLEDGE_URI_ROOT = "seele://knowledge";
-export function listWorkspaceKnowledge(conversation) {
-    migrateLegacyFileKnowledge(conversation);
-    const rows = getConversationWorkspaceDatabase(conversation)
-        .prepare("select data_json from workspace_knowledge order by updated_at desc")
-        .all();
-    return rows
-        .map((row) => parseStoredKnowledgeItem(conversation, row.data_json))
-        .filter((item) => item !== null)
-        .sort((left, right) => {
-        const attentionOrder = attentionRank(right.attention) - attentionRank(left.attention);
-        if (attentionOrder !== 0) {
-            return attentionOrder;
-        }
-        return right.updatedAt.localeCompare(left.updatedAt);
-    });
-}
-export function createWorkspaceKnowledge(conversation, input) {
-    const now = new Date().toISOString();
-    const id = createKnowledgeId(conversation);
-    const item = normalizeKnowledgeItem(conversation, {
-        id,
-        kind: parseKnowledgeKind(input.kind, "source"),
-        name: parseText(input.name, "Untitled knowledge"),
-        description: parseText(input.description),
-        purpose: parseText(input.purpose),
-        attention: parseKnowledgeAttention(input.attention, "tracked"),
-        refreshPolicy: parseKnowledgeRefreshPolicy(input.refreshPolicy, "manual"),
-        status: parseKnowledgeStatus(input.status, "draft"),
-        sourceClues: parseSourceClues(input.sourceClues, now),
-        fetch: {
-            type: "script",
-            scriptPath: relativeKnowledgePath(id, "fetch.sh"),
-            requiredEnv: parseRequiredEnv(input.requiredEnv),
-            verified: input.fetchVerified === true,
-            lastRunAt: parseNullableText(input.lastRunAt),
-            lastExitCode: typeof input.lastExitCode === "number"
-                ? Math.trunc(input.lastExitCode)
-                : null,
-            lastContentHash: parseNullableText(input.lastContentHash),
-        },
-        rawPath: relativeKnowledgePath(id, "raw"),
-        digestPath: relativeKnowledgePath(id, "digest.md"),
-        skillPath: relativeKnowledgePath(id, "skill.md"),
-        createdAt: now,
-        updatedAt: now,
-    });
-    writeKnowledgeItem(conversation, item);
-    return item;
-}
-export function updateWorkspaceKnowledge(conversation, id, input) {
-    const existing = readKnowledgeItem(conversation, id);
-    if (!existing) {
-        return null;
-    }
-    const item = normalizeKnowledgeItem(conversation, {
-        ...existing,
-        kind: parseKnowledgeKind(input.kind, existing.kind),
-        name: Object.prototype.hasOwnProperty.call(input, "name")
-            ? parseText(input.name, existing.name)
-            : existing.name,
-        description: Object.prototype.hasOwnProperty.call(input, "description")
-            ? parseText(input.description)
-            : existing.description,
-        purpose: Object.prototype.hasOwnProperty.call(input, "purpose")
-            ? parseText(input.purpose)
-            : existing.purpose,
-        attention: parseKnowledgeAttention(input.attention, existing.attention),
-        refreshPolicy: parseKnowledgeRefreshPolicy(input.refreshPolicy, existing.refreshPolicy),
-        status: parseKnowledgeStatus(input.status, existing.status),
-        sourceClues: Object.prototype.hasOwnProperty.call(input, "sourceClues")
-            ? parseSourceClues(input.sourceClues, new Date().toISOString())
-            : existing.sourceClues,
-        fetch: {
-            ...existing.fetch,
-            requiredEnv: Object.prototype.hasOwnProperty.call(input, "requiredEnv")
-                ? parseRequiredEnv(input.requiredEnv)
-                : existing.fetch.requiredEnv,
-            verified: Object.prototype.hasOwnProperty.call(input, "fetchVerified")
-                ? input.fetchVerified === true
-                : existing.fetch.verified,
-            lastRunAt: Object.prototype.hasOwnProperty.call(input, "lastRunAt")
-                ? parseNullableText(input.lastRunAt)
-                : existing.fetch.lastRunAt,
-            lastExitCode: Object.prototype.hasOwnProperty.call(input, "lastExitCode")
-                ? typeof input.lastExitCode === "number"
-                    ? Math.trunc(input.lastExitCode)
-                    : null
-                : existing.fetch.lastExitCode,
-            lastContentHash: Object.prototype.hasOwnProperty.call(input, "lastContentHash")
-                ? parseNullableText(input.lastContentHash)
-                : existing.fetch.lastContentHash,
-        },
-        updatedAt: new Date().toISOString(),
-    });
-    writeKnowledgeItem(conversation, item);
-    return item;
-}
-export function deleteWorkspaceKnowledge(conversation, id) {
-    migrateLegacyFileKnowledge(conversation);
-    const result = getConversationWorkspaceDatabase(conversation)
-        .prepare("delete from workspace_knowledge where id = ?")
-        .run(sanitizeKnowledgeId(id));
-    return result.changes > 0;
-}
-export function summarizeWorkspaceKnowledge(conversation) {
-    return listWorkspaceKnowledge(conversation).map((item) => ({
-        id: item.id,
-        kind: item.kind,
-        name: item.name,
-        purpose: item.purpose || item.description,
-        status: item.status,
-        attention: item.attention,
-        refreshPolicy: item.refreshPolicy,
-        rawPath: item.rawPath,
-        digestPath: item.digestPath,
-        skillPath: item.skillPath,
-        fetchScriptPath: item.fetch.scriptPath,
-        requiredEnv: item.fetch.requiredEnv,
-    }));
-}
-function readKnowledgeItem(conversation, id) {
-    const safeId = sanitizeKnowledgeId(id);
-    if (!safeId) {
-        return null;
-    }
-    migrateLegacyFileKnowledge(conversation);
-    const row = getConversationWorkspaceDatabase(conversation)
-        .prepare("select data_json from workspace_knowledge where id = ?")
-        .get(safeId);
-    return row?.data_json
-        ? parseStoredKnowledgeItem(conversation, row.data_json)
-        : null;
-}
-function writeKnowledgeItem(conversation, item) {
-    getConversationWorkspaceDatabase(conversation)
-        .prepare(`
-      insert into workspace_knowledge (id, data_json, created_at, updated_at)
-      values (@id, @dataJson, @createdAt, @updatedAt)
-      on conflict(id) do update set
-        data_json = excluded.data_json,
-        updated_at = excluded.updated_at
-    `)
-        .run({
-        id: item.id,
-        dataJson: JSON.stringify(item),
-        createdAt: item.createdAt,
-        updatedAt: item.updatedAt,
-    });
-}
-function parseStoredKnowledgeItem(conversation, dataJson) {
-    try {
-        const value = JSON.parse(dataJson);
-        return normalizeKnowledgeItem(conversation, value);
-    }
-    catch {
-        return null;
-    }
-}
-function migrateLegacyFileKnowledge(conversation) {
-    const db = getConversationWorkspaceDatabase(conversation);
-    const existing = db
-        .prepare("select count(*) as count from workspace_knowledge")
-        .get();
-    if (existing.count > 0) {
-        return;
-    }
-    const root = workspaceKnowledgeRoot(conversation);
-    if (!existsSync(root)) {
-        return;
-    }
-    const legacyItems = readdirSync(root, { withFileTypes: true })
-        .filter((entry) => entry.isDirectory())
-        .map((entry) => readLegacyKnowledgeItem(conversation, entry.name))
-        .filter((item) => item !== null);
-    const insert = db.prepare(`
-    insert or ignore into workspace_knowledge (id, data_json, created_at, updated_at)
-    values (@id, @dataJson, @createdAt, @updatedAt)
-  `);
-    runInTransaction(db, () => {
-        for (const item of legacyItems) {
-            insert.run({
-                id: item.id,
-                dataJson: JSON.stringify(item),
-                createdAt: item.createdAt,
-                updatedAt: item.updatedAt,
-            });
-        }
-    });
-}
-function readLegacyKnowledgeItem(conversation, id) {
-    const safeId = sanitizeKnowledgeId(id);
-    if (!safeId) {
-        return null;
-    }
-    const itemPath = path.join(workspaceKnowledgeItemRoot(conversation, safeId), "item.json");
-    if (!existsSync(itemPath)) {
-        return null;
-    }
-    try {
-        const value = JSON.parse(readFileSync(itemPath, "utf8"));
-        return normalizeKnowledgeItem(conversation, value);
-    }
-    catch {
-        return null;
-    }
-}
-function normalizeKnowledgeItem(conversation, item) {
-    const now = new Date().toISOString();
-    const id = sanitizeKnowledgeId(item.id) || createKnowledgeId(conversation);
-    const createdAt = parseNullableText(item.createdAt) ?? now;
-    return {
-        id,
-        kind: parseKnowledgeKind(item.kind, "source"),
-        name: parseText(item.name, "Untitled knowledge"),
-        description: parseText(item.description),
-        purpose: parseText(item.purpose),
-        attention: parseKnowledgeAttention(item.attention, "tracked"),
-        refreshPolicy: parseKnowledgeRefreshPolicy(item.refreshPolicy, "manual"),
-        status: parseKnowledgeStatus(item.status, "draft"),
-        sourceClues: parseSourceClues(item.sourceClues, createdAt),
-        fetch: {
-            type: "script",
-            scriptPath: parseRelativeKnowledgePath(item.fetch?.scriptPath, id) ??
-                relativeKnowledgePath(id, "fetch.sh"),
-            requiredEnv: parseRequiredEnv(item.fetch?.requiredEnv),
-            verified: item.fetch?.verified === true,
-            lastRunAt: parseNullableText(item.fetch?.lastRunAt),
-            lastExitCode: typeof item.fetch?.lastExitCode === "number"
-                ? Math.trunc(item.fetch.lastExitCode)
-                : null,
-            lastContentHash: parseNullableText(item.fetch?.lastContentHash),
-        },
-        rawPath: parseRelativeKnowledgePath(item.rawPath, id) ??
-            relativeKnowledgePath(id, "raw"),
-        digestPath: parseRelativeKnowledgePath(item.digestPath, id) ??
-            relativeKnowledgePath(id, "digest.md"),
-        skillPath: parseRelativeKnowledgePath(item.skillPath, id) ??
-            relativeKnowledgePath(id, "skill.md"),
-        createdAt,
-        updatedAt: parseNullableText(item.updatedAt) ?? createdAt,
-    };
-}
-function createKnowledgeId(conversation) {
-    for (let index = 0; index < 50; index += 1) {
-        const id = randomInt(36 ** 6).toString(36).padStart(6, "0");
-        const row = getConversationWorkspaceDatabase(conversation)
-            .prepare("select id from workspace_knowledge where id = ?")
-            .get(id);
-        if (!row) {
-            return id;
-        }
-    }
-    return randomInt(36 ** 8).toString(36).padStart(8, "0");
-}
-function workspaceKnowledgeRoot(conversation) {
-    return path.join(conversation.workspacePath, KNOWLEDGE_ROOT);
-}
-function workspaceKnowledgeItemRoot(conversation, id) {
-    return path.join(workspaceKnowledgeRoot(conversation), sanitizeKnowledgeId(id));
-}
-function relativeKnowledgePath(id, leaf) {
-    return `${KNOWLEDGE_URI_ROOT}/${sanitizeKnowledgeId(id)}/${leaf}`;
-}
-function parseRelativeKnowledgePath(value, id) {
-    const text = parseText(value);
-    if (!text) {
-        return null;
-    }
-    const normalized = text.replace(/\\/g, "/").replace(/^\/+/, "");
-    if (normalized.startsWith(`${KNOWLEDGE_ROOT}/${sanitizeKnowledgeId(id)}/`)) {
-        return normalized.replace(`${KNOWLEDGE_ROOT}/${sanitizeKnowledgeId(id)}`, `${KNOWLEDGE_URI_ROOT}/${sanitizeKnowledgeId(id)}`);
-    }
-    if (normalized.startsWith(`${KNOWLEDGE_URI_ROOT}/${sanitizeKnowledgeId(id)}/`)) {
-        return normalized;
-    }
-    return null;
-}
-function sanitizeKnowledgeId(value) {
-    return String(value ?? "")
-        .trim()
-        .toLowerCase()
-        .replace(/[^a-z0-9_-]/g, "")
-        .slice(0, 32);
-}
-function parseText(value, fallback = "") {
-    return typeof value === "string" ? value.trim() : fallback;
-}
-function parseNullableText(value) {
-    const text = parseText(value);
-    return text ? text : null;
-}
-function parseKnowledgeKind(value, fallback) {
-    return value === "source" || value === "skill" || value === "reference"
-        ? value
-        : fallback;
-}
-function parseKnowledgeAttention(value, fallback) {
-    return value === "none" || value === "tracked" || value === "watch"
-        ? value
-        : fallback;
-}
-function parseKnowledgeRefreshPolicy(value, fallback) {
-    return value === "manual" || value === "low-frequency-check"
-        ? value
-        : fallback;
-}
-function parseKnowledgeStatus(value, fallback) {
-    return value === "draft" ||
-        value === "needs_credentials" ||
-        value === "invalid_credentials" ||
-        value === "needs_fetch_method" ||
-        value === "ready" ||
-        value === "stale_signal"
-        ? value
-        : fallback;
-}
-function parseSourceClues(value, fallbackTime) {
-    if (!Array.isArray(value)) {
-        return [];
-    }
-    return value
-        .map((item) => {
-        if (!item || typeof item !== "object") {
-            return null;
-        }
-        const record = item;
-        const clueValue = parseText(record.value);
-        if (!clueValue) {
-            return null;
-        }
-        const providedBy = record.providedBy === "agent" || record.providedBy === "system"
-            ? record.providedBy
-            : "user";
-        return {
-            type: parseText(record.type, "text"),
-            value: clueValue,
-            providedBy,
-            providedAt: parseNullableText(record.providedAt) ?? fallbackTime,
-        };
-    })
-        .filter((item) => item !== null);
-}
-function parseRequiredEnv(value) {
-    if (!Array.isArray(value)) {
-        return [];
-    }
-    return value
-        .map((item) => {
-        if (!item || typeof item !== "object") {
-            return null;
-        }
-        const record = item;
-        const key = parseText(record.key).toUpperCase();
-        if (!/^[A-Z_][A-Z0-9_]*$/.test(key)) {
-            return null;
-        }
-        return {
-            key,
-            description: parseText(record.description),
-        };
-    })
-        .filter((item) => item !== null)
-        .sort((left, right) => left.key.localeCompare(right.key));
-}
-function attentionRank(value) {
-    if (value === "watch") {
-        return 2;
-    }
-    if (value === "tracked") {
-        return 1;
-    }
-    return 0;
-}