npm - forge-openclaw-plugin - Versions diffs - 0.2.50 → 0.2.52 - Mend

forge-openclaw-plugin 0.2.50 → 0.2.52

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

package/dist/assets/{index-C9_gJvi6.js → index-DX8RiahO.js} +46 -46
package/dist/assets/{index-C9_gJvi6.js.map → index-DX8RiahO.js.map} +1 -1
package/dist/assets/index-gthTrgvO.css +1 -0
package/dist/index.html +2 -2
package/dist/server/server/src/db.js +11 -0
package/dist/server/server/src/openapi.js +1 -1
package/dist/server/server/src/repositories/wiki-memory.js +1 -1
package/dist/server/server/src/services/legacy-wiki-markdown-import.js +364 -0
package/openclaw.plugin.json +1 -1
package/package.json +1 -1
package/dist/assets/index-2_tuemtU.css +0 -1

package/dist/index.html CHANGED Viewed

@@ -13,14 +13,14 @@
     />
     <link rel="icon" type="image/png" href="/forge/assets/favicon-BCHm9dUV.ico" />
     <link rel="alternate icon" href="/forge/assets/favicon-BCHm9dUV.ico" />
-    <script type="module" crossorigin src="/forge/assets/index-C9_gJvi6.js"></script>
+    <script type="module" crossorigin src="/forge/assets/index-DX8RiahO.js"></script>
     <link rel="modulepreload" crossorigin href="/forge/assets/vendor-D_NZFJze.js">
     <link rel="modulepreload" crossorigin href="/forge/assets/board-CAszQU7Y.js">
     <link rel="modulepreload" crossorigin href="/forge/assets/ui-B5MjRjKe.js">
     <link rel="modulepreload" crossorigin href="/forge/assets/motion-CU5aNClV.js">
     <link rel="modulepreload" crossorigin href="/forge/assets/table-CK0KcPYW.js">
     <link rel="stylesheet" crossorigin href="/forge/assets/vendor-DT3pnAKJ.css">
-    <link rel="stylesheet" crossorigin href="/forge/assets/index-2_tuemtU.css">
+    <link rel="stylesheet" crossorigin href="/forge/assets/index-gthTrgvO.css">
   </head>
   <body class="bg-canvas text-ink antialiased">
     <div id="root"></div>

package/dist/server/server/src/db.js CHANGED Viewed

@@ -79,6 +79,7 @@ export function resolveDefaultDataRoot(currentWorkingDir = process.cwd()) {
 }
 let dataRoot = resolveDefaultDataRoot();
 let seedDemoDataEnabled = false;
+let legacyWikiAutoImportEnabled = true;
 let db = null;
 let transactionDepth = 0;
 let savepointCounter = 0;
@@ -161,6 +162,9 @@ export function configureDatabase(options = {}) {
         seedDemoDataEnabled = options.seedDemoData;
     }
 }
