@lanonasis/recall-forge 1.1.1

package/dist/cli-common.js

@@ -0,0 +1,338 @@
+import { readFile } from "node:fs/promises";
+export const MEMORY_TYPES = [
+    "context",
+    "project",
+    "knowledge",
+    "reference",
+    "personal",
+    "workflow",
+];
+const SORT_FIELD_MAP = {
+    created_at: "created_at",
+    updated_at: "updated_at",
+    title: "title",
+    type: "memory_type",
+};
+function errorMessage(error) {
+    if (error instanceof Error && error.message.trim()) {
+        return error.message;
+    }
+    return typeof error === "string" && error.trim() ? error : "unknown error";
+}
+export function exitWithError(error) {
+    console.error(`Error: ${errorMessage(error)}`);
+    process.exit(1);
+}
+export function isNotFoundError(error) {
+    const message = errorMessage(error);
+    return message.includes("(404)") || /\b404\b/.test(message);
+}
+export function normalizeTextInput(label, value) {
+    if (value === undefined)
+        return undefined;
+    const normalized = value.trim();
+    if (!normalized) {
+        throw new Error(`${label} cannot be empty or whitespace-only.`);
+    }
+    return normalized;
+}
+export async function resolveContentInput(options) {
+    const { content, contentFile, required = false } = options;
+    if (content !== undefined && contentFile !== undefined) {
+        throw new Error("Provide either --content or --content-file, not both.");
+    }
+    if (contentFile !== undefined) {
+        try {
+            const fileContent = await readFile(contentFile, "utf8");
+            return normalizeTextInput("Content", fileContent);
+        }
+        catch (error) {
+            throw new Error(`Unable to read content file "${contentFile}": ${errorMessage(error)}`);
+        }
+    }
+    const normalized = normalizeTextInput("Content", content);
+    if (required && normalized === undefined) {
+        throw new Error("Provide one of --content or --content-file.");
+    }
+    return normalized;
+}
+export function parseTags(input) {
+    if (input === undefined)
+        return undefined;
+    const tags = [...new Set(input.split(",").map((tag) => tag.trim()).filter(Boolean))];
+    if (tags.length === 0) {
+        throw new Error("`--tags` must include at least one non-empty tag.");
+    }
+    return tags;
+}
+export function parsePositiveInt(flag, raw, defaultValue) {
+    if (raw === undefined)
+        return defaultValue;
+    const value = Number(raw);
+    if (!Number.isInteger(value) || value <= 0) {
+        throw new Error(`${flag} must be a positive integer.`);
+    }
+    return value;
+}
+export function parseThreshold(raw) {
+    if (raw === undefined)
+        return undefined;
+    const value = Number(raw);
+    if (!Number.isFinite(value) || value < 0 || value > 1) {
+        throw new Error("--threshold must be a number between 0 and 1.");
+    }
+    return value;
+}
+export function parseMemoryType(raw, flag = "--type") {
+    if (raw === undefined)
+        return undefined;
+    const normalized = raw.trim().toLowerCase();
+    if (!normalized) {
+        throw new Error(`${flag} cannot be empty or whitespace-only.`);
+    }
+    if (!MEMORY_TYPES.includes(normalized)) {
+        throw new Error(`${flag} must be one of: ${MEMORY_TYPES.join(", ")}.`);
+    }
+    return normalized;
+}
+export function parseSortField(raw) {
+    if (raw === undefined)
+        return undefined;
+    const normalized = raw.trim().toLowerCase();
+    if (!normalized) {
+        throw new Error("--sort cannot be empty or whitespace-only.");
+    }
+    const sortField = SORT_FIELD_MAP[normalized];
+    if (!sortField) {
+        throw new Error("--sort must be one of: created_at, updated_at, title, type.");
+    }
+    return sortField;
+}
+export function parseSortOrder(raw) {
+    if (raw === undefined)
+        return undefined;
+    const normalized = raw.trim().toLowerCase();
+    if (normalized !== "asc" && normalized !== "desc") {
+        throw new Error("--order must be either asc or desc.");
+    }
+    return normalized;
+}
+export function requireMemoryId(id) {
+    const normalized = normalizeTextInput("Memory ID", id);
+    if (!normalized) {
+        throw new Error("Memory ID is required.");
+    }
+    return normalized;
+}
+export function requireUpdateFields(updates, message = "Provide at least one field to update: --title, --content, --content-file, --type, or --tags.") {
+    if (Object.keys(updates).length === 0) {
+        throw new Error(message);
+    }
+}
+export function formatPreview(content, maxLength = 140) {
+    const normalized = content.replace(/\s+/g, " ").trim();
+    if (!normalized)
+        return "";
+    if (normalized.length <= maxLength)
+        return normalized;
+    return `${normalized.slice(0, maxLength - 3).trimEnd()}...`;
+}
+export function memoryTypeOf(memory) {
+    return memory.memory_type ?? memory.type ?? "unknown";
+}
+function formatTags(tags) {
+    return tags && tags.length > 0 ? tags.join(", ") : "(none)";
+}
+export function similarityOf(memory) {
+    return memory.similarity ?? memory.similarity_score;
+}
+export function printMemorySummary(memory, heading) {
+    const lines = [
+        `${heading}:`,
+        `  ID: ${memory.id}`,
+        `  Title: ${memory.title}`,
+        `  Type: ${memoryTypeOf(memory)}`,
+        `  Tags: ${formatTags(memory.tags)}`,
+    ];
+    if (memory.created_at)
+        lines.push(`  Created: ${memory.created_at}`);
+    if (memory.updated_at)
+        lines.push(`  Updated: ${memory.updated_at}`);
+    const preview = formatPreview(memory.content);
+    if (preview)
+        lines.push(`  Preview: ${preview}`);
+    console.log(lines.join("\n"));
+}
+export function printMemoryDetail(memory) {
+    const lines = [
+        `ID: ${memory.id}`,
+        `Title: ${memory.title}`,
+        `Type: ${memoryTypeOf(memory)}`,
+        `Tags: ${formatTags(memory.tags)}`,
+        `Created: ${memory.created_at ?? "(unknown)"}`,
+        `Updated: ${memory.updated_at ?? "(unknown)"}`,
+        "",
+        "Content:",
+        memory.content,
+        "",
+        "Metadata:",
+        JSON.stringify(memory.metadata ?? {}, null, 2),
+    ];
+    console.log(lines.join("\n"));
+}
+export function assertMemoryStatsShape(stats) {
+    if (!stats || typeof stats !== "object") {
+        throw new Error("Stats endpoint returned an invalid response. Expected an object.");
+    }
+    const typedStats = stats;
+    if (typeof typedStats.total_memories !== "number") {
+        throw new Error("Stats endpoint returned an invalid response. Missing numeric total_memories.");
+    }
+    const byType = typedStats.memories_by_type ?? typedStats.by_type;
+    if (!byType || typeof byType !== "object" || Array.isArray(byType)) {
+        throw new Error("Stats endpoint returned an invalid response. Missing object memories_by_type or by_type.");
+    }
+    for (const [key, value] of Object.entries(byType)) {
+        if (typeof value !== "number") {
+            throw new Error(`Stats endpoint returned an invalid response. by_type.${key} must be numeric.`);
+        }
+    }
+    if (typedStats.with_embeddings !== undefined &&
+        typeof typedStats.with_embeddings !== "number") {
+        throw new Error("Stats endpoint returned an invalid response. with_embeddings must be numeric.");
+    }
+    if (typedStats.without_embeddings !== undefined &&
+        typeof typedStats.without_embeddings !== "number") {
+        throw new Error("Stats endpoint returned an invalid response. without_embeddings must be numeric.");
+    }
+    if (typedStats.recent_activity !== undefined) {
+        if (!typedStats.recent_activity ||
+            typeof typedStats.recent_activity !== "object" ||
+            Array.isArray(typedStats.recent_activity)) {
+            throw new Error("Stats endpoint returned an invalid response. recent_activity must be an object.");
+        }
+        for (const [key, value] of Object.entries(typedStats.recent_activity)) {
+            if (typeof value !== "number") {
+                throw new Error(`Stats endpoint returned an invalid response. recent_activity.${key} must be numeric.`);
+            }
+        }
+    }
+    if (typedStats.top_tags !== undefined) {
+        if (!Array.isArray(typedStats.top_tags) ||
+            typedStats.top_tags.some((entry) => {
+                if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+                    return true;
+                }
+                const typedEntry = entry;
+                return (typeof typedEntry.tag !== "string" ||
+                    typeof typedEntry.count !== "number");
+            })) {
+            throw new Error("Stats endpoint returned an invalid response. top_tags must be an array of { tag, count } objects.");
+        }
+    }
+    if (typedStats.storage !== undefined &&
+        (!typedStats.storage ||
+            typeof typedStats.storage !== "object" ||
+            Array.isArray(typedStats.storage))) {
+        throw new Error("Stats endpoint returned an invalid response. storage must be an object.");
+    }
+    if (typedStats.organization_id !== undefined &&
+        typeof typedStats.organization_id !== "string") {
+        throw new Error("Stats endpoint returned an invalid response. organization_id must be a string.");
+    }
+    if (typedStats.generated_at !== undefined &&
+        typeof typedStats.generated_at !== "string") {
+        throw new Error("Stats endpoint returned an invalid response. generated_at must be a string.");
+    }
+    if (typedStats.total_topics !== undefined &&
+        typeof typedStats.total_topics !== "number") {
+        throw new Error("Stats endpoint returned an invalid response. total_topics must be numeric.");
+    }
+    if (typedStats.most_accessed_memory !== undefined &&
+        typeof typedStats.most_accessed_memory !== "string") {
+        throw new Error("Stats endpoint returned an invalid response. most_accessed_memory must be a string.");
+    }
+    if (typedStats.recent_memories !== undefined &&
+        (!Array.isArray(typedStats.recent_memories) ||
+            typedStats.recent_memories.some((entry) => typeof entry !== "string"))) {
+        throw new Error("Stats endpoint returned an invalid response. recent_memories must be an array of strings.");
+    }
+    return {
+        total_memories: typedStats.total_memories,
+        memories_by_type: byType,
+        with_embeddings: typedStats.with_embeddings,
+        without_embeddings: typedStats.without_embeddings,
+        recent_activity: typedStats.recent_activity,
+        top_tags: typedStats.top_tags,
+        storage: typedStats.storage,
+        organization_id: typedStats.organization_id,
+        generated_at: typedStats.generated_at,
+        total_topics: typedStats.total_topics,
+        most_accessed_memory: typedStats.most_accessed_memory,
+        recent_memories: typedStats.recent_memories,
+    };
+}
+export function printMemoryStats(stats) {
+    console.log(`Total memories: ${stats.total_memories}`);
+    if (stats.organization_id) {
+        console.log(`Organization: ${stats.organization_id}`);
+    }
+    if (stats.generated_at) {
+        console.log(`Generated: ${stats.generated_at}`);
+    }
+    if (typeof stats.total_topics === "number") {
+        console.log(`Total topics: ${stats.total_topics}`);
+    }
+    if (typeof stats.with_embeddings === "number" ||
+        typeof stats.without_embeddings === "number") {
+        console.log(`Embeddings: with=${stats.with_embeddings ?? 0}, without=${stats.without_embeddings ?? 0}`);
+    }
+    console.log("");
+    console.log("By type:");
+    const byTypeEntries = Object.entries(stats.memories_by_type).sort((a, b) => b[1] - a[1]);
+    if (byTypeEntries.length === 0) {
+        console.log("  (none)");
+    }
+    else {
+        byTypeEntries.forEach(([type, count]) => {
+            console.log(`  ${type.padEnd(12)}: ${count}`);
+        });
+    }
+    if (stats.recent_activity) {
+        console.log("");
+        console.log("Recent activity (24h):");
+        console.log(`  created : ${stats.recent_activity.created_last_24h ?? 0}`);
+        console.log(`  updated : ${stats.recent_activity.updated_last_24h ?? 0}`);
+        console.log(`  accessed: ${stats.recent_activity.accessed_last_24h ?? 0}`);
+    }
+    if (stats.most_accessed_memory) {
+        console.log("");
+        console.log(`Most accessed: ${stats.most_accessed_memory}`);
+    }
+    if (stats.recent_memories && stats.recent_memories.length > 0) {
+        console.log("");
+        console.log("Recent memories:");
+        stats.recent_memories.forEach((entry) => {
+            console.log(`  - ${entry}`);
+        });
+    }
+    if (stats.top_tags && stats.top_tags.length > 0) {
+        console.log("");
+        console.log("Top tags:");
+        stats.top_tags.forEach((entry) => {
+            console.log(`  ${entry.tag}: ${entry.count}`);
+        });
+    }
+    if (stats.storage && Object.keys(stats.storage).length > 0) {
+        console.log("");
+        console.log("Storage:");
+        Object.entries(stats.storage).forEach(([key, value]) => {
+            const rendered = typeof value === "string" ||
+                typeof value === "number" ||
+                typeof value === "boolean"
+                ? String(value)
+                : JSON.stringify(value);
+            console.log(`  ${key}: ${rendered}`);
+        });
+    }
+}

