@stackmemoryai/stackmemory 1.10.5 → 1.12.0

package/dist/src/daemon/services/github-service.js

@@ -0,0 +1,126 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { refreshCurrentRepoPullRequestState } from "../../integrations/github/pr-state.js";
+import { canonicalStateStore } from "../../core/shared-state/canonical-store.js";
+class DaemonGitHubService {
+  config;
+  state;
+  intervalId;
+  isRunning = false;
+  onLog;
+  constructor(config, onLog) {
+    this.config = config;
+    this.onLog = onLog;
+    this.state = {
+      lastSyncTime: 0,
+      syncCount: 0,
+      errors: []
+    };
+  }
+  async start() {
+    if (this.isRunning || !this.config.enabled) {
+      return;
+    }
+    if (!this.isGitHubConfigured()) {
+      this.onLog("WARN", "GitHub CLI not configured, skipping github service");
+      return;
+    }
+    this.isRunning = true;
+    const intervalMs = this.config.interval * 60 * 1e3;
+    this.onLog("INFO", "GitHub service started", {
+      interval: this.config.interval
+    });
+    await this.performSync();
+    this.intervalId = setInterval(async () => {
+      await this.performSync();
+    }, intervalMs);
+  }
+  stop() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = void 0;
+    }
+    this.isRunning = false;
+    this.onLog("INFO", "GitHub service stopped");
+  }
+  getState() {
+    return {
+      ...this.state,
+      nextSyncTime: this.isRunning ? this.state.lastSyncTime + this.config.interval * 60 * 1e3 : void 0
+    };
+  }
+  async forceSync() {
+    await this.performSync();
+  }
+  async performSync() {
+    if (!this.isRunning) return;
+    try {
+      const projectRoots = await this.getProjectRoots();
+      this.state.lastProjectsScanned = projectRoots.length;
+      if (projectRoots.length === 0) {
+        this.onLog("DEBUG", "No active project roots found for GitHub sync");
+        return;
+      }
+      let synced = false;
+      for (const projectRoot of projectRoots) {
+        const projection = await refreshCurrentRepoPullRequestState(projectRoot);
+        if (!projection) {
+          this.onLog("DEBUG", "No GitHub PR projection available", {
+            projectRoot
+          });
+          continue;
+        }
+        synced = true;
+        this.state.syncCount++;
+        this.state.lastSyncTime = Date.now();
+        this.state.lastProjectionState = projection.state;
+        this.onLog("INFO", "GitHub PR projection refreshed", {
+          projectRoot,
+          repo: projection.repo,
+          branch: projection.branch,
+          prNumber: projection.prNumber,
+          state: projection.state
+        });
+      }
+      if (!synced) {
+        this.state.lastSyncTime = Date.now();
+      }
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : String(err);
+      this.state.errors.push(errorMsg);
+      this.onLog("ERROR", "GitHub sync failed", { error: errorMsg });
+      if (this.state.errors.length > 10) {
+        this.state.errors = this.state.errors.slice(-10);
+      }
+    }
+  }
+  isGitHubConfigured() {
+    try {
+      return existsSync(join(homedir(), ".config", "gh", "hosts.yml"));
+    } catch {
+      return false;
+    }
+  }
+  async getProjectRoots() {
+    const roots = /* @__PURE__ */ new Set();
+    const activeProjectPaths = await canonicalStateStore.listActiveProjectPaths();
+    for (const projectPath of activeProjectPaths) {
+      if (existsSync(join(projectPath, ".git"))) {
+        roots.add(projectPath);
+      }
+    }
+    const cwd = process.cwd();
+    if (existsSync(join(cwd, ".git"))) {
+      roots.add(cwd);
+    }
+    return Array.from(roots).sort();
+  }
+}
+export {
+  DaemonGitHubService
+};

package/dist/src/daemon/unified-daemon.js

@@ -18,6 +18,7 @@ import {
 } from "./daemon-config.js";
 import { DaemonContextService } from "./services/context-service.js";
 import { DaemonLinearService } from "./services/linear-service.js";
