@stackmemoryai/stackmemory 0.3.1 → 0.3.5

package/dist/skills/claude-skills.js

@@ -0,0 +1,666 @@
+import { logger } from "../core/monitoring/logger.js";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+class HandoffSkill {
+  constructor(context) {
+    this.context = context;
+  }
+  async execute(targetUser, message, options) {
+    try {
+      const activeStack = this.context.dualStackManager.getActiveStack();
+      let framesToHandoff = options?.frames || [];
+      if (options?.autoDetect !== false && framesToHandoff.length === 0) {
+        const allFrames = await activeStack.getAllFrames();
+        const relevantFrames = allFrames.filter(
+          (f) => f.state === "completed" || f.outputs && Array.isArray(f.outputs) && f.outputs.some((o) => o.type === "error")
+        );
+        framesToHandoff = relevantFrames.slice(-5).map((f) => f.frameId);
+      }
+      if (framesToHandoff.length === 0) {
+        return {
+          success: false,
+          message: "No frames to handoff. Specify frames or complete some work first."
+        };
+      }
+      const frameDetails = await Promise.all(
+        framesToHandoff.map((id) => activeStack.getFrame(id))
+      );
+      const summary = this.generateHandoffSummary(frameDetails, message);
+      const metadata = {
+        initiatedAt: /* @__PURE__ */ new Date(),
+        initiatorId: this.context.userId,
+        targetUserId: targetUser,
+        frameContext: {
+          totalFrames: framesToHandoff.length,
+          frameTypes: [
+            ...new Set(frameDetails.map((f) => f?.type || "unknown"))
+          ],
+          estimatedSize: JSON.stringify(frameDetails).length,
+          dependencies: this.extractDependencies(frameDetails)
+        },
+        businessContext: {
+          priority: options?.priority || "medium",
+          stakeholders: [targetUser]
+        }
+      };
+      const availableStacks = await this.context.dualStackManager.getAvailableStacks();
+      let targetStackId = availableStacks.find(
+        (s) => s.type === "shared"
+      )?.stackId;
+      if (!targetStackId) {
+        targetStackId = await this.context.dualStackManager.createSharedStack(
+          "team",
+          `Handoff: ${message.slice(0, 50)}`,
+          this.context.userId
+        );
+      }
+      const handoffId = await this.context.handoffManager.initiateHandoff(
+        targetStackId,
+        framesToHandoff,
+        metadata,
+        targetUser,
+        summary
+      );
+      const actionItems = this.generateActionItems(frameDetails);
+      return {
+        success: true,
+        message: `Handoff initiated to @${targetUser}`,
+        data: {
+          handoffId,
+          frameCount: framesToHandoff.length,
+          priority: options?.priority || "medium",
+          actionItems,
+          targetStack: targetStackId
+        },
+        action: `Notified ${targetUser}. Handoff ID: ${handoffId}`
+      };
+    } catch (error) {
+      logger.error("Handoff skill error:", error);
+      return {
+        success: false,
+        message: `Failed to initiate handoff: ${error.message}`
+      };
+    }
+  }
+  generateHandoffSummary(frames, message) {
+    const completed = frames.filter((f) => f?.state === "completed").length;
+    const blocked = frames.filter(
+      (f) => f?.outputs?.some((o) => o.type === "error")
+    ).length;
+    return `
+## Handoff Summary
+**Message**: ${message}
+**Frames**: ${frames.length} total (${completed} completed, ${blocked} blocked)
+
+### Work Completed:
+${frames.filter((f) => f?.state === "completed").map((f) => `- ${f.name}: ${f.digest_deterministic?.summary || "No summary"}`).join("\n")}
+
+### Attention Required:
+${frames.filter((f) => f?.outputs?.some((o) => o.type === "error")).map(
+      (f) => `- ${f.name}: ${f.outputs.find((o) => o.type === "error")?.content || "Error"}`
+    ).join("\n") || "None"}
+
+### Context:
+${frames.map((f) => f?.digest_ai?.context || "").filter(Boolean).join("\n")}
+    `.trim();
+  }
+  extractDependencies(frames) {
+    const deps = /* @__PURE__ */ new Set();
+    frames.forEach((frame) => {
+      if (frame?.inputs?.dependencies) {
+        if (Array.isArray(frame.inputs.dependencies)) {
+          frame.inputs.dependencies.forEach((d) => deps.add(d));
+        }
+      }
+      if (frame?.outputs) {
+        frame.outputs.forEach((output) => {
+          if (output.type === "dependency") {
+            deps.add(output.content);
+          }
+        });
+      }
+    });
+    return Array.from(deps);
+  }
+  generateActionItems(frames) {
+    const items = [];
+    frames.forEach((frame) => {
+      if (frame?.outputs) {
+        frame.outputs.forEach((output) => {
+          if (output.type === "todo" || output.content?.includes("TODO")) {
+            items.push(output.content);
+          }
+        });
+      }
+      if (frame?.outputs?.some((o) => o.type === "error")) {
+        items.push(`Resolve error in ${frame.name}`);
+      }
+      if (frame?.inputs?.tests === "pending" || frame?.type === "implementation" || frame?.name && frame.name.toLowerCase().includes("implementation")) {
+        items.push(`Write tests for ${frame.name}`);
+      }
+    });
+    return items;
+  }
+}
+class CheckpointSkill {
+  constructor(context) {
+    this.context = context;
+    this.checkpointDir = path.join(
+      os.homedir(),
+      ".stackmemory",
+      "checkpoints",
+      context.projectId
+    );
+    fs.mkdirSync(this.checkpointDir, { recursive: true });
+  }
+  checkpointDir;
+  async create(description, options) {
+    try {
+      const timestamp = Date.now();
+      const checkpointId = `checkpoint-${timestamp}-${Math.random().toString(36).slice(2, 8)}`;
+      const activeStack = this.context.dualStackManager.getActiveStack();
+      const currentContext = this.context.dualStackManager.getCurrentContext();
+      const allFrames = await activeStack.getAllFrames();
+      const checkpoint = {
+        id: checkpointId,
+        timestamp,
+        description,
+        context: {
+          stackId: currentContext.stackId,
+          stackType: currentContext.type,
+          userId: this.context.userId,
+          projectId: this.context.projectId
+        },
+        frames: allFrames,
+        metadata: {
+          ...options?.metadata,
+          frameCount: allFrames.length,
+          activeFrames: allFrames.filter((f) => f.state === "active").length,
+          completedFrames: allFrames.filter((f) => f.state === "completed").length
+        },
+        files: options?.includeFiles || []
+      };
+      const checkpointPath = path.join(
+        this.checkpointDir,
+        `${checkpointId}.json`
+      );
+      fs.writeFileSync(checkpointPath, JSON.stringify(checkpoint, null, 2));
+      if (options?.includeFiles && options.includeFiles.length > 0) {
+        const filesDir = path.join(this.checkpointDir, checkpointId, "files");
+        fs.mkdirSync(filesDir, { recursive: true });
+        for (const file of options.includeFiles) {
+          if (fs.existsSync(file)) {
+            const basename = path.basename(file);
+            const backupPath = path.join(filesDir, basename);
+            fs.copyFileSync(file, backupPath);
+          }
+        }
+      }
+      if (options?.autoDetectRisky) {
+        const riskyPatterns = [
+          "migration",
+          "database",
+          "deploy",
+          "production",
+          "delete",
+          "remove",
+          "drop",
+          "migrate"
+          // Add more specific pattern
+        ];
+        const isRisky = allFrames.some((frame) => {
+          const nameMatches = frame.name && riskyPatterns.some(
+            (pattern) => frame.name.toLowerCase().includes(pattern)
+          );
+          const commandMatches = frame.inputs?.command && riskyPatterns.some(
+            (pattern) => frame.inputs.command.toLowerCase().includes(pattern)
+          );
+          return nameMatches || commandMatches;
+        });
+        if (isRisky) {
+          checkpoint.metadata.riskyOperation = true;
+          checkpoint.metadata.autoCheckpoint = true;
+        }
+      }
+      fs.writeFileSync(checkpointPath, JSON.stringify(checkpoint, null, 2));
+      logger.info(`Created checkpoint: ${checkpointId}`);
+      return {
+        success: true,
+        message: `Checkpoint created: ${description}`,
+        data: {
+          checkpointId,
+          timestamp: new Date(timestamp).toISOString(),
+          frameCount: checkpoint.metadata.frameCount,
+          location: checkpointPath
+        },
+        action: `Saved checkpoint ${checkpointId}`
+      };
+    } catch (error) {
+      logger.error("Checkpoint creation error:", error);
+      return {
+        success: false,
+        message: `Failed to create checkpoint: ${error.message}`
+      };
+    }
+  }
+  async restore(checkpointId) {
+    try {
+      const checkpointPath = path.join(
+        this.checkpointDir,
+        `${checkpointId}.json`
+      );
+      if (!fs.existsSync(checkpointPath)) {
+        const files = fs.readdirSync(this.checkpointDir);
+        const match = files.find((f) => f.includes(checkpointId));
+        if (match) {
+          checkpointId = match.replace(".json", "");
+        } else {
+          return {
+            success: false,
+            message: `Checkpoint not found: ${checkpointId}`
+          };
+        }
+      }
+      const checkpoint = JSON.parse(fs.readFileSync(checkpointPath, "utf-8"));
+      await this.context.dualStackManager.switchToStack(
+        checkpoint.context.stackId
+      );
+      const filesDir = path.join(this.checkpointDir, checkpointId, "files");
+      if (fs.existsSync(filesDir)) {
+        const files = fs.readdirSync(filesDir);
+        for (const file of files) {
+          const backupPath = path.join(filesDir, file);
+          const originalPath = checkpoint.files.find(
+            (f) => path.basename(f) === file
+          );
+          if (originalPath && fs.existsSync(backupPath)) {
+            fs.copyFileSync(backupPath, originalPath);
+          }
+        }
+      }
+      logger.info(`Restored checkpoint: ${checkpointId}`);
+      return {
+        success: true,
+        message: `Restored to checkpoint: ${checkpoint.description}`,
+        data: {
+          checkpointId,
+          timestamp: new Date(checkpoint.timestamp).toISOString(),
+          frameCount: checkpoint.metadata.frameCount,
+          filesRestored: checkpoint.files.length
+        },
+        action: `Restored checkpoint from ${new Date(checkpoint.timestamp).toLocaleString()}`
+      };
+    } catch (error) {
+      logger.error("Checkpoint restoration error:", error);
+      return {
+        success: false,
+        message: `Failed to restore checkpoint: ${error.message}`
+      };
+    }
+  }
+  async list(options) {
+    try {
+      const files = fs.readdirSync(this.checkpointDir).filter((f) => f.endsWith(".json")).map((f) => {
+        const checkpointPath = path.join(this.checkpointDir, f);
+        const checkpoint = JSON.parse(
+          fs.readFileSync(checkpointPath, "utf-8")
+        );
+        return checkpoint;
+      }).filter((c) => !options?.since || c.timestamp > options.since.getTime()).sort((a, b) => b.timestamp - a.timestamp).slice(0, options?.limit || 10);
+      return {
+        success: true,
+        message: `Found ${files.length} checkpoints`,
+        data: files.map((c) => ({
+          id: c.id,
+          description: c.description,
+          timestamp: new Date(c.timestamp).toISOString(),
+          frameCount: c.metadata.frameCount,
+          risky: c.metadata.riskyOperation || false
+        }))
+      };
+    } catch (error) {
+      logger.error("Checkpoint list error:", error);
+      return {
+        success: false,
+        message: `Failed to list checkpoints: ${error.message}`
+      };
+    }
+  }
+  async diff(checkpoint1, checkpoint2) {
+    try {
+      const cp1 = await this.loadCheckpoint(checkpoint1);
+      const cp2 = await this.loadCheckpoint(checkpoint2);
+      if (!cp1 || !cp2) {
+        return {
+          success: false,
+          message: "One or both checkpoints not found"
+        };
+      }
+      const diff = {
+        timeDiff: Math.abs(cp2.timestamp - cp1.timestamp),
+        framesDiff: cp2.frames.length - cp1.frames.length,
+        newFrames: cp2.frames.filter(
+          (f2) => !cp1.frames.some((f1) => f1.frameId === f2.frameId)
+        ),
+        removedFrames: cp1.frames.filter(
+          (f1) => !cp2.frames.some((f2) => f2.frameId === f1.frameId)
+        ),
+        modifiedFrames: cp2.frames.filter((f2) => {
+          const f1 = cp1.frames.find((f) => f.frameId === f2.frameId);
+          return f1 && JSON.stringify(f1) !== JSON.stringify(f2);
+        })
+      };
+      return {
+        success: true,
+        message: `Diff between ${cp1.description} and ${cp2.description}`,
+        data: {
+          timeDiff: `${Math.round(diff.timeDiff / 1e3 / 60)} minutes`,
+          framesDiff: diff.framesDiff > 0 ? `+${diff.framesDiff}` : `${diff.framesDiff}`,
+          newFrames: diff.newFrames.length,
+          removedFrames: diff.removedFrames.length,
+          modifiedFrames: diff.modifiedFrames.length,
+          details: diff
+        }
+      };
+    } catch (error) {
+      logger.error("Checkpoint diff error:", error);
+      return {
+        success: false,
+        message: `Failed to diff checkpoints: ${error.message}`
+      };
+    }
+  }
+  async loadCheckpoint(checkpointId) {
+    const checkpointPath = path.join(
+      this.checkpointDir,
+      `${checkpointId}.json`
+    );
+    if (fs.existsSync(checkpointPath)) {
+      return JSON.parse(fs.readFileSync(checkpointPath, "utf-8"));
+    }
+    const files = fs.readdirSync(this.checkpointDir);
+    const match = files.find((f) => f.includes(checkpointId));
+    if (match) {
+      const path2 = path2.join(this.checkpointDir, match);
+      return JSON.parse(fs.readFileSync(path2, "utf-8"));
+    }
+    return null;
+  }
+}
+class ArchaeologistSkill {
+  constructor(context) {
+    this.context = context;
+  }
+  async dig(query, options) {
+    try {
+      const depth = this.parseDepth(options?.depth || "30days");
+      const since = new Date(Date.now() - depth);
+      const results = await this.context.contextRetriever.retrieve({
+        query,
+        projectId: this.context.projectId,
+        limit: 50,
+        minScore: 0.3
+      });
+      const filtered = results.filter(
+        (r) => !depth || new Date(r.timestamp) > since
+      );
+      let patterns = [];
+      if (options?.patterns) {
+        patterns = this.extractPatterns(filtered);
+      }
+      let decisions = [];
+      if (options?.decisions) {
+        decisions = this.extractDecisions(filtered);
+      }
+      let timeline = [];
+      if (options?.timeline) {
+        timeline = this.generateTimeline(filtered);
+      }
+      const topResults = filtered.slice(0, 10);
+      const summary = this.generateArchaeologySummary(
+        topResults,
+        patterns,
+        decisions,
+        timeline
+      );
+      return {
+        success: true,
+        message: `Found ${filtered.length} relevant results`,
+        data: {
+          totalResults: filtered.length,
+          timeRange: {
+            from: since.toISOString(),
+            to: (/* @__PURE__ */ new Date()).toISOString()
+          },
+          topResults: topResults.map((r) => ({
+            frameId: r.frameId,
+            score: r.score,
+            timestamp: r.timestamp,
+            summary: r.content.slice(0, 100) + "..."
+          })),
+          patterns,
+          decisions,
+          timeline,
+          summary
+        },
+        action: `Analyzed ${filtered.length} frames from ${options?.depth || "30days"} of history`
+      };
+    } catch (error) {
+      logger.error("Archaeology skill error:", error);
+      return {
+        success: false,
+        message: `Failed to dig through context: ${error.message}`
+      };
+    }
+  }
+  parseDepth(depth) {
+    const match = depth.match(/^(\d+)(days?|weeks?|months?|years?|all)$/i);
+    if (!match) {
+      return 30 * 24 * 60 * 60 * 1e3;
+    }
+    const [, num, unit] = match;
+    const value = parseInt(num);
+    switch (unit.toLowerCase()) {
+      case "day":
+      case "days":
+        return value * 24 * 60 * 60 * 1e3;
+      case "week":
+      case "weeks":
+        return value * 7 * 24 * 60 * 60 * 1e3;
+      case "month":
+      case "months":
+        return value * 30 * 24 * 60 * 60 * 1e3;
+      case "year":
+      case "years":
+        return value * 365 * 24 * 60 * 60 * 1e3;
+      case "all":
+        return Number.MAX_SAFE_INTEGER;
+      default:
+        return 30 * 24 * 60 * 60 * 1e3;
+    }
+  }
+  extractPatterns(results) {
+    const patterns = /* @__PURE__ */ new Map();
+    const patternTypes = [
+      { regex: /test.*then.*implement/i, name: "TDD" },
+      { regex: /refactor/i, name: "Refactoring" },
+      { regex: /debug|fix|error|bug/i, name: "Debugging" },
+      { regex: /implement.*feature/i, name: "Feature Development" },
+      { regex: /review|code review/i, name: "Code Review" },
+      { regex: /deploy|release/i, name: "Deployment" },
+      { regex: /optimize|performance/i, name: "Optimization" }
+    ];
+    results.forEach((result) => {
+      patternTypes.forEach((pattern) => {
+        if (pattern.regex.test(result.content)) {
+          patterns.set(pattern.name, (patterns.get(pattern.name) || 0) + 1);
+        }
+      });
+    });
+    return Array.from(patterns.entries()).map(([name, count]) => ({ name, count })).sort((a, b) => b.count - a.count);
+  }
+  extractDecisions(results) {
+    const decisions = [];
+    const decisionKeywords = [
+      "decided",
+      "chose",
+      "selected",
+      "will use",
+      "going with",
+      "approach",
+      "strategy",
+      "solution"
+    ];
+    results.forEach((result) => {
+      const content = result.content.toLowerCase();
+      if (decisionKeywords.some((keyword) => content.includes(keyword))) {
+        const sentences = result.content.split(/[.!?]+/);
+        const decisionSentence = sentences.find(
+          (s) => decisionKeywords.some((k) => s.toLowerCase().includes(k))
+        );
+        if (decisionSentence) {
+          decisions.push({
+            frameId: result.frameId,
+            timestamp: result.timestamp,
+            decision: decisionSentence.trim(),
+            context: result.content.slice(0, 200)
+          });
+        }
+      }
+    });
+    return decisions.slice(0, 10);
+  }
+  generateTimeline(results) {
+    const timeline = /* @__PURE__ */ new Map();
+    results.forEach((result) => {
+      const date = new Date(result.timestamp).toDateString();
+      if (!timeline.has(date)) {
+        timeline.set(date, []);
+      }
+      timeline.get(date).push(result);
+    });
+    return Array.from(timeline.entries()).map(([date, items]) => ({
+      date,
+      itemCount: items.length,
+      highlights: items.slice(0, 3).map((item) => ({
+        frameId: item.frameId,
+        summary: item.content.slice(0, 50) + "..."
+      }))
+    })).sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime());
+  }
+  generateArchaeologySummary(results, patterns, decisions, timeline) {
+    let summary = "## Context Archaeology Report\n\n";
+    if (results.length > 0) {
+      summary += `### Most Relevant Context (${results.length} results)
+`;
+      results.slice(0, 3).forEach((r) => {
+        summary += `- **${new Date(r.timestamp).toLocaleDateString()}**: ${r.content.slice(0, 100)}...
+`;
+      });
+      summary += "\n";
+    }
+    if (patterns.length > 0) {
+      summary += `### Detected Patterns
+`;
+      patterns.slice(0, 5).forEach((p) => {
+        summary += `- ${p.name}: ${p.count} occurrences
+`;
+      });
+      summary += "\n";
+    }
+    if (decisions.length > 0) {
+      summary += `### Key Decisions
+`;
+      decisions.slice(0, 5).forEach((d) => {
+        summary += `- **${new Date(d.timestamp).toLocaleDateString()}**: ${d.decision}
+`;
+      });
+      summary += "\n";
+    }
+    if (timeline.length > 0) {
+      summary += `### Activity Timeline
+`;
+      timeline.slice(0, 5).forEach((t) => {
+        summary += `- **${t.date}**: ${t.itemCount} activities
+`;
+      });
+    }
+    return summary;
+  }
+}
+class ClaudeSkillsManager {
+  constructor(context) {
+    this.context = context;
+    this.handoffSkill = new HandoffSkill(context);
+    this.checkpointSkill = new CheckpointSkill(context);
+    this.archaeologistSkill = new ArchaeologistSkill(context);
+  }
+  handoffSkill;
+  checkpointSkill;
+  archaeologistSkill;
+  async executeSkill(skillName, args, options) {
+    switch (skillName) {
+      case "handoff":
+        return this.handoffSkill.execute(args[0], args[1], options);
+      case "checkpoint":
+        const subcommand = args[0];
+        switch (subcommand) {
+          case "create":
+            return this.checkpointSkill.create(args[1], options);
+          case "restore":
+            return this.checkpointSkill.restore(args[1]);
+          case "list":
+            return this.checkpointSkill.list(options);
+          case "diff":
+            return this.checkpointSkill.diff(args[1], args[2]);
+          default:
+            return {
+              success: false,
+              message: `Unknown checkpoint subcommand: ${subcommand}`
+            };
+        }
+      case "dig":
+        return this.archaeologistSkill.dig(args[0], options);
+      default:
+        return {
+          success: false,
+          message: `Unknown skill: ${skillName}`
+        };
+    }
+  }
+  getAvailableSkills() {
+    return ["handoff", "checkpoint", "dig"];
+  }
+  getSkillHelp(skillName) {
+    switch (skillName) {
+      case "handoff":
+        return `
+/handoff @user "message" [--priority high] [--frames frame1,frame2]
+Streamline frame handoffs between team members
+`;
+      case "checkpoint":
+        return `
+/checkpoint create "description" [--files file1,file2] [--auto-detect-risky]
+/checkpoint restore <id>
+/checkpoint list [--limit 10] [--since "2024-01-01"]
+/checkpoint diff <id1> <id2>
+Create and manage recovery points
+`;
+      case "dig":
+        return `
+/dig "query" [--depth 6months] [--patterns] [--decisions] [--timeline]
+Deep historical context retrieval across sessions
+`;
+      default:
+        return `Unknown skill: ${skillName}`;
+    }
+  }
+}
+export {
+  ArchaeologistSkill,
+  CheckpointSkill,
+  ClaudeSkillsManager,
+  HandoffSkill
+};
+//# sourceMappingURL=claude-skills.js.map