@mrc2204/agent-smart-memo 5.0.2 → 5.1.2

package/dist/tools/project-tools.js

@@ -106,6 +106,41 @@ export function registerProjectTools(api, options) {
             }
         },
     });
+    api.registerTool({
+        name: "project_binding_preview",
+        label: "Project Binding Preview",
+        description: "Read-only OpenCode-style project binding preview. Resolves active project by project_id/project_alias/repo_root/session alias, blocks ambiguous multi-project binding unless cross-project is explicit.",
+        parameters: {
+            type: "object",
+            properties: {
+                project_id: { type: "string" },
+                project_alias: { type: "string" },
+                repo_root: { type: "string" },
+                session_project_alias: { type: "string" },
+                allow_cross_project: { type: "boolean" },
+            },
+        },
+        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.binding_preview", {
+                    context: { userId, agentId },
+                    payload: params,
+                    meta: {
+                        source: "openclaw",
+                        toolName: "project_binding_preview",
+                        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",
@@ -332,6 +367,7 @@ export function registerProjectTools(api, options) {
                             checksum: { type: "string" },
                             module: { type: "string" },
                             language: { type: "string" },
+                            content: { type: "string" },
                         },
                         required: ["relative_path"],
                     },
@@ -360,6 +396,197 @@ export function registerProjectTools(api, options) {
             }
         },
     });