+import { DaemonGitHubService } from "./services/github-service.js";
 import { DaemonMaintenanceService } from "./services/maintenance-service.js";
 import { DaemonMemoryService } from "./services/memory-service.js";
 class UnifiedDaemon {
@@ -25,6 +26,7 @@ class UnifiedDaemon {
   paths;
   contextService;
   linearService;
+  githubService;
   maintenanceService;
   memoryService;
   heartbeatInterval;
@@ -41,6 +43,10 @@ class UnifiedDaemon {
       this.config.linear,
       (level, msg, data) => this.log(level, "linear", msg, data)
     );
+    this.githubService = new DaemonGitHubService(
+      this.config.github,
+      (level, msg, data) => this.log(level, "github", msg, data)
+    );
     this.maintenanceService = new DaemonMaintenanceService(
       this.config.maintenance,
       (level, msg, data) => this.log(level, "maintenance", msg, data)
@@ -101,6 +107,7 @@ class UnifiedDaemon {
   updateStatus() {
     const maintenanceState = this.maintenanceService.getState();
     const memoryState = this.memoryService.getState();
+    const githubState = this.githubService.getState();
     const status = {
       running: true,
       pid: process.pid,
@@ -117,6 +124,12 @@ class UnifiedDaemon {
           lastRun: this.linearService.getState().lastSyncTime || void 0,
           syncCount: this.linearService.getState().syncCount
         },
+        github: {
+          enabled: this.config.github.enabled,
+          lastRun: githubState.lastSyncTime || void 0,
+          syncCount: githubState.syncCount,
+          lastProjectionState: githubState.lastProjectionState
+        },
         maintenance: {
           enabled: this.config.maintenance.enabled,
           lastRun: maintenanceState.lastRunTime || void 0,
@@ -139,6 +152,7 @@ class UnifiedDaemon {
       errors: [
         ...this.contextService.getState().errors.slice(-5),
         ...this.linearService.getState().errors.slice(-5),
+        ...githubState.errors.slice(-5),
         ...maintenanceState.errors.slice(-5),
         ...memoryState.errors.slice(-5)
       ]
@@ -190,6 +204,11 @@ class UnifiedDaemon {
           enabled: false,
           syncCount: this.linearService.getState().syncCount
         },
+        github: {
+          enabled: false,
+          syncCount: this.githubService.getState().syncCount,
+          lastProjectionState: this.githubService.getState().lastProjectionState
+        },
         maintenance: {
           enabled: false,
           staleFramesCleaned: this.maintenanceService.getState().staleFramesCleaned,
@@ -213,6 +232,7 @@ class UnifiedDaemon {
       uptime: Date.now() - this.startTime,
       contextSaves: this.contextService.getState().saveCount,
       linearSyncs: this.linearService.getState().syncCount,
+      githubSyncs: this.githubService.getState().syncCount,
       maintenanceRuns: this.maintenanceService.getState().ftsRebuilds,
       memoryTriggers: this.memoryService.getState().triggerCount
     });
@@ -222,6 +242,7 @@ class UnifiedDaemon {
     }
     this.contextService.stop();
     this.linearService.stop();
+    this.githubService.stop();
     this.maintenanceService.stop();
     this.memoryService.stop();
     this.cleanup();
@@ -241,6 +262,7 @@ class UnifiedDaemon {
       config: {
         context: this.config.context.enabled,
         linear: this.config.linear.enabled,
+        github: this.config.github.enabled,
         maintenance: this.config.maintenance.enabled,
         memory: this.config.memory.enabled,
         fileWatch: this.config.fileWatch.enabled
@@ -248,6 +270,7 @@ class UnifiedDaemon {
     });
     this.contextService.start();
     await this.linearService.start();
+    await this.githubService.start();
     this.maintenanceService.start();
     this.memoryService.start();
     this.heartbeatInterval = setInterval(() => {
@@ -258,6 +281,7 @@ class UnifiedDaemon {
   getStatus() {
     const maintenanceState = this.maintenanceService.getState();
     const memoryState = this.memoryService.getState();
+    const githubState = this.githubService.getState();
     return {
       running: !this.isShuttingDown,
       pid: process.pid,
@@ -274,6 +298,12 @@ class UnifiedDaemon {
           lastRun: this.linearService.getState().lastSyncTime || void 0,
           syncCount: this.linearService.getState().syncCount
         },
+        github: {
+          enabled: this.config.github.enabled,
+          lastRun: githubState.lastSyncTime || void 0,
+          syncCount: githubState.syncCount,
+          lastProjectionState: githubState.lastProjectionState
+        },
         maintenance: {
           enabled: this.config.maintenance.enabled,
           lastRun: maintenanceState.lastRunTime || void 0,

package/dist/src/features/sweep/pty-wrapper.js

@@ -30,7 +30,9 @@ class PtyWrapper {
       claudeBin: config.claudeBin || this.findClaude(),
       claudeArgs: config.claudeArgs || [],
       stateFile: config.stateFile || getSweepPath("sweep-state.json"),
-      initialInput: config.initialInput || ""
+      initialInput: config.initialInput || "",
+      onExit: config.onExit || (() => void 0),
+      onSignal: config.onSignal || (() => void 0)
     };
     this.stateWatcher = new SweepStateWatcher(this.config.stateFile);
     this.statusBar = new StatusBar();
@@ -115,8 +117,9 @@ class PtyWrapper {
       this.ptyProcess?.resize(newCols, newRows - 1);
       this.statusBar.resize(newRows, newCols);
     });
-    this.ptyProcess.onExit(({ exitCode }) => {
+    this.ptyProcess.onExit(async ({ exitCode }) => {
       this.cleanup();
+      await this.config.onExit(exitCode);
       if (process.env["LINEAR_API_KEY"]) {
         try {
           execSync("stackmemory linear sync", {
@@ -128,12 +131,17 @@ class PtyWrapper {
       }
       process.exit(exitCode);
     });
-    const onSignal = () => {
+    const onSignal = async (signal) => {
       this.cleanup();
+      await this.config.onSignal(signal);
       process.exit(0);
     };
-    process.on("SIGINT", onSignal);
-    process.on("SIGTERM", onSignal);
+    process.on("SIGINT", () => {
+      void onSignal("SIGINT");
+    });
+    process.on("SIGTERM", () => {
+      void onSignal("SIGTERM");
+    });
   }
   acceptPrediction() {
     if (!this.currentPrediction || !this.ptyProcess) return;

package/dist/src/hooks/schemas.js

@@ -19,6 +19,7 @@ const ModelProviderSchema = z.enum([
   "cerebras",
   "deepinfra",
   "openrouter",
+  "moonshot",
   "anthropic-batch",
   "custom"
 ]);
@@ -59,6 +60,7 @@ const ModelRouterConfigSchema = z.object({
     cerebras: ModelConfigSchema.optional(),
     deepinfra: ModelConfigSchema.optional(),
     openrouter: ModelConfigSchema.optional(),
+    moonshot: ModelConfigSchema.optional(),
     "anthropic-batch": ModelConfigSchema.optional(),
     custom: ModelConfigSchema.optional()
   }).optional().default({}),

package/dist/src/integrations/claude-code/subagent-client.js

@@ -17,6 +17,17 @@ import {
   createProvider
 } from "../../core/extensions/provider-adapter.js";
 import { AnthropicBatchClient } from "../anthropic/batch-client.js";
+const QUOTA_ERROR_PATTERNS = [
+  /rate.?limit/i,
+  /quota.?exceeded/i,
+  /too many requests/i,
+  /429/,
+  /capacity/i,
+  /billing/i,
+  /usage.?limit/i,
+  /plan.?limit/i,
+  /max.*requests/i
+];
 class ClaudeCodeSubagentClient {
   tempDir;
   mockMode;
@@ -108,6 +119,12 @@ class ClaudeCodeSubagentClient {
         tokens: result.usage.inputTokens + result.usage.outputTokens
       };
     } catch (error) {
+      if (optimal.provider === "anthropic" && this.isQuotaError(error.message)) {
+        logger.warn("Anthropic API quota hit, overflowing to Kimi", {
+          error: error.message
+        });
+        return this.executeKimiOverflow(request, startTime, subagentId);
+      }
       logger.warn(`Direct API failed for ${optimal.provider}, falling back`, {
         error: error.message
       });
@@ -176,6 +193,13 @@ Context (JSON): ${JSON.stringify(request.context)}`;
         tokens: this.estimateTokens(fullPrompt + result.text)
       };
     } catch (error) {
+      if (this.isQuotaError(error.message)) {
+        logger.warn("Claude quota/rate limit hit, overflowing to Kimi", {
+          subagentId,
+          error: error.message
+        });
+        return this.executeKimiOverflow(request, startTime, subagentId);
+      }
       logger.error(`Subagent CLI execution failed: ${request.type}`, {
         error,
         subagentId
@@ -210,6 +234,71 @@ Context (JSON): ${JSON.stringify(request.context)}`;
       }
     });
   }
+  /**
+   * Check if an error message indicates quota/rate limit exhaustion
+   */
+  isQuotaError(message) {
+    return QUOTA_ERROR_PATTERNS.some((pattern) => pattern.test(message));
+  }
+  /**
+   * Execute via Kimi/Moonshot API as overflow when Claude quota is exhausted.
+   * Uses OpenAI-compatible API at api.moonshot.ai/v1.
+   */
+  async executeKimiOverflow(request, startTime, subagentId) {
+    const apiKey = process.env["MOONSHOT_API_KEY"] || "";
+    if (!apiKey) {
+      logger.warn("No MOONSHOT_API_KEY set, cannot overflow to Kimi");
+      return {
+        success: false,
+        result: null,
+        error: "Claude quota exceeded and no MOONSHOT_API_KEY configured",
+        duration: Date.now() - startTime,
+        subagentType: request.type
+      };
+    }
+    try {
+      const adapter = createProvider("moonshot", {
+        apiKey,
+        baseUrl: "https://api.moonshot.ai/v1"
+      });
+      const prompt = this.buildSubagentPrompt(request);
+      const result = await adapter.complete(
+        [{ role: "user", content: prompt }],
+        { model: "kimi-k2.6", maxTokens: 8192 }
+      );
+      const text = result.content.filter((c) => c.type === "text").map((c) => c.text).join("");
+      let parsed;
+      try {
+        parsed = JSON.parse(text);
+      } catch {
+        parsed = { rawOutput: text };
+      }
+      logger.info("Kimi overflow completed", {
+        subagentId,
+        tokens: result.usage.inputTokens + result.usage.outputTokens
+      });
+      return {
+        success: true,
+        result: parsed,
+        output: text,
+        duration: Date.now() - startTime,
+        subagentType: request.type,
+        tokens: result.usage.inputTokens + result.usage.outputTokens
+      };
+    } catch (kimiError) {
+      logger.error("Kimi overflow also failed", {
+        subagentId,
+        error: kimiError.message
+      });
+      return {
+        success: false,
+        result: null,
+        error: `Claude quota exceeded, Kimi fallback failed: ${kimiError.message}`,
+        duration: Date.now() - startTime,
+        subagentType: request.type
+      };
+    }
+  }
   /**
    * Build subagent prompt based on type
    */

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