@stackmemoryai/stackmemory 1.10.4 → 1.12.0

package/dist/src/integrations/github/pr-state.js

@@ -0,0 +1,158 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { execFileSync } from "child_process";
+import {
+  canonicalStateStore
+} from "../../core/shared-state/canonical-store.js";
+import { projectIdFromIdentifier } from "../../core/shared-state/canonical-store.js";
+function runGit(args, cwd) {
+  return execFileSync("git", args, {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"]
+  }).trim();
+}
+function runGh(args, cwd) {
+  return execFileSync("gh", args, {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"]
+  }).trim();
+}
+function normalizeRemoteToRepo(remote) {
+  const cleaned = remote.replace(/\.git$/, "").trim();
+  if (cleaned.startsWith("git@github.com:")) {
+    return cleaned.replace("git@github.com:", "");
+  }
+  if (cleaned.startsWith("https://github.com/")) {
+    return cleaned.replace("https://github.com/", "");
+  }
+  if (cleaned.startsWith("http://github.com/")) {
+    return cleaned.replace("http://github.com/", "");
+  }
+  throw new Error(`Unsupported GitHub remote: ${remote}`);
+}
+function summarizeStatusCheckRollup(rollup) {
+  if (!rollup || rollup.length === 0) {
+    return void 0;
+  }
+  const states = rollup.map((item) => item.conclusion || item.status || item.state).filter(Boolean);
+  if (states.length === 0) {
+    return void 0;
+  }
+  if (states.every((state) => state === "SUCCESS")) {
+    return "SUCCESS";
+  }
+  if (states.some((state) => state === "FAILURE" || state === "ERROR")) {
+    return "FAILURE";
+  }
+  if (states.some(
+    (state) => state === "PENDING" || state === "IN_PROGRESS" || state === "EXPECTED"
+  )) {
+    return "PENDING";
+  }
+  return states[0];
+}
+function getCurrentRepoGitHubInfo(cwd = process.cwd()) {
+  try {
+    const projectPath = runGit(["rev-parse", "--show-toplevel"], cwd);
+    const branch = runGit(["rev-parse", "--abbrev-ref", "HEAD"], projectPath);
+    const remote = runGit(
+      ["config", "--get", "remote.origin.url"],
+      projectPath
+    );
+    const repo = normalizeRemoteToRepo(remote);
+    return {
+      repo,
+      branch,
+      projectPath,
+      projectId: projectIdFromIdentifier(remote)
+    };
+  } catch {
+    return null;
+  }
+}
+async function refreshCurrentRepoPullRequestState(cwd = process.cwd()) {
+  const info = getCurrentRepoGitHubInfo(cwd);
+  if (!info) {
+    return null;
+  }
+  try {
+    const output = runGh(
+      [
+        "pr",
+        "view",
+        "--repo",
+        info.repo,
+        "--json",
+        [
+          "number",
+          "title",
+          "state",
+          "isDraft",
+          "url",
+          "baseRefName",
+          "headRefName",
+          "headRefOid",
+          "mergedAt",
+          "updatedAt",
+          "reviewDecision",
+          "statusCheckRollup"
+        ].join(",")
+      ],
+      info.projectPath
+    );
+    const parsed = JSON.parse(output);
+    const projection = {
+      repo: info.repo,
+      branch: info.branch,
+      projectId: info.projectId,
+      projectPath: info.projectPath,
+      prNumber: parsed.number,
+      title: parsed.title,
+      state: parsed.mergedAt && parsed.state === "MERGED" ? "MERGED" : parsed.state,
+      isDraft: parsed.isDraft,
+      url: parsed.url,
+      baseRefName: parsed.baseRefName,
+      headRefName: parsed.headRefName,
+      headRefOid: parsed.headRefOid,
+      mergedAt: parsed.mergedAt || void 0,
+      updatedAt: parsed.updatedAt,
+      reviewDecision: parsed.reviewDecision || void 0,
+      statusCheckRollup: summarizeStatusCheckRollup(parsed.statusCheckRollup),
+      lastSyncedAt: Date.now()
+    };
+    await canonicalStateStore.saveGitHubPullRequest(projection);
+    if (projection.state === "MERGED" || projection.state === "CLOSED") {
+      await canonicalStateStore.releaseClaims({
+        projectId: info.projectId,
+        projectPath: info.projectPath,
+        branch: info.branch,
+        reason: `github_pr_${projection.state.toLowerCase()}`
+      });
+    }
+    await canonicalStateStore.appendEvent({
+      type: "github_pr_refreshed",
+      tool: "stackmemory",
+      projectId: info.projectId,
+      projectPath: info.projectPath,
+      branch: info.branch,
+      payload: {
+        repo: info.repo,
+        prNumber: projection.prNumber,
+        state: projection.state,
+        reviewDecision: projection.reviewDecision,
+        statusCheckRollup: projection.statusCheckRollup
+      }
+    });
+    return projection;
+  } catch {
+    return null;
+  }
+}
+export {
+  getCurrentRepoGitHubInfo,
+  refreshCurrentRepoPullRequestState
+};

