@mrc2204/agent-smart-memo 5.0.0 → 5.0.1

package/dist/tools/project-tools.js

@@ -0,0 +1,649 @@
+import { configureOpenClawRuntime, createOpenClawResult, getMemoryUseCasePortForContext, getSessionKey, parseOpenClawSessionIdentity, } from "../adapters/openclaw/tool-runtime.js";
+function createResult(text, isError = false) {
+    return createOpenClawResult(text, isError);
+}
+export function registerProjectTools(api, options) {
+    configureOpenClawRuntime(options);
+    api.registerTool({
+        name: "project_registry_register",
+        label: "Project Registry Register",
+        description: "Register project identity lifecycle in ASM v5.1. Creates/updates project_id-centric registry, alias mapping, and registration state.",
+        parameters: {
+            type: "object",
+            properties: {
+                project_id: { type: "string", description: "Optional canonical project id. If omitted, system auto-generates." },
+                project_name: { type: "string", description: "Optional display name for project." },
+                project_alias: { type: "string", description: "Required human alias (unique within scope)." },
+                repo_root: { type: "string", description: "Optional repo root path." },
+                repo_remote: { type: "string", description: "Optional primary git remote URL." },
+                active_version: { type: "string", description: "Optional active architecture/runtime version." },
+                allow_alias_update: { type: "boolean", description: "Allow re-binding existing alias to another project_id." },
+            },
+            required: ["project_alias"],
+        },
+        async execute(_id, params, ctx) {
+            try {
+                const sessionKey = getSessionKey(ctx);
+                const { userId, agentId } = parseOpenClawSessionIdentity(sessionKey);
+                const useCasePort = getMemoryUseCasePortForContext(ctx);
+                const data = await useCasePort.run("project.register", {
+                    context: { userId, agentId },
+                    payload: params,
+                    meta: {
+                        source: "openclaw",
+                        toolName: "project_registry_register",
+                        requestId: _id,
+                    },
+                });
+                return createResult(JSON.stringify(data, null, 2));
+            }
+            catch (error) {
+                return createResult(`Error: ${error instanceof Error ? error.message : String(error)}`, true);
+            }
+        },
+    });
+    api.registerTool({
+        name: "project_registry_get",
+        label: "Project Registry Get",
+        description: "Get project registry record by project_id or project_alias.",
+        parameters: {
+            type: "object",
+            properties: {
+                project_id: { type: "string" },
+                project_alias: { type: "string" },
+            },
+        },
+        async execute(_id, params, ctx) {
+            try {
+                const sessionKey = getSessionKey(ctx);
+                const { userId, agentId } = parseOpenClawSessionIdentity(sessionKey);
+                const useCasePort = getMemoryUseCasePortForContext(ctx);
+                const data = await useCasePort.run("project.get", {
+                    context: { userId, agentId },
+                    payload: params,
+                    meta: {
+                        source: "openclaw",
+                        toolName: "project_registry_get",
+                        requestId: _id,
+                    },
+                });
+                if (!data) {
+                    return createResult("No project registry record found.");
+                }
+                return createResult(JSON.stringify(data, null, 2));
+            }
+            catch (error) {
+                return createResult(`Error: ${error instanceof Error ? error.message : String(error)}`, true);
+            }
+        },
+    });
+    api.registerTool({
+        name: "project_registry_list",
+        label: "Project Registry List",
+        description: "List all registered projects and registration states in current scope.",
+        parameters: {
+            type: "object",
+            properties: {},
+        },
+        async execute(_id, _params, ctx) {
+            try {
+                const sessionKey = getSessionKey(ctx);
+                const { userId, agentId } = parseOpenClawSessionIdentity(sessionKey);
+                const useCasePort = getMemoryUseCasePortForContext(ctx);
+                const data = await useCasePort.run("project.list", {
+                    context: { userId, agentId },
+                    payload: {},
+                    meta: {
+                        source: "openclaw",
+                        toolName: "project_registry_list",
+                        requestId: _id,
+                    },
+                });
+                return createResult(JSON.stringify(data, null, 2));
+            }
+            catch (error) {
+                return createResult(`Error: ${error instanceof Error ? error.message : String(error)}`, true);
+            }
+        },
+    });
+    api.registerTool({
+        name: "project_registration_state_set",
+        label: "Project Registration State Set",
+        description: "Update registration/validation state for a project registry identity.",
+        parameters: {
+            type: "object",
+            properties: {
+                project_id: { type: "string" },
+                registration_status: { type: "string", enum: ["draft", "registered", "validated", "blocked"] },
+                validation_status: { type: "string", enum: ["pending", "ok", "warn", "error"] },
+                validation_notes: { type: "string" },
+                completeness_score: { type: "number" },
+                missing_required_fields: { type: "array", items: { type: "string" } },
+                last_validated_at: { type: "string" },
+            },
+            required: [
+                "project_id",
+                "registration_status",
+                "validation_status",
+                "completeness_score",
+                "missing_required_fields",
+            ],
+        },
+        async execute(_id, params, ctx) {
+            try {
+                const sessionKey = getSessionKey(ctx);
+                const { userId, agentId } = parseOpenClawSessionIdentity(sessionKey);
+                const useCasePort = getMemoryUseCasePortForContext(ctx);
+                const data = await useCasePort.run("project.set_registration_state", {
+                    context: { userId, agentId },
+                    payload: params,
+                    meta: {
+                        source: "openclaw",
+                        toolName: "project_registration_state_set",
+                        requestId: _id,
+                    },
+                });
+                return createResult(JSON.stringify(data, null, 2));
+            }
+            catch (error) {
+                return createResult(`Error: ${error instanceof Error ? error.message : String(error)}`, true);
+            }
+        },
+    });
+    api.registerTool({
+        name: "project_tracker_mapping_set",
+        label: "Project Tracker Mapping Set",
+        description: "Attach/update external tracker mapping (Jira/GitHub/other) for a registered project.",
+        parameters: {
+            type: "object",
+            properties: {
+                project_id: { type: "string" },
+                tracker_type: { type: "string", enum: ["jira", "github", "other"] },
+                tracker_space_key: { type: "string" },
+                tracker_project_id: { type: "string" },
+                default_epic_key: { type: "string" },
+                board_key: { type: "string" },
+                active_version: { type: "string" },
+                external_project_url: { type: "string" },
+            },
+            required: ["project_id", "tracker_type"],
+        },
+        async execute(_id, params, ctx) {
+            try {
+                const sessionKey = getSessionKey(ctx);
+                const { userId, agentId } = parseOpenClawSessionIdentity(sessionKey);
+                const useCasePort = getMemoryUseCasePortForContext(ctx);
+                const data = await useCasePort.run("project.set_tracker_mapping", {
+                    context: { userId, agentId },
+                    payload: params,
+                    meta: {
+                        source: "openclaw",
+                        toolName: "project_tracker_mapping_set",
+                        requestId: _id,
+                    },
+                });
+                return createResult(JSON.stringify(data, null, 2));
+            }
+            catch (error) {
+                return createResult(`Error: ${error instanceof Error ? error.message : String(error)}`, true);
+            }
+        },
+    });
+    api.registerTool({
+        name: "project_register_command",
+        label: "Project Register Command",
+        description: "Canonical ASM v5.1 add/register project command flow. Supports optional Jira mapping attach and optional initial index trigger.",
+        parameters: {
+            type: "object",
+            properties: {
+                project_alias: { type: "string" },
+                project_name: { type: "string" },
+                project_id: { type: "string" },
+                repo_root: { type: "string" },
+                repo_remote: { type: "string" },
+                active_version: { type: "string" },
+                tracker: {
+                    type: "object",
+                    properties: {
+                        tracker_type: { type: "string", enum: ["jira", "github", "other"] },
+                        tracker_space_key: { type: "string" },
+                        tracker_project_id: { type: "string" },
+                        default_epic_key: { type: "string" },
+                        board_key: { type: "string" },
+                        active_version: { type: "string" },
+                        external_project_url: { type: "string" },
+                    },
+                },
+                options: {
+                    type: "object",
+                    properties: {
+                        trigger_index: { type: "boolean" },
+                        allow_alias_update: { type: "boolean" },
+                    },
+                },
+            },
+            required: ["project_alias"],
+        },
+        async execute(_id, params, ctx) {
+            try {
+                const sessionKey = getSessionKey(ctx);
+                const { userId, agentId } = parseOpenClawSessionIdentity(sessionKey);
+                const useCasePort = getMemoryUseCasePortForContext(ctx);
+                const data = await useCasePort.run("project.register_command", {
+                    context: { userId, agentId },
+                    payload: params,
+                    meta: {
+                        source: "openclaw",
+                        toolName: "project_register_command",
+                        requestId: _id,
+                    },
+                });
+                return createResult(JSON.stringify(data, null, 2));
+            }
+            catch (error) {
+                return createResult(`Error: ${error instanceof Error ? error.message : String(error)}`, true);
+            }
+        },
+    });
+    api.registerTool({
+        name: "project_link_tracker",
+        label: "Project Link Tracker",
+        description: "Canonical ASM v5.1 link jira/tracker command flow by project_id or project_alias.",
+        parameters: {
+            type: "object",
+            properties: {
+                project_ref: {
+                    type: "object",
+                    properties: {
+                        project_id: { type: "string" },
+                        project_alias: { type: "string" },
+                    },
+                },
+                tracker: {
+                    type: "object",
+                    properties: {
+                        tracker_type: { type: "string", enum: ["jira", "github", "other"] },
+                        tracker_space_key: { type: "string" },
+                        tracker_project_id: { type: "string" },
+                        default_epic_key: { type: "string" },
+                        board_key: { type: "string" },
+                        active_version: { type: "string" },
+                        external_project_url: { type: "string" },
+                    },
+                    required: ["tracker_type"],
+                },
+                mode: { type: "string", enum: ["attach_or_update"] },
+            },
+            required: ["project_ref", "tracker"],
+        },
+        async execute(_id, params, ctx) {
+            try {
+                const sessionKey = getSessionKey(ctx);
+                const { userId, agentId } = parseOpenClawSessionIdentity(sessionKey);
+                const useCasePort = getMemoryUseCasePortForContext(ctx);
+                const data = await useCasePort.run("project.link_tracker", {
+                    context: { userId, agentId },
+                    payload: params,
+                    meta: {
+                        source: "openclaw",
+                        toolName: "project_link_tracker",
+                        requestId: _id,
+                    },
+                });
+                return createResult(JSON.stringify(data, null, 2));
+            }
+            catch (error) {
+                return createResult(`Error: ${error instanceof Error ? error.message : String(error)}`, true);
+            }
+        },
+    });
+    api.registerTool({
+        name: "project_trigger_index",
+        label: "Project Trigger Index",
+        description: "Canonical ASM v5.1 index project/index now command flow after registration/linking.",
+        parameters: {
+            type: "object",
+            properties: {
+                project_ref: {
+                    type: "object",
+                    properties: {
+                        project_id: { type: "string" },
+                        project_alias: { type: "string" },
+                    },
+                },
+                mode: { type: "string", enum: ["bootstrap", "incremental", "manual", "repair"] },
+                scope: {
+                    type: "object",
+                    properties: {
+                        path_prefix: { type: "array", items: { type: "string" } },
+                        module: { type: "array", items: { type: "string" } },
+                        task_id: { type: "array", items: { type: "string" } },
+                    },
+                },
+                reason: { type: "string" },
+                source_rev: { type: "string" },
+                index_profile: { type: "string" },
+                paths: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            relative_path: { type: "string" },
+                            checksum: { type: "string" },
+                            module: { type: "string" },
+                            language: { type: "string" },
+                        },
+                        required: ["relative_path"],
+                    },
+                },
+            },
+            required: ["project_ref"],
+        },
+        async execute(_id, params, ctx) {
+            try {
+                const sessionKey = getSessionKey(ctx);
+                const { userId, agentId } = parseOpenClawSessionIdentity(sessionKey);
+                const useCasePort = getMemoryUseCasePortForContext(ctx);
+                const data = await useCasePort.run("project.trigger_index", {
+                    context: { userId, agentId },
+                    payload: params,
+                    meta: {
+                        source: "openclaw",
+                        toolName: "project_trigger_index",
+                        requestId: _id,
+                    },
+                });
+                return createResult(JSON.stringify(data, null, 2));
+            }
+            catch (error) {
+                return createResult(`Error: ${error instanceof Error ? error.message : String(error)}`, true);
+            }
+        },
+    });
+    api.registerTool({
+        name: "project_telegram_onboarding",
+        label: "Project Telegram Onboarding",
+        description: "Operator-facing Telegram onboarding helper for project registration + Jira mapping + optional index-now. Preview/confirm flow that bridges to ASM-80 command layer.",
+        parameters: {
+            type: "object",
+            properties: {
+                command: { type: "string", description: "Slash command trigger, e.g. /project" },
+                repo_url: { type: "string", description: "Repo URL/import source from Telegram step." },
+                project_alias: { type: "string", description: "Operator-confirmed project alias." },
+                jira_space_key: { type: "string", description: "Jira space key (uppercase format)." },
+                default_epic_key: { type: "string", description: "Default epic key, must match <SPACE>-* when provided." },
+                index_now: { type: "boolean", description: "Whether to trigger index immediately after confirm." },
+                project_name: { type: "string", description: "Optional project display name." },
+                repo_root: { type: "string", description: "Optional resolved repo root." },
+                active_version: { type: "string", description: "Optional active version." },
+                mode: { type: "string", enum: ["preview", "confirm"], description: "preview validates and returns confirm card; confirm executes." },
+            },
+        },
+        async execute(_id, params, ctx) {
+            try {
+                const sessionKey = getSessionKey(ctx);
+                const { userId, agentId } = parseOpenClawSessionIdentity(sessionKey);
+                const useCasePort = getMemoryUseCasePortForContext(ctx);
+                const data = await useCasePort.run("project.telegram_onboarding", {
+                    context: { userId, agentId },
+                    payload: params,
+                    meta: {
+                        source: "openclaw",
+                        toolName: "project_telegram_onboarding",
+                        requestId: _id,
+                    },
+                });
+                return createResult(JSON.stringify(data, null, 2));
+            }
+            catch (error) {
+                return createResult(`Error: ${error instanceof Error ? error.message : String(error)}`, true);
+            }
+        },
+    });
+    api.registerTool({
+        name: "project_reindex_diff",
+        label: "Project Reindex Diff",
+        description: "Run incremental reindex by diff/checksum and update watch state. Tracks changed/unchanged/deleted paths and updates index run lifecycle.",
+        parameters: {
+            type: "object",
+            properties: {
+                project_id: { type: "string" },
+                source_rev: { type: "string" },
+                trigger_type: { type: "string", enum: ["bootstrap", "incremental", "manual", "repair"] },
+                index_profile: { type: "string" },
+                paths: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            relative_path: { type: "string" },
+                            checksum: { type: "string" },
+                            module: { type: "string" },
+                            language: { type: "string" },
+                        },
+                        required: ["relative_path"],
+                    },
+                },
+            },
+            required: ["project_id", "paths"],
+        },
+        async execute(_id, params, ctx) {
+            try {
+                const sessionKey = getSessionKey(ctx);
+                const { userId, agentId } = parseOpenClawSessionIdentity(sessionKey);
+                const useCasePort = getMemoryUseCasePortForContext(ctx);
+                const data = await useCasePort.run("project.reindex_diff", {
+                    context: { userId, agentId },
+                    payload: params,
+                    meta: {
+                        source: "openclaw",
+                        toolName: "project_reindex_diff",
+                        requestId: _id,
+                    },
+                });
+                return createResult(JSON.stringify(data, null, 2));
+            }
+            catch (error) {
+                return createResult(`Error: ${error instanceof Error ? error.message : String(error)}`, true);
+            }
+        },
+    });
+    api.registerTool({
+        name: "project_index_watch_get",
+        label: "Project Index Watch Get",
+        description: "Get current project index watch-state snapshot (last source rev + checksum map).",
+        parameters: {
+            type: "object",
+            properties: {
+                project_id: { type: "string" },
+            },
+            required: ["project_id"],
+        },
+        async execute(_id, params, ctx) {
+            try {
+                const sessionKey = getSessionKey(ctx);
+                const { userId, agentId } = parseOpenClawSessionIdentity(sessionKey);
+                const useCasePort = getMemoryUseCasePortForContext(ctx);
+                const data = await useCasePort.run("project.index_watch_get", {
+                    context: { userId, agentId },
+                    payload: params,
+                    meta: {
+                        source: "openclaw",
+                        toolName: "project_index_watch_get",
+                        requestId: _id,
+                    },
+                });
+                return createResult(JSON.stringify(data, null, 2));
+            }
+            catch (error) {
+                return createResult(`Error: ${error instanceof Error ? error.message : String(error)}`, true);
+            }
+        },
+    });
+    api.registerTool({
+        name: "project_legacy_backfill",
+        label: "Project Legacy Backfill",
+        description: "Run legacy compatibility migration/backfill for indexed-but-unregistered projects: alias/tracker inference, registration state normalization, migration_state upsert.",
+        parameters: {
+            type: "object",
+            properties: {
+                mode: { type: "string", enum: ["dry_run", "apply"] },
+                only_project_ids: { type: "array", items: { type: "string" } },
+                only_aliases: { type: "array", items: { type: "string" } },
+                force_registration_state: { type: "boolean" },
+                source: { type: "string", enum: ["repo_root", "repo_remote", "task_registry", "mixed"] },
+            },
+        },
+        async execute(_id, params, ctx) {
+            try {
+                const sessionKey = getSessionKey(ctx);
+                const { userId, agentId } = parseOpenClawSessionIdentity(sessionKey);
+                const useCasePort = getMemoryUseCasePortForContext(ctx);
+                const data = await useCasePort.run("project.legacy_backfill", {
+                    context: { userId, agentId },
+                    payload: params,
+                    meta: {
+                        source: "openclaw",
+                        toolName: "project_legacy_backfill",
+                        requestId: _id,
+                    },
+                });
+                return createResult(JSON.stringify(data, null, 2));
+            }
+            catch (error) {
+                return createResult(`Error: ${error instanceof Error ? error.message : String(error)}`, true);
+            }
+        },
+    });
+    api.registerTool({
+        name: "project_task_registry_upsert",
+        label: "Project Task Registry Upsert",
+        description: "Upsert task-lineage metadata for a project task (parent/related links, touched files/symbols, decisions, tracker key).",
+        parameters: {
+            type: "object",
+            properties: {
+                task_id: { type: "string" },
+                project_id: { type: "string" },
+                task_title: { type: "string" },
+                task_type: { type: "string" },
+                task_status: { type: "string" },
+                parent_task_id: { type: "string" },
+                related_task_ids: { type: "array", items: { type: "string" } },
+                files_touched: { type: "array", items: { type: "string" } },
+                symbols_touched: { type: "array", items: { type: "string" } },
+                commit_refs: { type: "array", items: { type: "string" } },
+                diff_refs: { type: "array", items: { type: "string" } },
+                decision_notes: { type: "string" },
+                tracker_issue_key: { type: "string" },
+            },
+            required: ["task_id", "project_id", "task_title"],
+        },
+        async execute(_id, params, ctx) {
+            try {
+                const sessionKey = getSessionKey(ctx);
+                const { userId, agentId } = parseOpenClawSessionIdentity(sessionKey);
+                const useCasePort = getMemoryUseCasePortForContext(ctx);
+                const data = await useCasePort.run("project.task_registry_upsert", {
+                    context: { userId, agentId },
+                    payload: params,
+                    meta: {
+                        source: "openclaw",
+                        toolName: "project_task_registry_upsert",
+                        requestId: _id,
+                    },
+                });
+                return createResult(JSON.stringify(data, null, 2));
+            }
+            catch (error) {
+                return createResult(`Error: ${error instanceof Error ? error.message : String(error)}`, true);
+            }
+        },
+    });
+    api.registerTool({
+        name: "project_task_lineage_context",
+        label: "Project Task Lineage Context",
+        description: "Assemble compact task-lineage context (focus task, parent chain, related tasks, touched files/symbols, commit refs, decisions).",
+        parameters: {
+            type: "object",
+            properties: {
+                project_id: { type: "string" },
+                task_id: { type: "string" },
+                tracker_issue_key: { type: "string" },
+                task_title: { type: "string" },
+                include_related: { type: "boolean" },
+                include_parent_chain: { type: "boolean" },
+            },
+            required: ["project_id"],
+        },
+        async execute(_id, params, ctx) {
+            try {
+                const sessionKey = getSessionKey(ctx);
+                const { userId, agentId } = parseOpenClawSessionIdentity(sessionKey);
+                const useCasePort = getMemoryUseCasePortForContext(ctx);
+                const data = await useCasePort.run("project.task_lineage_context", {
+                    context: { userId, agentId },
+                    payload: params,
+                    meta: {
+                        source: "openclaw",
+                        toolName: "project_task_lineage_context",
+                        requestId: _id,
+                    },
+                });
+                return createResult(JSON.stringify(data, null, 2));
+            }
+            catch (error) {
+                return createResult(`Error: ${error instanceof Error ? error.message : String(error)}`, true);
+            }
+        },
+    });
+    api.registerTool({
+        name: "project_hybrid_search",
+        label: "Project Hybrid Search",
+        description: "Hybrid retrieval over file/symbol/task registries with optional task-lineage context assembly and project/task filters.",
+        parameters: {
+            type: "object",
+            properties: {
+                project_id: { type: "string" },
+                query: { type: "string" },
+                limit: { type: "number" },
+                path_prefix: { type: "array", items: { type: "string" } },
+                module: { type: "array", items: { type: "string" } },
+                language: { type: "array", items: { type: "string" } },
+                task_id: { type: "array", items: { type: "string" } },
+                tracker_issue_key: { type: "array", items: { type: "string" } },
+                task_context: {
+                    type: "object",
+                    properties: {
+                        task_id: { type: "string" },
+                        tracker_issue_key: { type: "string" },
+                        task_title: { type: "string" },
+                        include_related: { type: "boolean" },
+                        include_parent_chain: { type: "boolean" },
+                    },
+                },
+            },
+            required: ["project_id", "query"],
+        },
+        async execute(_id, params, ctx) {
+            try {
+                const sessionKey = getSessionKey(ctx);
+                const { userId, agentId } = parseOpenClawSessionIdentity(sessionKey);
+                const useCasePort = getMemoryUseCasePortForContext(ctx);
+                const data = await useCasePort.run("project.hybrid_search", {
+                    context: { userId, agentId },
+                    payload: params,
+                    meta: {
+                        source: "openclaw",
+                        toolName: "project_hybrid_search",
+                        requestId: _id,
+                    },
+                });
+                return createResult(JSON.stringify(data, null, 2));
+            }
+            catch (error) {
+                return createResult(`Error: ${error instanceof Error ? error.message : String(error)}`, true);
+            }
+        },
+    });
+}
+//# sourceMappingURL=project-tools.js.map