@stackmemoryai/stackmemory 1.10.5 → 1.14.0

package/dist/src/daemon/services/desire-path-service.js

@@ -0,0 +1,566 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  appendFileSync,
+  mkdirSync,
+  readdirSync,
+  statSync,
+  renameSync,
+  unlinkSync
+} from "fs";
+import { join, basename, dirname, extname } from "path";
+import { homedir } from "os";
+import { randomUUID } from "crypto";
+const SM_DIR = join(homedir(), ".stackmemory");
+const DP_DIR = join(SM_DIR, "desire-paths");
+const STREAM_FILE = join(DP_DIR, "action-stream.jsonl");
+const PATTERNS_FILE = join(DP_DIR, "patterns.json");
+const SUGGESTIONS_DIR = join(DP_DIR, "suggestions");
+const MAX_LOG_SIZE = 10 * 1024 * 1024;
+const TOOL_TARGET_SENSITIVE = /* @__PURE__ */ new Set(["Bash"]);
+function sanitizePath(filePath) {
+  if (!filePath) return "*";
+  const dir = dirname(filePath);
+  const ext = extname(filePath);
+  if (ext) {
+    return `${dir}/*${ext}`;
+  }
+  return `${dir}/*`;
+}
+function sanitizeCommand(cmd) {
+  if (!cmd) return "*";
+  const parts = cmd.trim().split(/\s+/);
+  const command = parts[0];
+  const firstArg = parts.slice(1).find((p) => !p.startsWith("-"));
+  if (firstArg) {
+    return `${command} ${firstArg.length > 30 ? firstArg.slice(0, 30) + "*" : firstArg}`;
+  }
+  return command;
+}
+function actionKey(entry) {
+  return `${entry.tool}:${entry.target}`;
+}
+function sequenceHash(seq) {
+  return seq.join("|");
+}
+class DaemonDesirePathService {
+  config;
+  state;
+  scanTimeout;
+  isRunning = false;
+  onLog;
+  lastActivityTime = 0;
+  // last time an action was logged
+  consecutiveIdleScans = 0;
+  // scans with no new actions
+  constructor(config, onLog) {
+    this.config = config;
+    this.onLog = onLog;
+    this.state = {
+      lastScanTime: 0,
+      actionsLogged: 0,
+      patternsDetected: 0,
+      suggestionsGenerated: 0,
+      skillsAutoPromoted: 0,
+      errors: []
+    };
+  }
+  isOptedOut() {
+    if (process.env.STACKMEMORY_DESIRE_PATHS === "0" || process.env.STACKMEMORY_DESIRE_PATHS === "false") {
+      return true;
+    }
+    return !this.config.enabled;
+  }
+  // ─── 1. Action Stream Logger ─────────────────────────────
+  /** Append a tool call to the action stream. Called from hook events. */
+  logAction(entry) {
+    if (this.isOptedOut()) return;
+    try {
+      mkdirSync(DP_DIR, { recursive: true });
+      if (existsSync(STREAM_FILE)) {
+        const stat = statSync(STREAM_FILE);
+        if (stat.size > (this.config.maxLogSizeBytes || MAX_LOG_SIZE)) {
+          const rotated = `${STREAM_FILE}.${Date.now()}.bak`;
+          renameSync(STREAM_FILE, rotated);
+          this.onLog("INFO", "Action stream rotated", { size: stat.size });
+        }
+      }
+      appendFileSync(STREAM_FILE, JSON.stringify(entry) + "\n", "utf-8");
+      this.state.actionsLogged++;
+      this.lastActivityTime = Date.now();
+    } catch (err) {
+      this.addError(String(err));
+    }
+  }
+  /** Parse a hook event into an ActionEntry. */
+  static parseHookEvent(toolName, firstArg, sessionId, durationMs) {
+    let target;
+    if (TOOL_TARGET_SENSITIVE.has(toolName)) {
+      target = sanitizeCommand(firstArg);
+    } else if (firstArg && (firstArg.includes("/") || firstArg.includes("\\"))) {
+      target = sanitizePath(firstArg);
+    } else {
+      target = firstArg ? firstArg.slice(0, 50) : "*";
+    }
+    return {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      sid: sessionId,
+      tool: toolName,
+      target,
+      dur: durationMs
+    };
+  }
+  // ─── 2. Pattern Detector ──────────────────────────────────
+  /** Scan the action stream for repeated sequences. */
+  detectPatterns() {
+    if (!existsSync(STREAM_FILE)) return [];
+    let entries;
+    try {
+      const lines = readFileSync(STREAM_FILE, "utf-8").trim().split("\n");
+      entries = lines.map((line) => {
+        try {
+          return JSON.parse(line);
+        } catch {
+          return null;
+        }
+      }).filter(Boolean);
+    } catch {
+      return [];
+    }
+    if (entries.length > 1e4) entries = entries.slice(-1e4);
+    if (entries.length < 3) return [];
+    const sessions = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      const sid = entry.sid || "unknown";
+      if (!sessions.has(sid)) sessions.set(sid, []);
+      sessions.get(sid).push(entry);
+    }
+    const maxLen = this.config.maxSequenceLength || 8;
+    const minLen = 2;
+    const sequenceCounts = /* @__PURE__ */ new Map();
+    for (const [sid, actions] of sessions) {
+      const keys = actions.map(actionKey);
+      for (let len = minLen; len <= Math.min(maxLen, keys.length); len++) {
+        for (let i = 0; i <= keys.length - len; i++) {
+          const subseq = keys.slice(i, i + len);
+          const hash = sequenceHash(subseq);
+          if (!sequenceCounts.has(hash)) {
+            sequenceCounts.set(hash, {
+              count: 0,
+              sessions: /* @__PURE__ */ new Set(),
+              firstSeen: actions[i].ts,
+              lastSeen: actions[i + len - 1].ts
+            });
+          }
+          const entry = sequenceCounts.get(hash);
+          entry.count++;
+          entry.sessions.add(sid);
+          if (actions[i + len - 1].ts > entry.lastSeen) {
+            entry.lastSeen = actions[i + len - 1].ts;
+          }
+        }
+      }
+    }
+    const minFreq = this.config.minFrequency || 3;
+    const minSess = this.config.minSessions || 2;
+    const patterns = [];
+    for (const [hash, data] of sequenceCounts) {
+      if (data.count >= minFreq && data.sessions.size >= minSess) {
+        const sequence = hash.split("|");
+        patterns.push({
+          id: randomUUID().slice(0, 8),
+          sequence,
+          frequency: data.count,
+          sessions: data.sessions.size,
+          avg_steps: sequence.length,
+          first_seen: data.firstSeen,
+          last_seen: data.lastSeen,
+          score: data.count * data.sessions.size
+        });
+      }
+    }
+    patterns.sort((a, b) => b.score - a.score);
+    const filtered = [];
+    const seenHashes = /* @__PURE__ */ new Set();
+    for (const pattern of patterns) {
+      const hash = sequenceHash(pattern.sequence);
+      let isSubseq = false;
+      for (const accepted of filtered) {
+        const acceptedHash = sequenceHash(accepted.sequence);
+        if (acceptedHash.includes(hash) && acceptedHash !== hash) {
+          isSubseq = true;
+          break;
+        }
+      }
+      if (!isSubseq && !seenHashes.has(hash)) {
+        filtered.push(pattern);
+        seenHashes.add(hash);
+      }
+    }
+    const topPatterns = filtered.slice(0, 20);
+    this.state.patternsDetected = topPatterns.length;
+    try {
+      writeFileSync(
+        PATTERNS_FILE,
+        JSON.stringify(
+          { patterns: topPatterns, updated_at: (/* @__PURE__ */ new Date()).toISOString() },
+          null,
+          2
+        )
+      );
+    } catch (err) {
+      this.addError(String(err));
+    }
+    return topPatterns;
+  }
+  /** Load previously detected patterns. */
+  loadPatterns() {
+    try {
+      if (!existsSync(PATTERNS_FILE)) return [];
+      const data = JSON.parse(readFileSync(PATTERNS_FILE, "utf-8"));
+      return data.patterns || [];
+    } catch {
+      return [];
+    }
+  }
+  // ─── 3. Skill Suggester ───────────────────────────────────
+  /** Generate skill suggestions from detected patterns. */
+  generateSuggestions(patterns) {
+    const pats = patterns || this.loadPatterns();
+    if (pats.length === 0) return [];
+    mkdirSync(SUGGESTIONS_DIR, { recursive: true });
+    const suggestions = [];
+    for (const pattern of pats.slice(0, 10)) {
+      const uniqueTools = new Set(
+        pattern.sequence.map((s) => s.split(":", 2)[0].toLowerCase())
+      );
+      if (uniqueTools.size < 2 || pattern.sequence.length < 3) {
+        this.cleanTrivialSuggestion(pattern);
+        continue;
+      }
+      const suggestion = this.patternToSuggestion(pattern);
+      if (!suggestion) continue;
+      suggestions.push(suggestion);
+      const fileName = `${suggestion.name}.skill.md`;
+      const content = this.renderSkillMarkdown(suggestion);
+      try {
+        writeFileSync(join(SUGGESTIONS_DIR, fileName), content, "utf-8");
+      } catch (err) {
+        this.addError(String(err));
+      }
+    }
+    this.state.suggestionsGenerated = suggestions.length;
+    this.autoPromote(suggestions);
+    return suggestions;
+  }
+  /** Remove suggestion files for trivial patterns that don't warrant skills. */
+  cleanTrivialSuggestion(pattern) {
+    const tools = pattern.sequence.map((s) => {
+      const [tool, target] = s.split(":", 2);
+      return { tool, target: target || "*" };
+    });
+    const toolNames = [...new Set(tools.map((t) => t.tool.toLowerCase()))];
+    const targets = tools.map((t) => t.target).filter((t) => t !== "*");
+    const dominantDir = targets.length > 0 ? targets[0].split("/").slice(0, 3).join("-").replace(/[^a-zA-Z0-9-]/g, "") : "";
+    const nameSuffix = dominantDir ? `-${dominantDir}` : "";
+    const name = `auto-${toolNames.join("-")}${nameSuffix}`;
+    const sugFile = join(SUGGESTIONS_DIR, `${name}.skill.md`);
+    try {
+      if (existsSync(sugFile)) {
+        unlinkSync(sugFile);
+        this.onLog("DEBUG", `Cleaned trivial suggestion: ${name}`, {
+          pattern_id: pattern.id,
+          uniqueTools: toolNames.length,
+          steps: pattern.sequence.length
+        });
+      }
+    } catch {
+    }
+  }
+  // ─── 4. Auto-Promotion ────────────────────────────────────
+  /**
+   * Auto-promote skills above confidence threshold.
+   * Copies from suggestions/ to the project's skills/ directory.
+   * Only promotes if: confidence ≥ threshold AND sessions ≥ minSessions.
+   */
+  autoPromote(suggestions) {
+    const threshold = this.config.autoPromoteThreshold ?? 0.8;
+    const minSessions = this.config.autoPromoteMinSessions ?? 5;
+    if (threshold >= 1) return;
+    const skillsDir = this.config.skillsDir || this.findSkillsDir();
+    if (!skillsDir) return;
+    const patterns = this.loadPatterns();
+    for (const suggestion of suggestions) {
+      if (suggestion.confidence < threshold) continue;
+      const pattern = patterns.find((p) => p.id === suggestion.pattern_id);
+      if (!pattern || pattern.sessions < minSessions) continue;
+      const destFile = join(skillsDir, `${suggestion.name}.skill.md`);
+      if (existsSync(destFile)) continue;
+      const srcFile = join(SUGGESTIONS_DIR, `${suggestion.name}.skill.md`);
+      if (!existsSync(srcFile)) continue;
+      try {
+        mkdirSync(skillsDir, { recursive: true });
+        let content = readFileSync(srcFile, "utf-8");
+        content = content.replace("status: suggested", "status: auto-promoted");
+        writeFileSync(destFile, content, "utf-8");
+        this.state.skillsAutoPromoted++;
+        this.onLog("INFO", `Skill auto-promoted: ${suggestion.name}`, {
+          confidence: suggestion.confidence,
+          sessions: pattern.sessions,
+          frequency: pattern.frequency,
+          dest: destFile
+        });
+      } catch (err) {
+        this.addError(
+          `Auto-promote failed for ${suggestion.name}: ${String(err)}`
+        );
+      }
+    }
+  }
+  /** Find the best skills directory for auto-promotion. */
+  findSkillsDir() {
+    const cwd = process.cwd();
+    const candidates = [
+      join(cwd, ".claude", "skills", "knowledge"),
+      join(cwd, "skills")
+    ];
+    for (const dir of candidates) {
+      if (existsSync(dir)) return dir;
+    }
+    const claudeDir = join(cwd, ".claude");
+    if (existsSync(claudeDir)) {
+      const target = join(claudeDir, "skills", "knowledge");
+      try {
+        mkdirSync(target, { recursive: true });
+        return target;
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+  patternToSuggestion(pattern) {
+    if (pattern.sequence.length < 2) return null;
+    const tools = pattern.sequence.map((s) => {
+      const [tool, target] = s.split(":", 2);
+      return { tool, target: target || "*" };
+    });
+    const toolNames = [...new Set(tools.map((t) => t.tool.toLowerCase()))];
+    const targets = tools.map((t) => t.target).filter((t) => t !== "*");
+    const dominantDir = targets.length > 0 ? targets[0].split("/").slice(0, 3).join("-").replace(/[^a-zA-Z0-9-]/g, "") : "";
+    const nameSuffix = dominantDir ? `-${dominantDir}` : "";
+    const name = `auto-${toolNames.join("-")}${nameSuffix}`;
+    const firstTarget = tools[0].target;
+    const inputs = [];
+    if (firstTarget && firstTarget !== "*") {
+      inputs.push({
+        name: "target_path",
+        type: "string",
+        required: true,
+        description: `Path pattern (observed: ${firstTarget})`
+      });
+    }
+    const lastTool = tools[tools.length - 1];
+    const outputs = [
+      {
+        name: "result",
+        type: "string",
+        description: `Output from ${lastTool.tool}`
+      }
+    ];
+    const steps = tools.map((t, i) => `${i + 1}. ${t.tool}: ${t.target}`);
+    const confidence = Math.min(1, pattern.score / 20);
+    return {
+      name,
+      description: `Auto-detected workflow: ${toolNames.join(" \u2192 ")} (seen ${pattern.frequency}\xD7 across ${pattern.sessions} sessions)`,
+      inputs,
+      outputs,
+      steps,
+      pattern_id: pattern.id,
+      confidence,
+      generated_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  renderSkillMarkdown(suggestion) {
+    const inputsYaml = suggestion.inputs.length > 0 ? suggestion.inputs.map(
+      (i) => `  - name: ${i.name}
+    type: ${i.type}
+    required: ${i.required}
+    description: "${i.description}"`
+    ).join("\n") : "";
+    const outputsYaml = suggestion.outputs.map(
+      (o) => `  - name: ${o.name}
+    type: ${o.type}
+    description: "${o.description}"`
+    ).join("\n");
+    return [
+      "---",
+      `name: ${suggestion.name}`,
+      `description: "${suggestion.description}"`,
+      `status: suggested`,
+      `pattern_id: ${suggestion.pattern_id}`,
+      `confidence: ${suggestion.confidence.toFixed(2)}`,
+      `generated_at: ${suggestion.generated_at}`,
+      suggestion.inputs.length > 0 ? `inputs:
+${inputsYaml}` : "",
+      `outputs:
+${outputsYaml}`,
+      "---",
+      "",
+      `# ${suggestion.name}`,
+      "",
+      "## Auto-Detected Workflow",
+      "",
+      `> This skill was auto-generated from ${suggestion.pattern_id} detected patterns.`,
+      "> Review and edit before promoting to an active skill.",
+      "",
+      "## Steps",
+      "",
+      ...suggestion.steps,
+      "",
+      "## Notes",
+      "",
+      "- Edit this file to refine the workflow",
+      "- Move to your `skills/` directory to activate",
+      `- Confidence: ${(suggestion.confidence * 100).toFixed(0)}%`
+    ].filter((line) => line !== "").join("\n") + "\n";
+  }
+  // ─── Lifecycle (adaptive backoff) ──────────────────────────
+  //
+  // Active sessions:  scan every 1 hour
+  // Idle (no actions): backoff 1h → 2h → 4h → 8h → 12h (cap)
+  // New activity resets to 1h immediately
+  static BASE_INTERVAL_MS = 60 * 60 * 1e3;
+  // 1 hour
+  static MAX_INTERVAL_MS = 12 * 60 * 60 * 1e3;
+  // 12 hours
+  static IDLE_THRESHOLD_MS = 30 * 60 * 1e3;
+  // 30 min = idle
+  getNextInterval() {
+    const now = Date.now();
+    const timeSinceActivity = now - this.lastActivityTime;
+    if (this.lastActivityTime > 0 && timeSinceActivity < DaemonDesirePathService.IDLE_THRESHOLD_MS) {
+      this.consecutiveIdleScans = 0;
+      return DaemonDesirePathService.BASE_INTERVAL_MS;
+    }
+    const backoff = DaemonDesirePathService.BASE_INTERVAL_MS * Math.pow(2, this.consecutiveIdleScans);
+    return Math.min(backoff, DaemonDesirePathService.MAX_INTERVAL_MS);
+  }
+  start() {
+    if (this.isRunning || this.isOptedOut()) {
+      if (this.isOptedOut()) {
+        this.onLog("INFO", "Desire-path detection disabled");
+      }
+      return;
+    }
+    this.isRunning = true;
+    mkdirSync(DP_DIR, { recursive: true });
+    this.onLog(
+      "INFO",
+      "Desire-path service started (adaptive backoff: 1h active, up to 12h idle)"
+    );
+    this.scanTimeout = setTimeout(() => {
+      if (!this.isRunning) return;
+      this.runScanAndScheduleNext();
+    }, 12e4);
+    if (this.scanTimeout.unref) this.scanTimeout.unref();
+  }
+  stop() {
+    if (this.scanTimeout) {
+      clearTimeout(this.scanTimeout);
+      this.scanTimeout = void 0;
+    }
+    this.isRunning = false;
+  }
+  runScanAndScheduleNext() {
+    this.runScan();
+    if (!this.isRunning) return;
+    const nextMs = this.getNextInterval();
+    this.onLog("DEBUG", "Next scan scheduled", {
+      next_min: Math.round(nextMs / 6e4),
+      idle_scans: this.consecutiveIdleScans
+    });
+    this.scanTimeout = setTimeout(() => {
+      if (!this.isRunning) return;
+      this.runScanAndScheduleNext();
+    }, nextMs);
+    if (this.scanTimeout.unref) this.scanTimeout.unref();
+  }
+  runScan() {
+    const prevActionsLogged = this.state.actionsLogged;
+    try {
+      const patterns = this.detectPatterns();
+      if (patterns.length > 0) {
+        const suggestions = this.generateSuggestions(patterns);
+        this.onLog("INFO", "Desire-path scan complete", {
+          patterns: patterns.length,
+          suggestions: suggestions.length,
+          topPattern: patterns[0] ? sequenceHash(patterns[0].sequence) : "none",
+          interval_min: Math.round(this.getNextInterval() / 6e4)
+        });
+      }
+      this.state.lastScanTime = Date.now();
+      if (this.state.actionsLogged === prevActionsLogged) {
+        this.consecutiveIdleScans++;
+      } else {
+        this.consecutiveIdleScans = 0;
+      }
+    } catch (err) {
+      this.addError(String(err));
+      this.onLog("ERROR", "Desire-path scan failed", { error: String(err) });
+    }
+  }
+  addError(err) {
+    this.state.errors.push(err);
+    if (this.state.errors.length > 10) {
+      this.state.errors = this.state.errors.slice(-10);
+    }
+  }
+  getState() {
+    return { ...this.state };
+  }
+  /** Get current suggestions for CLI/MCP consumption. */
+  getSuggestions() {
+    try {
+      if (!existsSync(SUGGESTIONS_DIR)) return [];
+      const files = readdirSync(SUGGESTIONS_DIR).filter(
+        (f) => f.endsWith(".skill.md")
+      );
+      return files.map((f) => {
+        const content = readFileSync(join(SUGGESTIONS_DIR, f), "utf-8");
+        const match = content.match(/^---\n([\s\S]*?)\n---/);
+        if (!match) return null;
+        try {
+          const lines = match[1].split("\n");
+          const meta = {};
+          for (const line of lines) {
+            const kv = line.match(/^(\w[\w_-]*):\s*(.*)/);
+            if (kv) meta[kv[1]] = kv[2].trim().replace(/^["']|["']$/g, "");
+          }
+          return {
+            name: meta.name || basename(f, ".skill.md"),
+            description: meta.description || "",
+            pattern_id: meta.pattern_id || "",
+            confidence: parseFloat(meta.confidence || "0"),
+            generated_at: meta.generated_at || "",
+            inputs: [],
+            outputs: [],
+            steps: []
+          };
+        } catch {
+          return null;
+        }
+      }).filter(Boolean);
+    } catch {
+      return [];
+    }
+  }
+}
+export {
+  DaemonDesirePathService
+};

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
+};