package/dist/src/integrations/linear/client.js

@@ -496,7 +496,10 @@ class LinearClient {
       filter: Object.keys(filter).length > 0 ? filter : void 0,
       first: options?.limit || 50
     });
-    return result.issues.nodes;
+    return result.issues.nodes.map((issue) => ({
+      ...issue,
+      labels: Array.isArray(issue.labels) ? issue.labels : issue.labels?.nodes || []
+    }));
   }
   /**
    * Assign an issue to a user

package/dist/src/integrations/mcp/handlers/cross-search-handlers.js

@@ -0,0 +1,188 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import {
+  CrossProjectSearch
+} from "../../../core/cross-search/cross-project-search.js";
+import { logger } from "../../../core/monitoring/logger.js";
+class CrossSearchHandlers {
+  crossSearch;
+  constructor(deps) {
+    this.crossSearch = deps.crossSearch || new CrossProjectSearch();
+  }
+  /**
+   * sm_cross_search: Search across all registered project databases.
+   */
+  async handleCrossSearch(args) {
+    try {
+      const { query, limit = 20, exclude_current = false } = args;
+      if (!query) {
+        throw new Error("query is required");
+      }
+      const projects = this.crossSearch.listProjects();
+      if (projects.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No projects registered. Use sm_cross_discover to scan for project databases, or sm_cross_register to add one manually."
+            }
+          ]
+        };
+      }
+      const excludeProject = exclude_current ? this.getCurrentProjectName() : void 0;
+      const start = Date.now();
+      const results = await this.crossSearch.search({
+        query,
+        limit,
+        excludeProject
+      });
+      const elapsed = Date.now() - start;
+      if (results.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `No results found for "${query}" across ${projects.length} project databases (${elapsed}ms).`
+            }
+          ]
+        };
+      }
+      const text = this.formatResults(results, query, projects.length, elapsed);
+      return {
+        content: [{ type: "text", text }],
+        metadata: {
+          results: results.map((r) => ({
+            project: r.projectName,
+            frameId: r.frameId,
+            name: r.name,
+            score: r.score
+          })),
+          total: results.length,
+          projectsSearched: projects.length,
+          elapsedMs: elapsed
+        }
+      };
+    } catch (error) {
+      logger.error(
+        "Cross-project search failed",
+        error instanceof Error ? error : new Error(String(error))
+      );
+      throw error;
+    }
+  }
+  /**
+   * sm_cross_discover: Auto-discover project databases.
+   */
+  async handleCrossDiscover(args) {
+    try {
+      const paths = args.paths;
+      const discovered = this.crossSearch.discoverProjects(paths);
+      const all = this.crossSearch.listProjects();
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Discovered ${discovered.length} project database(s).
+Total registered: ${all.length}
+
+` + all.map((p) => `  ${p.name}: ${p.path}
+    db: ${p.dbPath}`).join("\n")
+          }
+        ],
+        metadata: { discovered: discovered.length, total: all.length }
+      };
+    } catch (error) {
+      logger.error(
+        "Cross-project discover failed",
+        error instanceof Error ? error : new Error(String(error))
+      );
+      throw error;
+    }
+  }
+  /**
+   * sm_cross_register: Register a project database manually.
+   */
+  async handleCrossRegister(args) {
+    try {
+      const { name, path, db_path } = args;
+      if (!name || !path || !db_path) {
+        throw new Error("name, path, and db_path are required");
+      }
+      this.crossSearch.registerProject({
+        name,
+        path,
+        dbPath: db_path,
+        lastAccessed: Date.now()
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Registered project "${name}" at ${path} (db: ${db_path})`
+          }
+        ]
+      };
+    } catch (error) {
+      logger.error(
+        "Cross-project register failed",
+        error instanceof Error ? error : new Error(String(error))
+      );
+      throw error;
+    }
+  }
+  /**
+   * sm_cross_list: List all registered project databases.
+   */
+  async handleCrossList() {
+    try {
+      const projects = this.crossSearch.listProjects();
+      if (projects.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No projects registered. Use sm_cross_discover to scan for project databases."
+            }
+          ]
+        };
+      }
+      const text = `Registered projects (${projects.length}):
+
+` + projects.map(
+        (p) => `  ${p.name}
+    path: ${p.path}
+    db: ${p.dbPath}
+    last: ${new Date(p.lastAccessed).toLocaleDateString()}`
+      ).join("\n");
+      return {
+        content: [{ type: "text", text }],
+        metadata: { projects }
+      };
+    } catch (error) {
+      logger.error(
+        "Cross-project list failed",
+        error instanceof Error ? error : new Error(String(error))
+      );
+      throw error;
+    }
+  }
+  formatResults(results, query, projectCount, elapsed) {
+    const header = `Cross-project search: ${results.length} results for "${query}" across ${projectCount} databases (${elapsed}ms):
+
+`;
+    const body = results.map(
+      (r) => `[${r.projectName}] ${r.name} (${r.type}, score: ${r.score.toFixed(3)})` + (r.digestText ? `
+  ${r.digestText.slice(0, 120)}` : "")
+    ).join("\n");
+    return header + body;
+  }
+  getCurrentProjectName() {
+    const cwd = process.cwd();
+    return cwd.split("/").pop();
+  }
+}
+export {
+  CrossSearchHandlers
+};