+    api.registerTool({
+        name: "project_deindex",
+        label: "Project Deindex",
+        description: "Mark a project as deindexed (non-destructive): keep registry identity but tombstone indexed artifacts so retrieval/search no longer returns them.",
+        parameters: {
+            type: "object",
+            properties: {
+                project_id: { type: "string" },
+                reason: { 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.deindex", {
+                    context: { userId, agentId },
+                    payload: params,
+                    meta: {
+                        source: "openclaw",
+                        toolName: "project_deindex",
+                        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_detach",
+        label: "Project Detach",
+        description: "Detach a project from active bindings (aliases/repo/tracker) after deindex safety step. Non-purge and reversible via re-register.",
+        parameters: {
+            type: "object",
+            properties: {
+                project_ref: {
+                    type: "object",
+                    properties: {
+                        project_id: { type: "string" },
+                        project_alias: { type: "string" },
+                    },
+                },
+                reason: { type: "string" },
+            },
+            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.detach", {
+                    context: { userId, agentId },
+                    payload: params,
+                    meta: {
+                        source: "openclaw",
+                        toolName: "project_detach",
+                        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_unregister",
+        label: "Project Unregister",
+        description: "Safe unregister lifecycle step: requires explicit confirm=true, deindexes first, then disables project and detaches active bindings without destructive purge.",
+        parameters: {
+            type: "object",
+            properties: {
+                project_ref: {
+                    type: "object",
+                    properties: {
+                        project_id: { type: "string" },
+                        project_alias: { type: "string" },
+                    },
+                },
+                confirm: { type: "boolean" },
+                mode: { type: "string", enum: ["safe"] },
+                reason: { type: "string" },
+            },
+            required: ["project_ref", "confirm"],
+        },
+        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.unregister", {
+                    context: { userId, agentId },
+                    payload: params,
+                    meta: {
+                        source: "openclaw",
+                        toolName: "project_unregister",
+                        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_purge_preview",
+        label: "Project Purge Preview",
+        description: "Preview destructive purge impact with guardrails. Purge is only allowed when lifecycle_status=disabled and still requires explicit confirm in the purge call.",
+        parameters: {
+            type: "object",
+            properties: {
+                project_ref: {
+                    type: "object",
+                    properties: {
+                        project_id: { type: "string" },
+                        project_alias: { type: "string" },
+                    },
+                },
+            },
+            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.purge_preview", {
+                    context: { userId, agentId },
+                    payload: params,
+                    meta: {
+                        source: "openclaw",
+                        toolName: "project_purge_preview",
+                        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_purge",
+        label: "Project Purge",
+        description: "Destructive lifecycle endpoint. Requires project to be disabled first and explicit confirm=true. Use project_purge_preview before execution.",
+        parameters: {
+            type: "object",
+            properties: {
+                project_ref: {
+                    type: "object",
+                    properties: {
+                        project_id: { type: "string" },
+                        project_alias: { type: "string" },
+                    },
+                },
+                confirm: { type: "boolean" },
+                reason: { type: "string" },
+            },
+            required: ["project_ref", "confirm"],
+        },
+        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.purge", {
+                    context: { userId, agentId },
+                    payload: params,
+                    meta: {
+                        source: "openclaw",
+                        toolName: "project_purge",
+                        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",
@@ -420,6 +647,7 @@ export function registerProjectTools(api, options) {
                             checksum: { type: "string" },
                             module: { type: "string" },
                             language: { type: "string" },
+                            content: { type: "string" },
                         },
                         required: ["relative_path"],
                     },
@@ -448,6 +676,77 @@ export function registerProjectTools(api, options) {
             }
         },
     });
+    api.registerTool({
+        name: "project_index_event",
+        label: "Project Index Event",
+        description: "Event-driven partial project reindex using explicit changed/deleted file lists from git hooks or local automation.",
+        parameters: {
+            type: "object",
+            properties: {
+                project_id: { type: "string" },
+                repo_root: { type: "string" },
+                source_rev: { type: "string" },
+                event_type: { type: "string", enum: ["post_commit", "post_merge", "post_rewrite", "manual"] },
+                changed_files: { type: "array", items: { type: "string" } },
+                deleted_files: { type: "array", items: { type: "string" } },
+                trusted_sync: { type: "boolean" },
+                full_snapshot: { 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.index_event", {
+                    context: { userId, agentId },
+                    payload: params,
+                    meta: {
+                        source: "openclaw",
+                        toolName: "project_index_event",
+                        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_install_hooks",
+        label: "Project Install Hooks",
+        description: "Install local git hooks for an already-registered project so commit/merge events auto-trigger ASM indexing.",
+        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.install_hooks", {
+                    context: { userId, agentId },
+                    payload: params,
+                    meta: {
+                        source: "openclaw",
+                        toolName: "project_install_hooks",
+                        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",
@@ -596,6 +895,249 @@ export function registerProjectTools(api, options) {
             }
         },
     });
+    api.registerTool({
+        name: "project_change_overlay_query",
+        label: "Project Change Overlay Query",
+        description: "Query ASM-94 change-aware overlay with explicit selector (task/tracker) and optional feature filter.",
+        parameters: {
+            type: "object",
+            properties: {
+                project_id: { type: "string" },
+                task_id: { type: "string" },
+                tracker_issue_key: { type: "string" },
+                task_title: { type: "string" },
+                feature_key: {
+                    type: "string",
+                    enum: [
+                        "project_onboarding_registration_indexing",
+                        "code_aware_retrieval",
+                        "heartbeat_health_runtime_integrity",
+                        "change_aware_impact",
+                        "post_entry_review_decision_support",
+                    ],
+                },
+                feature_name: { 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.change_overlay.query", {
+                    context: { userId, agentId },
+                    payload: params,
+                    meta: {
+                        source: "openclaw",
+                        toolName: "project_change_overlay_query",
+                        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_feature_pack_generate",
+        label: "Project Feature Pack Generate",
+        description: "Generate a minimal feature/capability pack for a registered project flow. ASM-93 Slice 2 supports multiple priority feature packs.",
+        parameters: {
+            type: "object",
+            properties: {
+                project_id: { type: "string" },
+                project_alias: { type: "string" },
+                feature_key: {
+                    type: "string",
+                    enum: [
+                        "project_onboarding_registration_indexing",
+                        "code_aware_retrieval",
+                        "heartbeat_health_runtime_integrity",
+                        "change_aware_impact",
+                        "post_entry_review_decision_support",
+                    ],
+                },
+            },
+        },
+        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.feature_pack.generate", {
+                    context: { userId, agentId },
+                    payload: params,
+                    meta: {
+                        source: "openclaw",
+                        toolName: "project_feature_pack_generate",
+                        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_feature_pack_query",
+        label: "Project Feature Pack Query",
+        description: "Query feature pack by feature_key or feature name (human-friendly) for a registered project.",
+        parameters: {
+            type: "object",
+            properties: {
+                project_id: { type: "string" },
+                project_alias: { type: "string" },
+                feature_key: {
+                    type: "string",
+                    enum: [
+                        "project_onboarding_registration_indexing",
+                        "code_aware_retrieval",
+                        "heartbeat_health_runtime_integrity",
+                        "change_aware_impact",
+                        "post_entry_review_decision_support",
+                    ],
+                },
+                feature_name: { 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.feature_pack.query", {
+                    context: { userId, agentId },
+                    payload: params,
+                    meta: {
+                        source: "openclaw",
+                        toolName: "project_feature_pack_query",
+                        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_opencode_search",
+        label: "Project OpenCode Search",
+        description: "Read-only OpenCode retrieval surface. Resolves project binding first, then runs project-scoped developer query. Cross-project behavior requires explicit opt-in.",
+        parameters: {
+            type: "object",
+            properties: {
+                query: { type: "string" },
+                limit: { type: "number" },
+                project_id: { type: "string" },
+                project_alias: { type: "string" },
+                repo_root: { type: "string" },
+                session_project_alias: { type: "string" },
+                explicit_project_id: { type: "string" },
+                explicit_project_alias: { type: "string" },
+                explicit_cross_project: { type: "boolean" },
+            },
+            required: ["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.opencode_search", {
+                    context: { userId, agentId },
+                    payload: params,
+                    meta: {
+                        source: "openclaw",
+                        toolName: "project_opencode_search",
+                        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_developer_query",
+        label: "Project Developer Query",
+        description: "ASM-112 typed developer query parser surface with deterministic intent/selector normalization over existing hybrid_search/feature_pack/change_overlay capabilities.",
+        parameters: {
+            type: "object",
+            properties: {
+                project_id: { type: "string" },
+                project_alias: { type: "string" },
+                query: { type: "string" },
+                intent: {
+                    type: "string",
+                    enum: [
+                        "locate_symbol",
+                        "locate_file",
+                        "feature_lookup",
+                        "change_lookup",
+                        "locate",
+                        "trace_flow",
+                        "impact",
+                        "impact_analysis",
+                        "change_aware_lookup",
+                        "feature_understanding",
+                    ],
+                },
+                limit: { type: "number" },
+                symbol_name: { type: "string" },
+                relative_path: { type: "string" },
+                route_path: { type: "string" },
+                tracker_issue_key: { type: "string" },
+                task_id: { type: "string" },
+                task_title: { type: "string" },
+                tracker_issue_keys: { type: "array", items: { type: "string" } },
+                task_ids: { type: "array", items: { type: "string" } },
+                route_paths: { type: "array", items: { type: "string" } },
+                feature_key: {
+                    type: "string",
+                    enum: [
+                        "project_onboarding_registration_indexing",
+                        "code_aware_retrieval",
+                        "heartbeat_health_runtime_integrity",
+                        "change_aware_impact",
+                        "post_entry_review_decision_support",
+                    ],
+                },
+                feature_name: { type: "string" },
+            },
+            required: [],
+        },
+        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.developer_query", {
+                    context: { userId, agentId },
+                    payload: params,
+                    meta: {
+                        source: "openclaw",
+                        toolName: "project_developer_query",
+                        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",
@@ -606,6 +1148,7 @@ export function registerProjectTools(api, options) {
                 project_id: { type: "string" },
                 query: { type: "string" },
                 limit: { type: "number" },
+                debug: { type: "boolean", description: "Return candidate-generation and ranking debug info for conformance/debugging." },
                 path_prefix: { type: "array", items: { type: "string" } },
                 module: { type: "array", items: { type: "string" } },
                 language: { type: "array", items: { type: "string" } },