@stackmemoryai/stackmemory 1.10.4 → 1.12.0

package/dist/src/core/shared-state/canonical-store.js

@@ -0,0 +1,564 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import * as fs from "fs/promises";
+import * as path from "path";
+import * as os from "os";
+import { createHash, randomUUID } from "crypto";
+function getBaseStateDir() {
+  const xdgState = process.env["XDG_STATE_HOME"]?.trim();
+  if (xdgState) {
+    return path.join(xdgState, "stackmemory");
+  }
+  const homeDir = process.env["HOME"] || process.env["USERPROFILE"] || os.homedir();
+  return path.join(homeDir, ".stackmemory");
+}
+function projectIdFromIdentifier(identifier) {
+  return identifier.replace(/\.git$/, "").replace(/[^a-zA-Z0-9-]/g, "-").toLowerCase().slice(-50);
+}
+function normalizeProjectId(projectId, projectPath) {
+  if (projectId && projectId.trim()) {
+    return projectIdFromIdentifier(projectId.trim());
+  }
+  if (!projectPath || !projectPath.trim()) {
+    return void 0;
+  }
+  return createHash("sha1").update(projectPath.trim().toLowerCase()).digest("hex").slice(0, 16);
+}
+async function pathExists(targetPath) {
+  try {
+    await fs.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+class CanonicalStateStore {
+  rootDir;
+  constructor(rootDir = path.join(getBaseStateDir(), "shared-state")) {
+    this.rootDir = rootDir;
+  }
+  getRootDir() {
+    return this.rootDir;
+  }
+  async initialize() {
+    await fs.mkdir(this.getInstancesDir(), { recursive: true });
+    await fs.mkdir(this.getSessionsDir(), { recursive: true });
+    await fs.mkdir(this.getEventsDir(), { recursive: true });
+    await fs.mkdir(this.getGithubDir(), { recursive: true });
+    await fs.mkdir(this.getClaimsDir(), { recursive: true });
+  }
+  async upsertInstance(input) {
+    await this.initialize();
+    const filePath = this.getInstanceFile(input.instanceId);
+    const existing = await this.readJsonFile(filePath);
+    const now = Date.now();
+    const record = {
+      instanceId: input.instanceId,
+      tool: input.tool,
+      sessionId: input.sessionId ?? existing?.sessionId,
+      projectId: normalizeProjectId(input.projectId, input.projectPath) ?? existing?.projectId,
+      projectPath: input.projectPath ?? existing?.projectPath,
+      branch: input.branch ?? existing?.branch,
+      worktreePath: input.worktreePath ?? existing?.worktreePath,
+      pid: input.pid ?? existing?.pid,
+      startedAt: existing?.startedAt ?? input.startedAt ?? now,
+      lastSeenAt: input.lastSeenAt ?? now,
+      status: input.status ?? existing?.status ?? "active",
+      metadata: {
+        ...existing?.metadata || {},
+        ...input.metadata || {}
+      }
+    };
+    await this.writeJsonFile(filePath, record);
+    if (record.sessionId) {
+      await this.upsertSession({
+        sessionId: record.sessionId,
+        tool: record.tool,
+        projectId: record.projectId,
+        projectPath: record.projectPath,
+        branch: record.branch,
+        instanceId: record.instanceId,
+        metadata: record.metadata
+      });
+    }
+    return record;
+  }
+  async endInstance(instanceId) {
+    await this.initialize();
+    const filePath = this.getInstanceFile(instanceId);
+    const existing = await this.readJsonFile(filePath);
+    if (!existing) {
+      return;
+    }
+    const updated = {
+      ...existing,
+      status: "ended",
+      lastSeenAt: Date.now()
+    };
+    await this.writeJsonFile(filePath, updated);
+  }
+  async upsertSession(input) {
+    await this.initialize();
+    const filePath = this.getSessionFile(input.sessionId);
+    const existing = await this.readJsonFile(filePath);
+    const now = Date.now();
+    const nextInstanceIds = new Set(existing?.instanceIds || []);
+    if (input.instanceId) {
+      nextInstanceIds.add(input.instanceId);
+    }
+    for (const instanceId of input.instanceIds || []) {
+      nextInstanceIds.add(instanceId);
+    }
+    const record = {
+      sessionId: input.sessionId,
+      tool: input.tool,
+      projectId: normalizeProjectId(input.projectId, input.projectPath) ?? existing?.projectId,
+      projectPath: input.projectPath ?? existing?.projectPath,
+      branch: input.branch ?? existing?.branch,
+      startedAt: existing?.startedAt ?? input.startedAt ?? now,
+      lastSeenAt: input.lastSeenAt ?? now,
+      status: input.status ?? existing?.status ?? "active",
+      instanceIds: Array.from(nextInstanceIds),
+      metadata: {
+        ...existing?.metadata || {},
+        ...input.metadata || {}
+      }
+    };
+    await this.writeJsonFile(filePath, record);
+    return record;
+  }
+  async endSession(sessionId, status = "closed") {
+    await this.initialize();
+    const filePath = this.getSessionFile(sessionId);
+    const existing = await this.readJsonFile(filePath);
+    if (!existing) {
+      return;
+    }
+    const updated = {
+      ...existing,
+      status,
+      lastSeenAt: Date.now()
+    };
+    await this.writeJsonFile(filePath, updated);
+  }
+  async saveGitHubPullRequest(projection) {
+    await this.initialize();
+    const normalizedProjectId = normalizeProjectId(projection.projectId, projection.projectPath) ?? projection.projectId;
+    const filePath = this.getGitHubPullRequestFile(
+      projection.repo,
+      projection.branch
+    );
+    const record = {
+      ...projection,
+      projectId: normalizedProjectId,
+      lastSyncedAt: projection.lastSyncedAt || Date.now()
+    };
+    await this.writeJsonFile(filePath, record);
+    return record;
+  }
+  async claimPaths(input) {
+    await this.initialize();
+    await this.cleanupExpiredClaims();
+    const now = input.lastSeenAt ?? Date.now();
+    const existing = input.claimId ? await this.readJsonFile(
+      this.getClaimFile(input.claimId)
+    ) : null;
+    const record = {
+      claimId: input.claimId || randomUUID(),
+      tool: input.tool,
+      sessionId: input.sessionId ?? existing?.sessionId,
+      instanceId: input.instanceId ?? existing?.instanceId,
+      projectId: normalizeProjectId(input.projectId, input.projectPath) ?? existing?.projectId,
+      projectPath: input.projectPath ?? existing?.projectPath,
+      branch: input.branch ?? existing?.branch,
+      paths: Array.from(
+        new Set(
+          (input.paths ?? existing?.paths ?? []).map((item) => item.trim()).filter(Boolean)
+        )
+      ),
+      status: input.status ?? "active",
+      claimedAt: existing?.claimedAt ?? now,
+      lastSeenAt: now,
+      expiresAt: input.expiresAt ?? now + Math.max(1, input.ttlMs ?? 24 * 60 * 60 * 1e3),
+      metadata: {
+        ...existing?.metadata || {},
+        ...input.metadata || {}
+      }
+    };
+    const conflicts = (await this.listPathClaims({
+      projectId: record.projectId,
+      projectPath: record.projectPath,
+      activeOnly: true
+    })).filter((claim) => claim.claimId !== record.claimId).filter((claim) => this.claimsOverlap(record, claim)).map((claim) => ({
+      claimId: claim.claimId,
+      branch: claim.branch,
+      paths: claim.paths,
+      sessionId: claim.sessionId,
+      instanceId: claim.instanceId
+    }));
+    await this.writeJsonFile(this.getClaimFile(record.claimId), record);
+    return { record, conflicts };
+  }
+  async releaseClaims(options) {
+    await this.initialize();
+    const now = Date.now();
+    let released = 0;
+    const claims = await this.listPathClaims({
+      projectId: options.projectId,
+      projectPath: options.projectPath,
+      activeOnly: false
+    });
+    for (const claim of claims) {
+      if (claim.status !== "active") {
+        continue;
+      }
+      if (options.claimId && claim.claimId !== options.claimId) {
+        continue;
+      }
+      if (options.instanceId && claim.instanceId !== options.instanceId) {
+        continue;
+      }
+      if (options.sessionId && claim.sessionId !== options.sessionId) {
+        continue;
+      }
+      if (options.branch && claim.branch !== options.branch) {
+        continue;
+      }
+      await this.writeJsonFile(this.getClaimFile(claim.claimId), {
+        ...claim,
+        status: "released",
+        lastSeenAt: now,
+        releasedAt: now,
+        releaseReason: options.reason || claim.releaseReason
+      });
+      released++;
+    }
+    return released;
+  }
+  async listPathClaims(options) {
+    await this.initialize();
+    await this.cleanupExpiredClaims();
+    const projectId = normalizeProjectId(
+      options?.projectId,
+      options?.projectPath
+    );
+    const dir = this.getClaimsDir();
+    const entries = await fs.readdir(dir);
+    const claims = await Promise.all(
+      entries.filter((entry) => entry.endsWith(".json")).map(
+        (entry) => this.readJsonFile(path.join(dir, entry))
+      )
+    );
+    return claims.filter(Boolean).filter((claim) => !options?.activeOnly || claim.status === "active").filter(
+      (claim) => !projectId || this.matchesProject(
+        claim.projectId,
+        claim.projectPath,
+        projectId,
+        options?.projectPath
+      )
+    ).sort((a, b) => b.lastSeenAt - a.lastSeenAt);
+  }
+  async listActiveProjectPaths() {
+    await this.initialize();
+    const projectPaths = /* @__PURE__ */ new Set();
+    const sessions = await this.listSessions();
+    for (const session of sessions) {
+      if (session.status === "active" && session.projectPath) {
+        projectPaths.add(session.projectPath);
+      }
+    }
+    const instances = await this.listInstances();
+    for (const instance of instances) {
+      if (instance.status === "active" && instance.projectPath) {
+        projectPaths.add(instance.projectPath);
+      }
+    }
+    const pullRequests = await this.listGitHubPullRequests();
+    for (const projection of pullRequests) {
+      if (projection.projectPath) {
+        projectPaths.add(projection.projectPath);
+      }
+    }
+    return Array.from(projectPaths).sort();
+  }
+  async getGitHubPullRequest(options) {
+    await this.initialize();
+    return this.readJsonFile(
+      this.getGitHubPullRequestFile(options.repo, options.branch)
+    );
+  }
+  async listGitHubPullRequests(options) {
+    await this.initialize();
+    const projectId = normalizeProjectId(
+      options?.projectId,
+      options?.projectPath
+    );
+    const dir = this.getGithubDir();
+    const entries = await fs.readdir(dir);
+    const records = await Promise.all(
+      entries.filter((entry) => entry.endsWith(".json")).map(
+        (entry) => this.readJsonFile(path.join(dir, entry))
+      )
+    );
+    return records.filter(Boolean).filter(
+      (record) => !projectId || this.matchesProject(
+        record.projectId,
+        record.projectPath,
+        projectId,
+        options?.projectPath
+      )
+    );
+  }
+  async appendEvent(input) {
+    await this.initialize();
+    const event = {
+      id: input.id || randomUUID(),
+      timestamp: input.timestamp || Date.now(),
+      type: input.type,
+      tool: input.tool,
+      instanceId: input.instanceId,
+      sessionId: input.sessionId,
+      projectId: normalizeProjectId(input.projectId, input.projectPath),
+      projectPath: input.projectPath,
+      branch: input.branch,
+      payload: input.payload || {}
+    };
+    const date = new Date(event.timestamp).toISOString().slice(0, 10);
+    const eventFile = path.join(this.getEventsDir(), `${date}.jsonl`);
+    await fs.appendFile(eventFile, `${JSON.stringify(event)}
+`, "utf8");
+    if (event.instanceId) {
+      const instance = await this.readJsonFile(
+        this.getInstanceFile(event.instanceId)
+      );
+      if (instance) {
+        await this.upsertInstance({
+          ...instance,
+          lastSeenAt: event.timestamp
+        });
+      }
+    }
+    if (event.sessionId) {
+      const session = await this.readJsonFile(
+        this.getSessionFile(event.sessionId)
+      );
+      if (session) {
+        await this.upsertSession({
+          ...session,
+          lastSeenAt: event.timestamp,
+          instanceIds: session.instanceIds
+        });
+      }
+    }
+    return event;
+  }
+  async listSessions() {
+    await this.initialize();
+    const dir = this.getSessionsDir();
+    const entries = await fs.readdir(dir);
+    const sessions = await Promise.all(
+      entries.filter((entry) => entry.endsWith(".json")).map(
+        (entry) => this.readJsonFile(path.join(dir, entry))
+      )
+    );
+    return sessions.filter(Boolean);
+  }
+  async listInstances() {
+    await this.initialize();
+    const dir = this.getInstancesDir();
+    const entries = await fs.readdir(dir);
+    const instances = await Promise.all(
+      entries.filter((entry) => entry.endsWith(".json")).map(
+        (entry) => this.readJsonFile(path.join(dir, entry))
+      )
+    );
+    return instances.filter(Boolean);
+  }
+  async getProjectSummary(options) {
+    await this.initialize();
+    const projectId = normalizeProjectId(
+      options.projectId,
+      options.projectPath
+    );
+    const sessions = (await this.listSessions()).filter(
+      (session) => session.status === "active" && this.matchesProject(
+        session.projectId,
+        session.projectPath,
+        projectId,
+        options.projectPath
+      )
+    );
+    const instances = (await this.listInstances()).filter(
+      (instance) => instance.status === "active" && this.matchesProject(
+        instance.projectId,
+        instance.projectPath,
+        projectId,
+        options.projectPath
+      )
+    );
+    const activeClaims = await this.listPathClaims({
+      projectId,
+      projectPath: options.projectPath,
+      activeOnly: true
+    });
+    const recentEvents = await this.listRecentEvents({
+      projectId,
+      projectPath: options.projectPath,
+      limit: options.eventLimit || 10
+    });
+    return {
+      projectId,
+      projectPath: options.projectPath,
+      activeSessions: sessions.sort((a, b) => b.lastSeenAt - a.lastSeenAt),
+      activeInstances: instances.sort((a, b) => b.lastSeenAt - a.lastSeenAt),
+      activeClaims,
+      recentEvents
+    };
+  }
+  async cleanupExpiredClaims() {
+    const dir = this.getClaimsDir();
+    const entries = await fs.readdir(dir).catch(() => []);
+    const now = Date.now();
+    for (const entry of entries) {
+      if (!entry.endsWith(".json")) {
+        continue;
+      }
+      const filePath = path.join(dir, entry);
+      const claim = await this.readJsonFile(filePath);
+      if (!claim || claim.status !== "active" || claim.expiresAt > now) {
+        continue;
+      }
+      await this.writeJsonFile(filePath, {
+        ...claim,
+        status: "expired",
+        releasedAt: now,
+        releaseReason: claim.releaseReason || "expired",
+        lastSeenAt: now
+      });
+    }
+  }
+  claimsOverlap(left, right) {
+    if (left.branch && right.branch && left.branch.trim() && right.branch.trim() && left.branch === right.branch) {
+      return true;
+    }
+    for (const leftPath of left.paths) {
+      for (const rightPath of right.paths) {
+        if (this.pathsOverlap(leftPath, rightPath)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  pathsOverlap(left, right) {
+    const normalizedLeft = this.normalizeClaimPath(left);
+    const normalizedRight = this.normalizeClaimPath(right);
+    if (!normalizedLeft || !normalizedRight) {
+      return false;
+    }
+    if (normalizedLeft === "*" || normalizedRight === "*" || normalizedLeft === "." || normalizedRight === ".") {
+      return true;
+    }
+    if (normalizedLeft === normalizedRight) {
+      return true;
+    }
+    return normalizedLeft.startsWith(`${normalizedRight}/`) || normalizedRight.startsWith(`${normalizedLeft}/`);
+  }
+  normalizeClaimPath(value) {
+    return value.trim().replace(/\\/g, "/").replace(/\/\*\*$/, "").replace(/\/$/, "");
+  }
+  async listRecentEvents(options) {
+    await this.initialize();
+    const projectId = normalizeProjectId(
+      options.projectId,
+      options.projectPath
+    );
+    const eventDir = this.getEventsDir();
+    const eventFiles = (await fs.readdir(eventDir)).filter((entry) => entry.endsWith(".jsonl")).sort().reverse().slice(0, 7);
+    const events = [];
+    for (const entry of eventFiles) {
+      const filePath = path.join(eventDir, entry);
+      const content = await fs.readFile(filePath, "utf8");
+      const lines = content.split("\n").map((line) => line.trim()).filter(Boolean);
+      for (let i = lines.length - 1; i >= 0; i--) {
+        try {
+          const parsed = JSON.parse(lines[i]);
+          if (this.matchesProject(
+            parsed.projectId,
+            parsed.projectPath,
+            projectId,
+            options.projectPath
+          )) {
+            events.push(parsed);
+          }
+        } catch {
+        }
+        if (events.length >= (options.limit || 20)) {
+          return events;
+        }
+      }
+    }
+    return events;
+  }
+  matchesProject(candidateProjectId, candidateProjectPath, projectId, projectPath) {
+    if (projectId && candidateProjectId) {
+      return candidateProjectId === projectId;
+    }
+    if (projectPath && candidateProjectPath) {
+      return candidateProjectPath === projectPath;
+    }
+    return !projectId && !projectPath;
+  }
+  getInstancesDir() {
+    return path.join(this.rootDir, "instances");
+  }
+  getSessionsDir() {
+    return path.join(this.rootDir, "sessions");
+  }
+  getEventsDir() {
+    return path.join(this.rootDir, "events");
+  }
+  getGithubDir() {
+    return path.join(this.rootDir, "github", "pull-requests");
+  }
+  getClaimsDir() {
+    return path.join(this.rootDir, "claims");
+  }
+  getInstanceFile(instanceId) {
+    return path.join(this.getInstancesDir(), `${instanceId}.json`);
+  }
+  getSessionFile(sessionId) {
+    return path.join(this.getSessionsDir(), `${sessionId}.json`);
+  }
+  getGitHubPullRequestFile(repo, branch) {
+    const slug = `${repo}__${branch}`.replace(/[\\/]/g, "__").replace(/[^a-zA-Z0-9_.-]/g, "-");
+    return path.join(this.getGithubDir(), `${slug}.json`);
+  }
+  getClaimFile(claimId) {
+    return path.join(this.getClaimsDir(), `${claimId}.json`);
+  }
+  async readJsonFile(filePath) {
+    if (!await pathExists(filePath)) {
+      return null;
+    }
+    const content = await fs.readFile(filePath, "utf8");
+    return JSON.parse(content);
+  }
+  async writeJsonFile(filePath, value) {
+    const dir = path.dirname(filePath);
+    await fs.mkdir(dir, { recursive: true });
+    const tempPath = `${filePath}.${process.pid}.tmp`;
+    await fs.writeFile(tempPath, JSON.stringify(value, null, 2));
+    await fs.rename(tempPath, filePath);
+  }
+}
+const canonicalStateStore = new CanonicalStateStore();
+export {
+  CanonicalStateStore,
+  canonicalStateStore,
+  getBaseStateDir as getCanonicalStateBaseDir,
+  normalizeProjectId,
+  projectIdFromIdentifier
+};

package/dist/src/core/skill-packs/index.js

@@ -0,0 +1,18 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+export * from "./types.js";
+import { parsePackYaml, loadPackFromDir } from "./parser.js";
+import {
+  SkillPackRegistry,
+  getSkillPackRegistry,
+  resetSkillPackRegistry
+} from "./registry.js";
+export {
+  SkillPackRegistry,
+  getSkillPackRegistry,
+  loadPackFromDir,
+  parsePackYaml,
+  resetSkillPackRegistry
+};

package/dist/src/core/skill-packs/parser.js

@@ -0,0 +1,42 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import * as fs from "fs";
+import * as path from "path";
+import * as yaml from "js-yaml";
+import { SkillPackManifestSchema } from "./types.js";
+import { logger } from "../monitoring/logger.js";
+function parsePackYaml(content) {
+  const raw = yaml.load(content);
+  const manifest = SkillPackManifestSchema.parse(raw);
+  const instructions = manifest.instructions;
+  return { manifest, instructions };
+}
+async function loadPackFromDir(dir) {
+  const yamlPath = path.join(dir, "pack.yaml");
+  if (!fs.existsSync(yamlPath)) {
+    throw new Error(`pack.yaml not found in ${dir}`);
+  }
+  const content = fs.readFileSync(yamlPath, "utf-8");
+  const pack = parsePackYaml(content);
+  if (pack.manifest.instructions?.endsWith(".md")) {
+    const instrPath = path.join(dir, pack.manifest.instructions);
+    if (fs.existsSync(instrPath)) {
+      pack.instructions = fs.readFileSync(instrPath, "utf-8");
+      logger.debug(
+        `Loaded instructions from ${instrPath} for pack ${pack.manifest.name}`
+      );
+    } else {
+      logger.warn(
+        `Instructions file ${instrPath} referenced but not found for pack ${pack.manifest.name}`
+      );
+      pack.instructions = void 0;
+    }
+  }
+  return pack;
+}
+export {
+  loadPackFromDir,
+  parsePackYaml
+};