package/dist/src/integrations/mcp/handlers/index.js

@@ -18,11 +18,12 @@ import {
 import {
   ProviderHandlers
 } from "./provider-handlers.js";
-import { TeamHandlers } from "./team-handlers.js";
-import { CordHandlers } from "./cord-handlers.js";
 import {
   ProvenantHandlers
 } from "./provenant-handlers.js";
+import {
+  CrossSearchHandlers
+} from "./cross-search-handlers.js";
 import {
   ContextHandlers as ContextHandlers2
 } from "./context-handlers.js";
@@ -32,18 +33,19 @@ import {
 } from "./linear-handlers.js";
 import { TraceHandlers as TraceHandlers2 } from "./trace-handlers.js";
 import { ProviderHandlers as ProviderHandlers2 } from "./provider-handlers.js";
-import { TeamHandlers as TeamHandlers2 } from "./team-handlers.js";
-import { CordHandlers as CordHandlers2 } from "./cord-handlers.js";
 import { ProvenantHandlers as ProvenantHandlers2 } from "./provenant-handlers.js";
+import { CrossSearchHandlers as CrossSearchHandlers2 } from "./cross-search-handlers.js";
+import {
+  resolveToolAlias
+} from "../tool-alias-registry.js";
 class MCPHandlerFactory {
   contextHandlers;
   taskHandlers;
   linearHandlers;
   traceHandlers;
   providerHandlers;
-  teamHandlers;
-  cordHandlers;
   provenantHandlers;
+  crossSearchHandlers;
   constructor(deps) {
     this.contextHandlers = new ContextHandlers2({
       frameManager: deps.frameManager
@@ -62,27 +64,20 @@ class MCPHandlerFactory {
       browserMCP: deps.browserMCP
     });
     this.providerHandlers = new ProviderHandlers2();
-    if (deps.dbAdapter) {
-      this.teamHandlers = new TeamHandlers2({
-        frameManager: deps.frameManager,
-        dbAdapter: deps.dbAdapter
-      });
-      this.cordHandlers = new CordHandlers2({
-        frameManager: deps.frameManager,
-        dbAdapter: deps.dbAdapter
-      });
-    }
     if (deps.projectDir) {
       this.provenantHandlers = new ProvenantHandlers2({
         projectDir: deps.projectDir
       });
     }
+    this.crossSearchHandlers = new CrossSearchHandlers2({});
   }
   /**
-   * Get handler for a specific tool
+   * Get handler for a specific tool.
+   * Resolves tool name aliases before lookup.
    */
   getHandler(toolName) {
-    switch (toolName) {
+    const { canonicalName } = resolveToolAlias(toolName);
+    switch (canonicalName) {
       // Context handlers
       case "get_context":
         return this.contextHandlers.handleGetContext.bind(this.contextHandlers);
@@ -150,32 +145,6 @@ class MCPHandlerFactory {
         return this.providerHandlers.handleBatchCheck.bind(
           this.providerHandlers
         );
-      // Team handlers
-      case "team_context_get":
-        if (!this.teamHandlers) throw new Error("Team tools require dbAdapter");
-        return this.teamHandlers.handleTeamContextGet.bind(this.teamHandlers);
-      case "team_context_share":
-        if (!this.teamHandlers) throw new Error("Team tools require dbAdapter");
-        return this.teamHandlers.handleTeamContextShare.bind(this.teamHandlers);
-      case "team_search":
-        if (!this.teamHandlers) throw new Error("Team tools require dbAdapter");
-        return this.teamHandlers.handleTeamSearch.bind(this.teamHandlers);
-      // Cord orchestration handlers
-      case "cord_spawn":
-        if (!this.cordHandlers) throw new Error("Cord tools require dbAdapter");
-        return this.cordHandlers.handleCordSpawn.bind(this.cordHandlers);
-      case "cord_fork":
-        if (!this.cordHandlers) throw new Error("Cord tools require dbAdapter");
-        return this.cordHandlers.handleCordFork.bind(this.cordHandlers);
-      case "cord_complete":
-        if (!this.cordHandlers) throw new Error("Cord tools require dbAdapter");
-        return this.cordHandlers.handleCordComplete.bind(this.cordHandlers);
-      case "cord_ask":
-        if (!this.cordHandlers) throw new Error("Cord tools require dbAdapter");
-        return this.cordHandlers.handleCordAsk.bind(this.cordHandlers);
-      case "cord_tree":
-        if (!this.cordHandlers) throw new Error("Cord tools require dbAdapter");
-        return this.cordHandlers.handleCordTree.bind(this.cordHandlers);
       // Provenant decision graph handlers
       case "provenant_search":
         if (!this.provenantHandlers)
@@ -201,6 +170,23 @@ class MCPHandlerFactory {
         return this.provenantHandlers.handleResolve.bind(
           this.provenantHandlers
         );
+      // Cross-project search handlers
+      case "sm_cross_search":
+        return this.crossSearchHandlers.handleCrossSearch.bind(
+          this.crossSearchHandlers
+        );
+      case "sm_cross_discover":
+        return this.crossSearchHandlers.handleCrossDiscover.bind(
+          this.crossSearchHandlers
+        );
+      case "sm_cross_register":
+        return this.crossSearchHandlers.handleCrossRegister.bind(
+          this.crossSearchHandlers
+        );
+      case "sm_cross_list":
+        return this.crossSearchHandlers.handleCrossList.bind(
+          this.crossSearchHandlers
+        );
       default:
         throw new Error(`Unknown tool: ${toolName}`);
     }
@@ -237,40 +223,35 @@ class MCPHandlerFactory {
       "delegate_to_model",
       "batch_submit",
       "batch_check",
-      // Team tools
-      "team_context_get",
-      "team_context_share",
-      "team_search",
-      // Cord orchestration tools
-      "cord_spawn",
-      "cord_fork",
-      "cord_complete",
-      "cord_ask",
-      "cord_tree",
       // Provenant decision graph tools
       "provenant_search",
       "provenant_log",
       "provenant_status",
       "provenant_contradictions",
-      "provenant_resolve"
+      "provenant_resolve",
+      // Cross-project search tools
+      "sm_cross_search",
+      "sm_cross_discover",
+      "sm_cross_register",
+      "sm_cross_list"
     ];
   }
   /**
-   * Check if a tool exists
+   * Check if a tool exists (resolves aliases)
    */
   hasHandler(toolName) {
-    return this.getAvailableTools().includes(toolName);
+    const { canonicalName } = resolveToolAlias(toolName);
+    return this.getAvailableTools().includes(canonicalName);
   }
 }
 export {
   ContextHandlers,
-  CordHandlers,
+  CrossSearchHandlers,
   DiscoveryHandlers,
   LinearHandlers,
   MCPHandlerFactory,
   ProvenantHandlers,
   ProviderHandlers,
   TaskHandlers,
-  TeamHandlers,
   TraceHandlers
 };