package/dist/cli-memory.d.ts

@@ -0,0 +1,6 @@
+import type { LanonasisClient } from "./client.js";
+import type { LanonasisConfig } from "./config.js";
+export declare function registerMemoryCli(cmd: any, getRuntime: () => {
+    client: LanonasisClient;
+    cfg: LanonasisConfig;
+}): void;

package/dist/cli-memory.js

@@ -0,0 +1,146 @@
+import { exitWithError, isNotFoundError, parseMemoryType, parseTags, printMemoryDetail, printMemorySummary, requireMemoryId, requireUpdateFields, resolveContentInput, normalizeTextInput, } from "./cli-common.js";
+import { detectMemoryType } from "./enrichment/type-detector.js";
+import { extractTags } from "./enrichment/tag-extractor.js";
+function buildCliMetadata(cfg) {
+    return {
+        agent_id: cfg.agentId,
+        source: "openclaw-cli",
+        captured_at: new Date().toISOString(),
+    };
+}
+async function runDelete(client, rawId, options, deprecated = false) {
+    try {
+        const id = requireMemoryId(rawId);
+        if (deprecated) {
+            console.error("Warning: `forget` is deprecated and will be removed after two tagged releases. Use `delete` or `rm`.");
+        }
+        if (!options.force) {
+            throw new Error("Deletion requires --force. Re-run as `openclaw recall delete <id> --force`.");
+        }
+        await client.deleteMemory(id);
+        console.log(`Deleted memory: ${id}`);
+    }
+    catch (error) {
+        if (isNotFoundError(error)) {
+            exitWithError(`Memory not found: ${rawId}`);
+        }
+        exitWithError(error);
+    }
+}
+export function registerMemoryCli(cmd, getRuntime) {
+    cmd
+        .command("create")
+        .alias("add")
+        .description("Create a memory")
+        .requiredOption("--title <title>", "Memory title")
+        .option("--content <content>", "Memory content")
+        .option("--content-file <path>", "Read memory content from a file")
+        .option("--type <type>", "Memory type")
+        .option("--tags <tags>", "Comma-separated tags")
+        .action(async (options) => {
+        try {
+            const { client, cfg } = getRuntime();
+            const title = normalizeTextInput("Title", options.title);
+            if (!title) {
+                throw new Error("`--title` is required.");
+            }
+            const content = await resolveContentInput({
+                content: options.content,
+                contentFile: options.contentFile,
+                required: true,
+            });
+            if (!content) {
+                throw new Error("Provide one of --content or --content-file.");
+            }
+            const type = parseMemoryType(options.type) ?? detectMemoryType(content);
+            const tags = parseTags(options.tags) ?? extractTags(content);
+            const memory = await client.createMemory({
+                title,
+                content,
+                type,
+                tags,
+                metadata: buildCliMetadata(cfg),
+            });
+            printMemorySummary(memory, "Created memory");
+        }
+        catch (error) {
+            exitWithError(error);
+        }
+    });
+    cmd
+        .command("get <id>")
+        .alias("show")
+        .description("Get a memory by ID")
+        .action(async (rawId) => {
+        try {
+            const { client } = getRuntime();
+            const id = requireMemoryId(rawId);
+            const memory = await client.getMemory(id);
+            printMemoryDetail(memory);
+        }
+        catch (error) {
+            if (isNotFoundError(error)) {
+                exitWithError(`Memory not found: ${rawId}`);
+            }
+            exitWithError(error);
+        }
+    });
+    cmd
+        .command("update <id>")
+        .description("Update an existing memory")
+        .option("--title <title>", "New memory title")
+        .option("--content <content>", "New memory content")
+        .option("--content-file <path>", "Read new memory content from a file")
+        .option("--type <type>", "New memory type")
+        .option("--tags <tags>", "Comma-separated tags")
+        .action(async (rawId, options) => {
+        try {
+            const { client } = getRuntime();
+            const id = requireMemoryId(rawId);
+            const updates = {};
+            if (options.title !== undefined) {
+                updates.title = normalizeTextInput("Title", options.title);
+            }
+            if (options.content !== undefined ||
+                options.contentFile !== undefined) {
+                updates.content = await resolveContentInput({
+                    content: options.content,
+                    contentFile: options.contentFile,
+                });
+            }
+            if (options.type !== undefined) {
+                updates.type = parseMemoryType(options.type);
+            }
+            if (options.tags !== undefined) {
+                updates.tags = parseTags(options.tags);
+            }
+            requireUpdateFields(updates);
+            const memory = await client.updateMemory(id, updates);
+            printMemorySummary(memory, "Updated memory");
+        }
+        catch (error) {
+            if (isNotFoundError(error)) {
+                exitWithError(`Memory not found: ${rawId}`);
+            }
+            exitWithError(error);
+        }
+    });
+    cmd
+        .command("delete <id>")
+        .alias("rm")
+        .description("Delete a memory by ID")
+        .option("--force", "Confirm deletion")
+        .action((rawId, options) => {
+        const { client } = getRuntime();
+        return runDelete(client, rawId, options);
+    });
+    const forgetCommand = cmd
+        .command("forget <id>")
+        .description("Deprecated alias for delete")
+        .option("--force", "Confirm deletion")
+        .action((rawId, options) => {
+        const { client } = getRuntime();
+        return runDelete(client, rawId, options, true);
+    });
+    forgetCommand.hideHelp?.();
+}