+export function configureLegacyWikiAutoImport(enabled) {
+    legacyWikiAutoImportEnabled = enabled;
+}
 async function listMigrationFiles() {
     const files = await readdir(migrationsDir);
     return files.filter((file) => file.endsWith(".sql")).sort();
@@ -389,6 +393,13 @@ export async function initializeDatabase() {
         seedData();
     }
     ensureQuestionnaireSeeds();
+    if (legacyWikiAutoImportEnabled) {
+        const { importLegacyWikiMarkdownOnStartup } = await import("./services/legacy-wiki-markdown-import.js");
+        const legacyWikiImport = await importLegacyWikiMarkdownOnStartup(getDataDir());
+        if (legacyWikiImport.scanned > 0) {
+            logForgeDebug(`[forge-db] imported legacy wiki markdown scanned=${legacyWikiImport.scanned} inserted=${legacyWikiImport.inserted} updated=${legacyWikiImport.updated} backed_up=${legacyWikiImport.backedUp} backup_path=${legacyWikiImport.backupPath}`);
+        }
+    }
 }
 export function configureDatabaseSeeding(enabled) {
     seedDemoDataEnabled = enabled;

package/dist/server/server/src/openapi.js CHANGED Viewed

@@ -115,7 +115,7 @@ const API_TAGS = [
     },
     {
         name: "Wiki",
-        description: "File-first wiki settings, pages, ingest, sync, health, and search."
+        description: "SQLite-backed wiki settings, pages, ingest, sync, health, and search."
     },
     {
         name: "Preferences",

package/dist/server/server/src/repositories/wiki-memory.js CHANGED Viewed

@@ -1481,7 +1481,7 @@ export function listWikiSpaces() {
     const rows = getDatabase()
         .prepare(`SELECT id, slug, label, description, owner_user_id, visibility, created_at, updated_at
        FROM wiki_spaces
-       ORDER BY visibility ASC, updated_at DESC`)
+       ORDER BY CASE WHEN visibility = 'shared' THEN 0 ELSE 1 END, updated_at DESC`)
         .all();
     const spaces = rows.map(mapWikiSpace);
     for (const space of spaces) {

package/dist/server/server/src/services/legacy-wiki-markdown-import.js ADDED Viewed

@@ -0,0 +1,364 @@
+import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
+import { cp, mkdir, readdir, readFile, rm } from "node:fs/promises";
+import path from "node:path";
+import { getDatabase, getEffectiveDataRoot } from "../db.js";
+import { getNoteById } from "../repositories/notes.js";
+import { syncNoteWikiArtifacts } from "../repositories/wiki-memory.js";
+const startupImportMarkerId = "runtime:legacy-wiki-markdown-import:v1";
+function parseFrontmatter(markdown) {
+    const normalized = markdown.replace(/\r\n/g, "\n");
+    const match = normalized.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+    if (!match) {
+        return { frontmatter: {}, body: normalized };
+    }
+    const frontmatter = {};
+    for (const line of match[1].split("\n")) {
+        const separatorIndex = line.indexOf(":");
+        if (separatorIndex <= 0) {
+            throw new Error(`Malformed frontmatter line: ${line}`);
+        }
+        const key = line.slice(0, separatorIndex).trim();
+        const rawValue = line.slice(separatorIndex + 1).trim();
+        if (!key) {
+            throw new Error(`Malformed empty frontmatter key: ${line}`);
+        }
+        try {
+            frontmatter[key] = JSON.parse(rawValue);
+        }
+        catch {
+            frontmatter[key] = rawValue.replace(/^"(.*)"$/, "$1");
+        }
+    }
+    return { frontmatter, body: match[2] };
+}
+function slugify(value) {
+    const normalized = value
+        .toLowerCase()
+        .normalize("NFKD")
+        .replace(/[^\w\s-]/g, "")
+        .trim()
+        .replace(/[\s_]+/g, "-")
+        .replace(/-+/g, "-");
+    return normalized || "imported-page";
+}
+function stripMarkdown(markdown) {
+    return markdown
+        .replace(/```[\s\S]*?```/g, " ")
+        .replace(/`([^`]+)`/g, "$1")
+        .replace(/!\[[^\]]*\]\([^)]*\)/g, " ")
+        .replace(/\[([^\]]+)\]\([^)]*\)/g, "$1")
+        .replace(/[#>*_\-~]/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function inferTitle(markdown, fallback) {
+    const heading = markdown.match(/^#\s+(.+)$/m)?.[1]?.trim();
+    return heading || fallback.trim() || "Imported wiki page";
+}
+function inferSummary(markdown) {
+    return stripMarkdown(markdown).slice(0, 240);
+}
+function normalizeStringArray(value) {
+    return Array.isArray(value)
+        ? value.filter((entry) => typeof entry === "string")
+        : [];
+}
+function normalizeLinkedEntities(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.flatMap((entry) => {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+            return [];
+        }
+        const record = entry;
+        if (typeof record.entityType !== "string" ||
+            typeof record.entityId !== "string") {
+            return [];
+        }
+        return [
+            {
+                entityType: record.entityType,
+                entityId: record.entityId,
+                anchorKey: typeof record.anchorKey === "string" ? record.anchorKey : ""
+            }
+        ];
+    });
+}
+async function walkMarkdownFiles(root) {
+    const results = [];
+    async function visit(directory) {
+        if (!existsSync(directory)) {
+            return;
+        }
+        for (const entry of await readdir(directory, { withFileTypes: true })) {
+            const entryPath = path.join(directory, entry.name);
+            if (entry.isDirectory()) {
+                await visit(entryPath);
+                continue;
+            }
+            if (entry.isFile() && entry.name.endsWith(".md")) {
+                results.push(entryPath);
+            }
+        }
+    }
+    await visit(root);
+    return results.sort();
+}
+function findSpaceForFile(dataRoot, filePath, parsed) {
+    const explicitSpaceId = typeof parsed.frontmatter.spaceId === "string"
+        ? parsed.frontmatter.spaceId
+        : "";
+    if (explicitSpaceId) {
+        const row = getDatabase()
+            .prepare("SELECT id FROM wiki_spaces WHERE id = ?")
+            .get(explicitSpaceId);
+        if (row) {
+            return row.id;
+        }
+    }
+    const relative = path.relative(path.join(dataRoot, "wiki"), filePath);
+    const parts = relative.split(path.sep);
+    if (parts[0] === "shared" && parts[1]) {
+        const row = getDatabase()
+            .prepare("SELECT id FROM wiki_spaces WHERE visibility = 'shared' AND slug = ?")
+            .get(parts[1]);
+        if (row) {
+            return row.id;
+        }
+    }
+    if (parts[0] === "users" && parts[1]) {
+        const row = getDatabase()
+            .prepare("SELECT id FROM wiki_spaces WHERE owner_user_id = ? OR slug = ?")
+            .get(parts[1], parts[1]);
+        if (row) {
+            return row.id;
+        }
+        return ensurePersonalWikiSpaceForLegacyUser(parts[1]);
+    }
+    return "wiki_space_shared";
+}
+function findExistingNote(input) {
+    if (input.id) {
+        const byId = getDatabase()
+            .prepare("SELECT id FROM notes WHERE id = ?")
+            .get(input.id);
+        if (byId) {
+            return byId.id;
+        }
+    }
+    const bySlug = getDatabase()
+        .prepare("SELECT id FROM notes WHERE space_id = ? AND slug = ?")
+        .get(input.spaceId, input.slug);
+    return bySlug?.id ?? null;
+}
+function ensurePersonalWikiSpaceForLegacyUser(userId) {
+    const row = getDatabase()
+        .prepare(`SELECT id FROM wiki_spaces
+       WHERE owner_user_id = ? OR slug = ? OR slug = ? OR id = ?
+       ORDER BY created_at ASC
+       LIMIT 1`)
+        .get(userId, userId, `user-${slugify(userId)}`, `wiki_space_user_${slugify(userId)}`);
+    if (row) {
+        return row.id;
+    }
+    const now = new Date().toISOString();
+    const id = `wiki_space_user_${slugify(userId)}`;
+    getDatabase()
+        .prepare(`INSERT INTO wiki_spaces (id, slug, label, description, owner_user_id, visibility, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO NOTHING`)
+        .run(id, `user-${slugify(userId)}`, `${userId} Wiki`, "Personal Forge wiki space recovered from legacy wiki files.", userId, "personal", now, now);
+    const inserted = getDatabase()
+        .prepare("SELECT id FROM wiki_spaces WHERE id = ?")
+        .get(id);
+    return inserted?.id ?? "wiki_space_shared";
+}
+function upsertLinks(noteId, links) {
+    getDatabase().prepare("DELETE FROM note_links WHERE note_id = ?").run(noteId);
+    const createdAt = new Date().toISOString();
+    const statement = getDatabase().prepare(`INSERT OR IGNORE INTO note_links (note_id, entity_type, entity_id, anchor_key, created_at)
+     VALUES (?, ?, ?, ?, ?)`);
+    for (const link of links) {
+        statement.run(noteId, link.entityType, link.entityId, link.anchorKey, createdAt);
+    }
+}
+function legacyBackupPath(dataRoot, backupLabel) {
+    return path.join(dataRoot, "backups", backupLabel, "wiki");
+}
+async function backupWikiRootOnce(input) {
+    const backupPath = legacyBackupPath(input.dataRoot, input.backupLabel);
+    if (existsSync(backupPath)) {
+        return { backupPath, backedUp: false };
+    }
+    await mkdir(path.dirname(backupPath), { recursive: true });
+    await cp(input.wikiRoot, backupPath, { recursive: true, force: false });
+    return { backupPath, backedUp: true };
+}
+export async function importLegacyWikiMarkdownToSqlite(input = {}) {
+    const options = {
+        dataRoot: path.resolve(input.dataRoot ?? getEffectiveDataRoot()),
+        apply: input.apply ?? false,
+        deleteFiles: input.deleteFiles ?? false,
+        backupBeforeApply: input.backupBeforeApply ?? false,
+        backupLabel: input.backupLabel ?? "legacy-wiki-markdown-pre-sqlite-import",
+        preserveExistingNotes: input.preserveExistingNotes ?? false
+    };
+    const wikiRoot = path.join(options.dataRoot, "wiki");
+    const files = await walkMarkdownFiles(wikiRoot);
+    let scanned = 0;
+    let inserted = 0;
+    let updated = 0;
+    let deleted = 0;
+    let backupPath = legacyBackupPath(options.dataRoot, options.backupLabel);
+    let backedUp = false;
+    if (options.apply && options.backupBeforeApply && files.length > 0) {
+        const backup = await backupWikiRootOnce({
+            wikiRoot,
+            dataRoot: options.dataRoot,
+            backupLabel: options.backupLabel
+        });
+        backupPath = backup.backupPath;
+        backedUp = backup.backedUp;
+    }
+    for (const filePath of files) {
+        scanned += 1;
+        const parsed = parseFrontmatter(await readFile(filePath, "utf8"));
+        const kind = filePath.includes(`${path.sep}pages${path.sep}`)
+            ? "wiki"
+            : "evidence";
+        const spaceId = findSpaceForFile(options.dataRoot, filePath, parsed);
+        const markdown = parsed.body.trim();
+        const id = typeof parsed.frontmatter.id === "string" && parsed.frontmatter.id.trim()
+            ? parsed.frontmatter.id.trim()
+            : `note_${createHash("sha1").update(filePath).digest("hex").slice(0, 10)}`;
+        const title = typeof parsed.frontmatter.title === "string"
+            ? parsed.frontmatter.title
+            : inferTitle(markdown, path.basename(filePath, ".md"));
+        const slug = typeof parsed.frontmatter.slug === "string"
+            ? parsed.frontmatter.slug
+            : slugify(path.basename(filePath, ".md"));
+        const aliases = normalizeStringArray(parsed.frontmatter.aliases);
+        const tags = normalizeStringArray(parsed.frontmatter.tags);
+        const summary = typeof parsed.frontmatter.summary === "string"
+            ? parsed.frontmatter.summary
+            : inferSummary(markdown);
+        const contentPlain = stripMarkdown(markdown);
+        const links = normalizeLinkedEntities(parsed.frontmatter.linkedEntities);
+        const noteId = findExistingNote({ id, spaceId, slug });
+        const now = new Date().toISOString();
+        if (!options.apply) {
+            if (noteId) {
+                updated += 1;
+            }
+            else {
+                inserted += 1;
+            }
+            continue;
+        }
+        if (noteId) {
+            const existingNote = getNoteById(noteId, { skipCleanup: true });
+            if (options.preserveExistingNotes &&
+                existingNote &&
+                existingNote.contentMarkdown.trim().length > 0) {
+                getDatabase()
+                    .prepare("UPDATE notes SET source_path = '' WHERE id = ? AND source_path <> ''")
+                    .run(noteId);
+                syncNoteWikiArtifacts(existingNote);
+                updated += 1;
+                continue;
+            }
+            getDatabase()
+                .prepare(`UPDATE notes
+           SET kind = ?, title = ?, slug = ?, space_id = ?, parent_slug = ?, index_order = ?, show_in_index = ?,
+               aliases_json = ?, summary = ?, content_markdown = ?, content_plain = ?, tags_json = ?,
+               source_path = '', frontmatter_json = ?, updated_at = ?
+           WHERE id = ?`)
+                .run(kind, title, slug, spaceId, typeof parsed.frontmatter.parentSlug === "string"
+                ? parsed.frontmatter.parentSlug
+                : null, typeof parsed.frontmatter.indexOrder === "number"
+                ? Math.trunc(parsed.frontmatter.indexOrder)
+                : 0, parsed.frontmatter.showInIndex === false ? 0 : 1, JSON.stringify(aliases), summary, markdown, contentPlain, JSON.stringify(tags), JSON.stringify(parsed.frontmatter), now, noteId);
+            upsertLinks(noteId, links);
+            const note = getNoteById(noteId, { skipCleanup: true });
+            if (note) {
+                syncNoteWikiArtifacts(note);
+            }
+            updated += 1;
+        }
+        else {
+            getDatabase()
+                .prepare(`INSERT INTO notes (
+            id, kind, title, slug, space_id, parent_slug, index_order, show_in_index, aliases_json, summary,
+            content_markdown, content_plain, author, source, tags_json, destroy_at, source_path, frontmatter_json,
+            revision_hash, last_synced_at, created_at, updated_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, '', ?, '', NULL, ?, ?)`)
+                .run(id, kind, title, slug, spaceId, typeof parsed.frontmatter.parentSlug === "string"
+                ? parsed.frontmatter.parentSlug
+                : null, typeof parsed.frontmatter.indexOrder === "number"
+                ? Math.trunc(parsed.frontmatter.indexOrder)
+                : 0, parsed.frontmatter.showInIndex === false ? 0 : 1, JSON.stringify(aliases), summary, markdown, contentPlain, typeof parsed.frontmatter.author === "string"
+                ? parsed.frontmatter.author
+                : null, "system", JSON.stringify(tags), null, JSON.stringify(parsed.frontmatter), now, now);
+            upsertLinks(id, links);
+            const note = getNoteById(id, { skipCleanup: true });
+            if (note) {
+                syncNoteWikiArtifacts(note);
+            }
+            inserted += 1;
+        }
+        if (options.deleteFiles) {
+            await rm(filePath, { force: true });
+            deleted += 1;
+        }
+    }
+    return {
+        dataRoot: options.dataRoot,
+        scanned,
+        wouldApply: options.apply,
+        wouldDelete: options.deleteFiles,
+        inserted,
+        updated,
+        deleted,
+        backupPath,
+        backedUp,
+        skippedAlreadyImported: false
+    };
+}
+function hasStartupImportMarker() {
+    const row = getDatabase()
+        .prepare("SELECT id FROM migrations WHERE id = ?")
+        .get(startupImportMarkerId);
+    return Boolean(row);
+}
+function markStartupImportComplete() {
+    getDatabase()
+        .prepare("INSERT OR IGNORE INTO migrations (id, applied_at) VALUES (?, ?)")
+        .run(startupImportMarkerId, new Date().toISOString());
+}
+export async function importLegacyWikiMarkdownOnStartup(dataRoot = getEffectiveDataRoot()) {
+    if (hasStartupImportMarker()) {
+        return {
+            dataRoot: path.resolve(dataRoot),
+            scanned: 0,
+            wouldApply: true,
+            wouldDelete: false,
+            inserted: 0,
+            updated: 0,
+            deleted: 0,
+            backupPath: legacyBackupPath(path.resolve(dataRoot), "legacy-wiki-markdown-pre-sqlite-import"),
+            backedUp: false,
+            skippedAlreadyImported: true
+        };
+    }
+    const result = await importLegacyWikiMarkdownToSqlite({
+        dataRoot,
+        apply: true,
+        deleteFiles: false,
+        backupBeforeApply: true,
+        preserveExistingNotes: true
+    });
+    markStartupImportComplete();
+    return result;
+}

package/openclaw.plugin.json CHANGED Viewed

@@ -2,7 +2,7 @@
   "id": "forge-openclaw-plugin",
   "name": "Forge",
   "description": "Curated OpenClaw adapter for the Forge collaboration API, UI entrypoint, and localhost auto-start runtime.",
-  "version": "0.2.50",
+  "version": "0.2.52",
   "skills": [
     "./skills"
   ],

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "forge-openclaw-plugin",
-  "version": "0.2.50",
+  "version": "0.2.52",
   "description": "Curated OpenClaw adapter for the Forge collaboration API, UI entrypoint, and localhost auto-start runtime.",
   "type": "module",
   "license": "MIT",