package/dist/cli.d.ts

@@ -0,0 +1,7 @@
+import type { OpenClawPluginApi } from "./plugin-sdk-stub.js";
+import type { LanonasisClient } from "./client.js";
+import type { LanonasisConfig } from "./config.js";
+export declare function registerCli(api: OpenClawPluginApi, getRuntime: () => {
+    client: LanonasisClient;
+    cfg: LanonasisConfig;
+}): void;

package/dist/cli.js

@@ -0,0 +1,135 @@
+import { assertMemoryStatsShape, exitWithError, isNotFoundError, memoryTypeOf, parseMemoryType, parsePositiveInt, parseSortField, parseSortOrder, parseTags, parseThreshold, printMemoryStats, similarityOf, normalizeTextInput, } from "./cli-common.js";
+import { registerMemoryCli } from "./cli-memory.js";
+import { registerExtractCli } from "./extraction/cli-extract.js";
+function padCell(value, width) {
+    return (value ?? "").slice(0, width - 2).padEnd(width);
+}
+export function registerCli(api, getRuntime) {
+    api.registerCli(({ program }) => {
+        const cmd = program
+            .command("recall")
+            .alias("lrf")
+            .description("RecallForge memory commands (alias: lrf)");
+        // status
+        cmd
+            .command("status")
+            .description("Check LanOnasis connection status")
+            .action(async () => {
+            try {
+                const { client, cfg } = getRuntime();
+                const h = await client.getHealth();
+                console.log(`Status: ${h.status} | v${h.version} | project: ${cfg.projectId}`);
+            }
+            catch (err) {
+                console.error(`Error: ${err instanceof Error ? err.message : "unknown"}`);
+                process.exit(1);
+            }
+        });
+        // search
+        cmd
+            .command("search <query>")
+            .description("Semantic search memories")
+            .option("--agent <id>", "Filter by agent_id")
+            .option("--limit <n>", "Max results", "5")
+            .option("--threshold <n>", "Minimum semantic similarity (0-1)")
+            .option("--type <type>", "Filter by memory type")
+            .option("--tags <tags>", "Comma-separated tags")
+            .action(async (query, options) => {
+            try {
+                const { client } = getRuntime();
+                const normalizedQuery = normalizeTextInput("Query", query);
+                if (!normalizedQuery) {
+                    throw new Error("Query cannot be empty or whitespace-only.");
+                }
+                const metadata = {};
+                if (options.agent)
+                    metadata.agent_id = options.agent;
+                const memories = await client.searchMemories({
+                    query: normalizedQuery,
+                    threshold: parseThreshold(options.threshold),
+                    limit: parsePositiveInt("--limit", options.limit, 5),
+                    type: parseMemoryType(options.type),
+                    tags: parseTags(options.tags),
+                    metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
+                });
+                if (!memories || memories.length === 0) {
+                    console.log("No memories found.");
+                    return;
+                }
+                // Table format: id(8), title(40), type, score
+                console.log(`│ ${"ID".padEnd(10)} │ ${"Title".padEnd(42)} │ ${"Type".padEnd(12)} │ Score │`);
+                console.log(`├────────────┼──────────────────────────────────────────┼──────────────┼───────┤`);
+                memories.forEach((m) => {
+                    const id = padCell(m.id?.slice(0, 8), 10);
+                    const title = padCell(m.title, 42);
+                    const type = padCell(memoryTypeOf(m), 12);
+                    const similarity = similarityOf(m);
+                    const score = similarity !== undefined ? similarity.toFixed(2) : "N/A";
+                    console.log(`│ ${id} │ ${title} │ ${type} │ ${score.padStart(5)} │`);
+                });
+            }
+            catch (err) {
+                exitWithError(err);
+            }
+        });
+        // list
+        cmd
+            .command("list")
+            .description("List memories")
+            .option("--type <type>", "Filter by type")
+            .option("--limit <n>", "Max results", "20")
+            .option("--page <n>", "Page number", "1")
+            .option("--sort <field>", "Sort by created_at, updated_at, title, or type")
+            .option("--order <order>", "Sort order: asc or desc")
+            .option("--tags <tags>", "Comma-separated tags")
+            .action(async (options) => {
+            try {
+                const { client } = getRuntime();
+                const result = await client.listMemories({
+                    limit: parsePositiveInt("--limit", options.limit, 20),
+                    page: parsePositiveInt("--page", options.page, 1),
+                    type: parseMemoryType(options.type),
+                    tags: parseTags(options.tags),
+                    sort: parseSortField(options.sort),
+                    order: parseSortOrder(options.order),
+                });
+                if (!result.memories || result.memories.length === 0) {
+                    console.log("No memories found.");
+                    return;
+                }
+                console.log(`│ ${"ID".padEnd(10)} │ ${"Title".padEnd(42)} │ ${"Type".padEnd(12)} │`);
+                console.log(`├────────────┼──────────────────────────────────────────┼──────────────┤`);
+                result.memories.forEach((m) => {
+                    const id = padCell(m.id?.slice(0, 8), 10);
+                    const title = padCell(m.title, 42);
+                    const type = padCell(memoryTypeOf(m), 12);
+                    console.log(`│ ${id} │ ${title} │ ${type} │`);
+                });
+                console.log(`\nTotal: ${result.total}`);
+            }
+            catch (err) {
+                exitWithError(err);
+            }
+        });
+        // stats
+        cmd
+            .command("stats")
+            .description("Show memory statistics")
+            .action(async () => {
+            try {
+                const { client } = getRuntime();
+                const stats = assertMemoryStatsShape(await client.getStats());
+                printMemoryStats(stats);
+            }
+            catch (err) {
+                if (isNotFoundError(err)) {
+                    exitWithError("Stats endpoint unavailable. Verify the LanOnasis deployment exposes /api/v1/memory/stats.");
+                }
+                exitWithError(err);
+            }
+        });
+        registerMemoryCli(cmd, getRuntime);
+        // extract — JSONL extraction with secret redaction
+        registerExtractCli(cmd, getRuntime);
+    }, { commands: ["recall", "lrf"] });
+}