@stackmemoryai/stackmemory 0.2.9 → 0.3.0

package/dist/integrations/linear/sync.js

@@ -0,0 +1,565 @@
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { join } from "path";
+import { logger } from "../../core/monitoring/logger.js";
+import { LinearClient } from "./client.js";
+class LinearSyncEngine {
+  taskStore;
+  linearClient;
+  authManager;
+  config;
+  mappings = /* @__PURE__ */ new Map();
+  projectRoot;
+  mappingsPath;
+  constructor(taskStore, authManager, config, projectRoot) {
+    this.taskStore = taskStore;
+    this.authManager = authManager;
+    this.config = config;
+    this.projectRoot = projectRoot || process.cwd();
+    this.mappingsPath = join(
+      this.projectRoot,
+      ".stackmemory",
+      "linear-mappings.json"
+    );
+    const apiKey = process.env.LINEAR_API_KEY;
+    if (apiKey) {
+      this.linearClient = new LinearClient({
+        apiKey
+      });
+    } else {
+      const tokens = this.authManager.loadTokens();
+      if (!tokens) {
+        throw new Error(
+          'Linear API key or authentication tokens not found. Set LINEAR_API_KEY environment variable or run "stackmemory linear setup" first.'
+        );
+      }
+      this.linearClient = new LinearClient({
+        apiKey: tokens.accessToken
+      });
+    }
+    this.loadMappings();
+  }
+  /**
+   * Update sync configuration
+   */
+  updateConfig(newConfig) {
+    this.config = { ...this.config, ...newConfig };
+  }
+  /**
+   * Perform bi-directional sync
+   */
+  async sync() {
+    if (!this.config.enabled) {
+      return {
+        success: false,
+        synced: { toLinear: 0, fromLinear: 0, updated: 0 },
+        conflicts: [],
+        errors: ["Sync is disabled"]
+      };
+    }
+    const result = {
+      success: true,
+      synced: { toLinear: 0, fromLinear: 0, updated: 0 },
+      conflicts: [],
+      errors: []
+    };
+    try {
+      const apiKey = process.env.LINEAR_API_KEY;
+      if (!apiKey) {
+        const token = await this.authManager.getValidToken();
+        this.linearClient = new LinearClient({ apiKey: token });
+      }
+      if (!this.config.defaultTeamId) {
+        const team = await this.linearClient.getTeam();
+        this.config.defaultTeamId = team.id;
+        logger.info(`Using Linear team: ${team.name} (${team.key})`);
+      }
+      if (this.config.direction === "bidirectional" || this.config.direction === "to_linear") {
+        const toLinearResult = await this.syncToLinear();
+        result.synced.toLinear = toLinearResult.created;
+        result.synced.updated += toLinearResult.updated;
+        result.errors.push(...toLinearResult.errors);
+      }
+      if (this.config.direction === "bidirectional" || this.config.direction === "from_linear") {
+        const fromLinearResult = await this.syncFromLinear();
+        result.synced.fromLinear = fromLinearResult.created;
+        result.synced.updated += fromLinearResult.updated;
+        result.conflicts.push(...fromLinearResult.conflicts);
+        result.errors.push(...fromLinearResult.errors);
+      }
+      this.saveMappings();
+    } catch (error) {
+      result.success = false;
+      result.errors.push(`Sync failed: ${String(error)}`);
+      logger.error("Linear sync failed:", error);
+    }
+    return result;
+  }
+  /**
+   * Delay helper for rate limiting
+   */
+  async delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Sync tasks from StackMemory to Linear
+   */
+  async syncToLinear() {
+    const result = { created: 0, updated: 0, errors: [] };
+    const maxBatchSize = this.config.maxBatchSize || 10;
+    const rateLimitDelay = this.config.rateLimitDelay || 500;
+    const unsyncedTasks = this.getUnsyncedTasks();
+    const tasksToSync = unsyncedTasks.slice(0, maxBatchSize);
+    if (unsyncedTasks.length > maxBatchSize) {
+      logger.info(
+        `Syncing ${tasksToSync.length} of ${unsyncedTasks.length} unsynced tasks (batch limit)`
+      );
+    }
+    for (const task of tasksToSync) {
+      try {
+        const linearIssue = await this.createLinearIssueFromTask(task);
+        const mapping = {
+          stackmemoryId: task.id,
+          linearId: linearIssue.id,
+          linearIdentifier: linearIssue.identifier,
+          lastSyncTimestamp: Date.now(),
+          lastLinearUpdate: linearIssue.updatedAt,
+          lastStackMemoryUpdate: task.timestamp * 1e3
+        };
+        this.mappings.set(task.id, mapping);
+        this.updateTaskWithLinearRef(task.id, linearIssue);
+        result.created++;
+        logger.info(
+          `Synced task to Linear: ${task.title} \u2192 ${linearIssue.identifier}`
+        );
+        await this.delay(rateLimitDelay);
+      } catch (error) {
+        const errorMsg = String(error);
+        if (errorMsg.includes("rate limit") || errorMsg.includes("usage limit")) {
+          logger.warn("Rate limit hit, stopping sync batch");
+          result.errors.push("Rate limit reached - sync paused");
+          break;
+        }
+        result.errors.push(`Failed to sync task ${task.id}: ${errorMsg}`);
+        logger.error(
+          `Failed to sync task ${task.id} to Linear:`,
+          error
+        );
+      }
+    }
+    const modifiedTasks = this.getModifiedTasks();
+    for (const task of modifiedTasks) {
+      try {
+        const mapping = this.mappings.get(task.id);
+        if (!mapping) continue;
+        await this.updateLinearIssueFromTask(task, mapping);
+        mapping.lastSyncTimestamp = Date.now();
+        mapping.lastStackMemoryUpdate = task.timestamp * 1e3;
+        result.updated++;
+        logger.info(`Updated Linear issue: ${mapping.linearIdentifier}`);
+      } catch (error) {
+        result.errors.push(
+          `Failed to update Linear issue for task ${task.id}: ${String(error)}`
+        );
+        logger.error(
+          `Failed to update Linear issue for task ${task.id}:`,
+          error
+        );
+      }
+    }
+    return result;
+  }
+  /**
+   * Sync tasks from Linear to StackMemory
+   */
+  async syncFromLinear() {
+    const result = {
+      created: 0,
+      updated: 0,
+      conflicts: [],
+      errors: []
+    };
+    const importResult = await this.importFromLinear();
+    result.created = importResult.imported;
+    result.errors.push(...importResult.errors);
+    for (const [taskId, mapping] of this.mappings) {
+      try {
+        const linearIssue = await this.linearClient.getIssue(mapping.linearId);
+        if (!linearIssue) {
+          result.errors.push(`Linear issue ${mapping.linearId} not found`);
+          continue;
+        }
+        const linearUpdateTime = new Date(linearIssue.updatedAt).getTime();
+        if (linearUpdateTime <= mapping.lastSyncTimestamp) {
+          continue;
+        }
+        const task = this.taskStore.getTask(taskId);
+        if (!task) {
+          result.errors.push(`StackMemory task ${taskId} not found`);
+          continue;
+        }
+        const stackMemoryUpdateTime = task.timestamp * 1e3;
+        if (stackMemoryUpdateTime > mapping.lastSyncTimestamp && linearUpdateTime > mapping.lastSyncTimestamp) {
+          result.conflicts.push({
+            taskId,
+            linearId: mapping.linearId,
+            reason: "Both StackMemory and Linear were updated since last sync"
+          });
+          if (this.config.conflictResolution === "manual") {
+            continue;
+          }
+        }
+        const shouldUpdateFromLinear = this.shouldUpdateFromLinear(
+          task,
+          linearIssue,
+          mapping,
+          stackMemoryUpdateTime,
+          linearUpdateTime
+        );
+        if (shouldUpdateFromLinear) {
+          this.updateTaskFromLinearIssue(task, linearIssue);
+          mapping.lastSyncTimestamp = Date.now();
+          mapping.lastLinearUpdate = linearIssue.updatedAt;
+          result.updated++;
+          logger.info(`Updated StackMemory task from Linear: ${task.title}`);
+        }
+      } catch (error) {
+        result.errors.push(
+          `Failed to sync from Linear for task ${taskId}: ${String(error)}`
+        );
+        logger.error(
+          `Failed to sync from Linear for task ${taskId}:`,
+          error
+        );
+      }
+    }
+    return result;
+  }
+  /**
+   * Create Linear issue from StackMemory task
+   */
+  async createLinearIssueFromTask(task) {
+    const input = {
+      title: task.title,
+      description: this.formatDescriptionForLinear(task),
+      teamId: this.config.defaultTeamId,
+      priority: this.mapPriorityToLinear(task.priority),
+      estimate: task.estimated_effort ? Math.ceil(task.estimated_effort / 60) : void 0,
+      // Convert minutes to hours
+      labelIds: this.mapTagsToLinear(task.tags)
+    };
+    return await this.linearClient.createIssue(input);
+  }
+  /**
+   * Update Linear issue from StackMemory task
+   */
+  async updateLinearIssueFromTask(task, mapping) {
+    const updates = {
+      title: task.title,
+      description: this.formatDescriptionForLinear(task),
+      priority: this.mapPriorityToLinear(task.priority),
+      estimate: task.estimated_effort ? Math.ceil(task.estimated_effort / 60) : void 0,
+      stateId: await this.mapStatusToLinearState(task.status)
+    };
+    await this.linearClient.updateIssue(mapping.linearId, updates);
+  }
+  /**
+   * Update StackMemory task from Linear issue
+   */
+  updateTaskFromLinearIssue(task, linearIssue) {
+    const newStatus = this.mapLinearStateToStatus(linearIssue.state.type);
+    if (newStatus !== task.status) {
+      this.taskStore.updateTaskStatus(
+        task.id,
+        newStatus,
+        "Updated from Linear"
+      );
+    }
+  }
+  /**
+   * Check if task should be updated from Linear based on conflict resolution strategy
+   */
+  shouldUpdateFromLinear(task, linearIssue, mapping, stackMemoryUpdateTime, linearUpdateTime) {
+    switch (this.config.conflictResolution) {
+      case "linear_wins":
+        return true;
+      case "stackmemory_wins":
+        return false;
+      case "newest_wins":
+        return linearUpdateTime > stackMemoryUpdateTime;
+      case "manual":
+        return false;
+      default:
+        return false;
+    }
+  }
+  /**
+   * Get tasks that haven't been synced to Linear yet
+   */
+  getUnsyncedTasks() {
+    const activeTasks = this.taskStore.getActiveTasks();
+    return activeTasks.filter(
+      (task) => !this.mappings.has(task.id) && !task.external_refs?.linear
+    );
+  }
+  /**
+   * Get tasks that have been modified since last sync
+   */
+  getModifiedTasks() {
+    const tasks = [];
+    for (const [taskId, mapping] of this.mappings) {
+      const task = this.taskStore.getTask(taskId);
+      if (task && task.timestamp * 1e3 > mapping.lastSyncTimestamp) {
+        tasks.push(task);
+      }
+    }
+    return tasks;
+  }
+  /**
+   * Update task with Linear reference
+   */
+  updateTaskWithLinearRef(taskId, linearIssue) {
+    const task = this.taskStore.getTask(taskId);
+    if (!task) return;
+    logger.info(`Task ${taskId} mapped to Linear ${linearIssue.identifier}`);
+  }
+  // Mapping utilities
+  formatDescriptionForLinear(task) {
+    let description = task.description || "";
+    description += `
+
+---
+**StackMemory Context:**
+`;
+    description += `- Task ID: ${task.id}
+`;
+    description += `- Frame: ${task.frame_id}
+`;
+    description += `- Created: ${new Date(task.created_at * 1e3).toISOString()}
+`;
+    if (task.tags.length > 0) {
+      description += `- Tags: ${task.tags.join(", ")}
+`;
+    }
+    if (task.depends_on.length > 0) {
+      description += `- Dependencies: ${task.depends_on.join(", ")}
+`;
+    }
+    return description;
+  }
+  mapPriorityToLinear(priority) {
+    const map = {
+      low: 1,
+      // Low priority in Linear
+      medium: 2,
+      // Medium priority in Linear
+      high: 3,
+      // High priority in Linear
+      urgent: 4
+      // Urgent priority in Linear
+    };
+    return map[priority] || 2;
+  }
+  mapTagsToLinear(_tags) {
+    return void 0;
+  }
+  mapLinearStateToStatus(linearStateType) {
+    switch (linearStateType) {
+      case "backlog":
+      case "unstarted":
+        return "pending";
+      case "started":
+        return "in_progress";
+      case "completed":
+        return "completed";
+      case "cancelled":
+        return "cancelled";
+      default:
+        return "pending";
+    }
+  }
+  async mapStatusToLinearState(status) {
+    try {
+      const team = await this.linearClient.getTeam();
+      const states = await this.linearClient.getWorkflowStates(team.id);
+      const targetStateType = this.getLinearStateTypeFromStatus(status);
+      const matchingState = states.find(
+        (state) => state.type === targetStateType
+      );
+      return matchingState?.id;
+    } catch (error) {
+      logger.warn(
+        "Failed to map status to Linear state:",
+        error instanceof Error ? { error } : void 0
+      );
+      return void 0;
+    }
+  }
+  getLinearStateTypeFromStatus(status) {
+    switch (status) {
+      case "pending":
+        return "unstarted";
+      case "in_progress":
+        return "started";
+      case "completed":
+        return "completed";
+      case "cancelled":
+        return "cancelled";
+      case "blocked":
+        return "unstarted";
+      // Map blocked to unstarted in Linear
+      default:
+        return "unstarted";
+    }
+  }
+  // Persistence for mappings
+  loadMappings() {
+    this.mappings.clear();
+    if (existsSync(this.mappingsPath)) {
+      try {
+        const data = readFileSync(this.mappingsPath, "utf8");
+        const mappingsArray = JSON.parse(data);
+        for (const mapping of mappingsArray) {
+          this.mappings.set(mapping.stackmemoryId, mapping);
+        }
+        logger.info(`Loaded ${this.mappings.size} task mappings from disk`);
+      } catch (error) {
+        logger.warn("Failed to load mappings, starting fresh");
+      }
+    }
+  }
+  saveMappings() {
+    try {
+      const mappingsArray = Array.from(this.mappings.values());
+      writeFileSync(this.mappingsPath, JSON.stringify(mappingsArray, null, 2));
+      logger.info(`Saved ${this.mappings.size} task mappings to disk`);
+    } catch (error) {
+      logger.error("Failed to save mappings:", error);
+    }
+  }
+  /**
+   * Import all issues from Linear to local task store
+   */
+  async importFromLinear() {
+    const result = { imported: 0, skipped: 0, errors: [] };
+    try {
+      if (!this.config.defaultTeamId) {
+        const team = await this.linearClient.getTeam();
+        this.config.defaultTeamId = team.id;
+        logger.info(`Using Linear team: ${team.name} (${team.key})`);
+      }
+      const issues = await this.linearClient.getIssues({
+        teamId: this.config.defaultTeamId,
+        limit: 100
+      });
+      logger.info(`Found ${issues.length} issues in Linear`);
+      const linearIdToTaskId = /* @__PURE__ */ new Map();
+      for (const [taskId, mapping] of this.mappings) {
+        linearIdToTaskId.set(mapping.linearId, taskId);
+      }
+      for (const issue of issues) {
+        try {
+          if (linearIdToTaskId.has(issue.id)) {
+            result.skipped++;
+            continue;
+          }
+          const taskId = await this.createTaskFromLinearIssue(issue);
+          if (taskId) {
+            const mapping = {
+              stackmemoryId: taskId,
+              linearId: issue.id,
+              linearIdentifier: issue.identifier,
+              lastSyncTimestamp: Date.now(),
+              lastLinearUpdate: issue.updatedAt,
+              lastStackMemoryUpdate: Date.now()
+            };
+            this.mappings.set(taskId, mapping);
+            result.imported++;
+            logger.info(`Imported ${issue.identifier}: ${issue.title}`);
+          }
+        } catch (error) {
+          result.errors.push(
+            `Failed to import ${issue.identifier}: ${String(error)}`
+          );
+          logger.error(`Failed to import ${issue.identifier}:`, error);
+        }
+      }
+      this.saveMappings();
+    } catch (error) {
+      result.errors.push(`Import failed: ${String(error)}`);
+      logger.error("Linear import failed:", error);
+    }
+    return result;
+  }
+  /**
+   * Create a local task from a Linear issue
+   */
+  async createTaskFromLinearIssue(issue) {
+    try {
+      const priority = this.mapLinearPriorityToLocal(issue.priority);
+      let description = issue.description || "";
+      description += `
+
+---
+**Linear:** ${issue.identifier} | ${issue.url}`;
+      const labels = Array.isArray(issue.labels) ? issue.labels : issue.labels?.nodes || [];
+      const tags = labels.map((l) => l.name);
+      if (tags.length === 0) tags.push("linear");
+      const taskId = this.taskStore.createTask({
+        title: `[${issue.identifier}] ${issue.title}`,
+        description,
+        priority,
+        frameId: "linear-import",
+        tags,
+        estimatedEffort: issue.estimate ? issue.estimate * 60 : void 0
+      });
+      const status = this.mapLinearStateToStatus(issue.state.type);
+      if (status !== "pending") {
+        this.taskStore.updateTaskStatus(
+          taskId,
+          status,
+          `Imported from Linear as ${status}`
+        );
+      }
+      return taskId;
+    } catch (error) {
+      logger.error(
+        `Failed to create task from Linear issue ${issue.identifier}: ${String(error)}`
+      );
+      return null;
+    }
+  }
+  /**
+   * Map Linear priority (0-4) to local TaskPriority
+   */
+  mapLinearPriorityToLocal(priority) {
+    switch (priority) {
+      case 1:
+        return "urgent";
+      case 2:
+        return "high";
+      case 3:
+        return "medium";
+      case 4:
+        return "low";
+      default:
+        return "medium";
+    }
+  }
+}
+const DEFAULT_SYNC_CONFIG = {
+  enabled: false,
+  direction: "bidirectional",
+  autoSync: true,
+  conflictResolution: "newest_wins",
+  syncInterval: 15,
+  // minutes
+  maxBatchSize: 10,
+  // max tasks per sync batch
+  rateLimitDelay: 500
+  // 500ms between API calls
+};
+export {
+  DEFAULT_SYNC_CONFIG,
+  LinearSyncEngine
+};
+//# sourceMappingURL=sync.js.map

package/dist/integrations/linear/sync.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/integrations/linear/sync.ts"],
+  "sourcesContent": ["/**\n * Linear Bi-directional Sync Engine\n * Handles syncing tasks between StackMemory and Linear\n */\n\nimport { readFileSync, writeFileSync, existsSync } from 'fs';\nimport { join } from 'path';\nimport { logger } from '../../core/monitoring/logger.js';\nimport {\n  PebblesTask,\n  PebblesTaskStore,\n  TaskStatus,\n  TaskPriority,\n} from '../../features/tasks/pebbles-task-store.js';\nimport { LinearClient, LinearIssue, LinearCreateIssueInput } from './client.js';\nimport { LinearAuthManager } from './auth.js';\n\nexport interface SyncConfig {\n  enabled: boolean;\n  direction: 'bidirectional' | 'to_linear' | 'from_linear';\n  defaultTeamId?: string;\n  autoSync: boolean;\n  conflictResolution:\n    | 'linear_wins'\n    | 'stackmemory_wins'\n    | 'manual'\n    | 'newest_wins';\n  syncInterval?: number; // minutes\n  maxBatchSize?: number; // max tasks to sync per batch\n  rateLimitDelay?: number; // ms delay between API calls\n}\n\nexport interface SyncResult {\n  success: boolean;\n  synced: {\n    toLinear: number;\n    fromLinear: number;\n    updated: number;\n  };\n  conflicts: Array<{\n    taskId: string;\n    linearId: string;\n    reason: string;\n  }>;\n  errors: string[];\n}\n\nexport interface TaskMapping {\n  stackmemoryId: string;\n  linearId: string;\n  linearIdentifier: string;\n  lastSyncTimestamp: number;\n  lastLinearUpdate: string;\n  lastStackMemoryUpdate: number;\n}\n\nexport class LinearSyncEngine {\n  private taskStore: PebblesTaskStore;\n  private linearClient: LinearClient;\n  private authManager: LinearAuthManager;\n  private config: SyncConfig;\n  private mappings: Map<string, TaskMapping> = new Map();\n  private projectRoot: string;\n  private mappingsPath: string;\n\n  constructor(\n    taskStore: PebblesTaskStore,\n    authManager: LinearAuthManager,\n    config: SyncConfig,\n    projectRoot?: string\n  ) {\n    this.taskStore = taskStore;\n    this.authManager = authManager;\n    this.config = config;\n    this.projectRoot = projectRoot || process.cwd();\n    this.mappingsPath = join(\n      this.projectRoot,\n      '.stackmemory',\n      'linear-mappings.json'\n    );\n\n    // Check for API key from environment variable first\n    const apiKey = process.env.LINEAR_API_KEY;\n\n    if (apiKey) {\n      // Use API key from environment\n      this.linearClient = new LinearClient({\n        apiKey: apiKey,\n      });\n    } else {\n      // Fall back to OAuth tokens\n      const tokens = this.authManager.loadTokens();\n      if (!tokens) {\n        throw new Error(\n          'Linear API key or authentication tokens not found. Set LINEAR_API_KEY environment variable or run \"stackmemory linear setup\" first.'\n        );\n      }\n\n      this.linearClient = new LinearClient({\n        apiKey: tokens.accessToken,\n      });\n    }\n\n    this.loadMappings();\n  }\n\n  /**\n   * Update sync configuration\n   */\n  updateConfig(newConfig: Partial<SyncConfig>): void {\n    this.config = { ...this.config, ...newConfig };\n  }\n\n  /**\n   * Perform bi-directional sync\n   */\n  async sync(): Promise<SyncResult> {\n    if (!this.config.enabled) {\n      return {\n        success: false,\n        synced: { toLinear: 0, fromLinear: 0, updated: 0 },\n        conflicts: [],\n        errors: ['Sync is disabled'],\n      };\n    }\n\n    const result: SyncResult = {\n      success: true,\n      synced: { toLinear: 0, fromLinear: 0, updated: 0 },\n      conflicts: [],\n      errors: [],\n    };\n\n    try {\n      // Update client with valid token if not using environment API key\n      const apiKey = process.env.LINEAR_API_KEY;\n      if (!apiKey) {\n        const token = await this.authManager.getValidToken();\n        this.linearClient = new LinearClient({ apiKey: token });\n      }\n\n      // Get team info if not configured\n      if (!this.config.defaultTeamId) {\n        const team = await this.linearClient.getTeam();\n        this.config.defaultTeamId = team.id;\n        logger.info(`Using Linear team: ${team.name} (${team.key})`);\n      }\n\n      // Sync in both directions based on configuration\n      if (\n        this.config.direction === 'bidirectional' ||\n        this.config.direction === 'to_linear'\n      ) {\n        const toLinearResult = await this.syncToLinear();\n        result.synced.toLinear = toLinearResult.created;\n        result.synced.updated += toLinearResult.updated;\n        result.errors.push(...toLinearResult.errors);\n      }\n\n      if (\n        this.config.direction === 'bidirectional' ||\n        this.config.direction === 'from_linear'\n      ) {\n        const fromLinearResult = await this.syncFromLinear();\n        result.synced.fromLinear = fromLinearResult.created;\n        result.synced.updated += fromLinearResult.updated;\n        result.conflicts.push(...fromLinearResult.conflicts);\n        result.errors.push(...fromLinearResult.errors);\n      }\n\n      this.saveMappings();\n    } catch (error) {\n      result.success = false;\n      result.errors.push(`Sync failed: ${String(error)}`);\n      logger.error('Linear sync failed:', error as Error);\n    }\n\n    return result;\n  }\n\n  /**\n   * Delay helper for rate limiting\n   */\n  private async delay(ms: number): Promise<void> {\n    return new Promise((resolve) => setTimeout(resolve, ms));\n  }\n\n  /**\n   * Sync tasks from StackMemory to Linear\n   */\n  private async syncToLinear(): Promise<{\n    created: number;\n    updated: number;\n    errors: string[];\n  }> {\n    const result = { created: 0, updated: 0, errors: [] as string[] };\n    const maxBatchSize = this.config.maxBatchSize || 10;\n    const rateLimitDelay = this.config.rateLimitDelay || 500;\n\n    // Get unsynced tasks from StackMemory\n    const unsyncedTasks = this.getUnsyncedTasks();\n\n    // Limit batch size to avoid rate limits\n    const tasksToSync = unsyncedTasks.slice(0, maxBatchSize);\n\n    if (unsyncedTasks.length > maxBatchSize) {\n      logger.info(\n        `Syncing ${tasksToSync.length} of ${unsyncedTasks.length} unsynced tasks (batch limit)`\n      );\n    }\n\n    for (const task of tasksToSync) {\n      try {\n        const linearIssue = await this.createLinearIssueFromTask(task);\n\n        // Create mapping\n        const mapping: TaskMapping = {\n          stackmemoryId: task.id,\n          linearId: linearIssue.id,\n          linearIdentifier: linearIssue.identifier,\n          lastSyncTimestamp: Date.now(),\n          lastLinearUpdate: linearIssue.updatedAt,\n          lastStackMemoryUpdate: task.timestamp * 1000,\n        };\n\n        this.mappings.set(task.id, mapping);\n\n        // Update task with Linear reference\n        this.updateTaskWithLinearRef(task.id, linearIssue);\n\n        result.created++;\n        logger.info(\n          `Synced task to Linear: ${task.title} \u2192 ${linearIssue.identifier}`\n        );\n\n        // Rate limit delay between creates\n        await this.delay(rateLimitDelay);\n      } catch (error) {\n        const errorMsg = String(error);\n        // Stop syncing on rate limit errors\n        if (\n          errorMsg.includes('rate limit') ||\n          errorMsg.includes('usage limit')\n        ) {\n          logger.warn('Rate limit hit, stopping sync batch');\n          result.errors.push('Rate limit reached - sync paused');\n          break;\n        }\n        result.errors.push(`Failed to sync task ${task.id}: ${errorMsg}`);\n        logger.error(\n          `Failed to sync task ${task.id} to Linear:`,\n          error as Error\n        );\n      }\n    }\n\n    // Update existing Linear issues for modified StackMemory tasks\n    const modifiedTasks = this.getModifiedTasks();\n\n    for (const task of modifiedTasks) {\n      try {\n        const mapping = this.mappings.get(task.id);\n        if (!mapping) continue;\n\n        await this.updateLinearIssueFromTask(task, mapping);\n\n        mapping.lastSyncTimestamp = Date.now();\n        mapping.lastStackMemoryUpdate = task.timestamp * 1000;\n\n        result.updated++;\n        logger.info(`Updated Linear issue: ${mapping.linearIdentifier}`);\n      } catch (error) {\n        result.errors.push(\n          `Failed to update Linear issue for task ${task.id}: ${String(error)}`\n        );\n        logger.error(\n          `Failed to update Linear issue for task ${task.id}:`,\n          error as Error\n        );\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * Sync tasks from Linear to StackMemory\n   */\n  private async syncFromLinear(): Promise<{\n    created: number;\n    updated: number;\n    conflicts: Array<{ taskId: string; linearId: string; reason: string }>;\n    errors: string[];\n  }> {\n    const result = {\n      created: 0,\n      updated: 0,\n      conflicts: [] as Array<{\n        taskId: string;\n        linearId: string;\n        reason: string;\n      }>,\n      errors: [] as string[],\n    };\n\n    // First, import any new issues from Linear that aren't mapped yet\n    const importResult = await this.importFromLinear();\n    result.created = importResult.imported;\n    result.errors.push(...importResult.errors);\n\n    // Then update existing mapped tasks\n    for (const [taskId, mapping] of this.mappings) {\n      try {\n        const linearIssue = await this.linearClient.getIssue(mapping.linearId);\n\n        if (!linearIssue) {\n          result.errors.push(`Linear issue ${mapping.linearId} not found`);\n          continue;\n        }\n\n        // Check if Linear issue was updated since last sync\n        const linearUpdateTime = new Date(linearIssue.updatedAt).getTime();\n        if (linearUpdateTime <= mapping.lastSyncTimestamp) {\n          continue; // No changes in Linear\n        }\n\n        // Check for conflicts\n        const task = this.taskStore.getTask(taskId);\n        if (!task) {\n          result.errors.push(`StackMemory task ${taskId} not found`);\n          continue;\n        }\n\n        const stackMemoryUpdateTime = task.timestamp * 1000;\n\n        if (\n          stackMemoryUpdateTime > mapping.lastSyncTimestamp &&\n          linearUpdateTime > mapping.lastSyncTimestamp\n        ) {\n          // Conflict: both sides updated since last sync\n          result.conflicts.push({\n            taskId,\n            linearId: mapping.linearId,\n            reason: 'Both StackMemory and Linear were updated since last sync',\n          });\n\n          if (this.config.conflictResolution === 'manual') {\n            continue; // Skip, let user resolve manually\n          }\n        }\n\n        // Apply conflict resolution\n        const shouldUpdateFromLinear = this.shouldUpdateFromLinear(\n          task,\n          linearIssue,\n          mapping,\n          stackMemoryUpdateTime,\n          linearUpdateTime\n        );\n\n        if (shouldUpdateFromLinear) {\n          this.updateTaskFromLinearIssue(task, linearIssue);\n\n          mapping.lastSyncTimestamp = Date.now();\n          mapping.lastLinearUpdate = linearIssue.updatedAt;\n\n          result.updated++;\n          logger.info(`Updated StackMemory task from Linear: ${task.title}`);\n        }\n      } catch (error) {\n        result.errors.push(\n          `Failed to sync from Linear for task ${taskId}: ${String(error)}`\n        );\n        logger.error(\n          `Failed to sync from Linear for task ${taskId}:`,\n          error as Error\n        );\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * Create Linear issue from StackMemory task\n   */\n  private async createLinearIssueFromTask(\n    task: PebblesTask\n  ): Promise<LinearIssue> {\n    const input: LinearCreateIssueInput = {\n      title: task.title,\n      description: this.formatDescriptionForLinear(task),\n      teamId: this.config.defaultTeamId!,\n      priority: this.mapPriorityToLinear(task.priority),\n      estimate: task.estimated_effort\n        ? Math.ceil(task.estimated_effort / 60)\n        : undefined, // Convert minutes to hours\n      labelIds: this.mapTagsToLinear(task.tags),\n    };\n\n    return await this.linearClient.createIssue(input);\n  }\n\n  /**\n   * Update Linear issue from StackMemory task\n   */\n  private async updateLinearIssueFromTask(\n    task: PebblesTask,\n    mapping: TaskMapping\n  ): Promise<void> {\n    const updates: Partial<LinearCreateIssueInput> & { stateId?: string } = {\n      title: task.title,\n      description: this.formatDescriptionForLinear(task),\n      priority: this.mapPriorityToLinear(task.priority),\n      estimate: task.estimated_effort\n        ? Math.ceil(task.estimated_effort / 60)\n        : undefined,\n      stateId: await this.mapStatusToLinearState(task.status),\n    };\n\n    await this.linearClient.updateIssue(mapping.linearId, updates);\n  }\n\n  /**\n   * Update StackMemory task from Linear issue\n   */\n  private updateTaskFromLinearIssue(\n    task: PebblesTask,\n    linearIssue: LinearIssue\n  ): void {\n    // Map Linear state to StackMemory status\n    const newStatus = this.mapLinearStateToStatus(linearIssue.state.type);\n\n    if (newStatus !== task.status) {\n      this.taskStore.updateTaskStatus(\n        task.id,\n        newStatus,\n        'Updated from Linear'\n      );\n    }\n\n    // Note: Other fields like title, description could be updated here\n    // but require careful consideration of conflict resolution\n  }\n\n  /**\n   * Check if task should be updated from Linear based on conflict resolution strategy\n   */\n  private shouldUpdateFromLinear(\n    task: PebblesTask,\n    linearIssue: LinearIssue,\n    mapping: TaskMapping,\n    stackMemoryUpdateTime: number,\n    linearUpdateTime: number\n  ): boolean {\n    switch (this.config.conflictResolution) {\n      case 'linear_wins':\n        return true;\n      case 'stackmemory_wins':\n        return false;\n      case 'newest_wins':\n        return linearUpdateTime > stackMemoryUpdateTime;\n      case 'manual':\n        return false;\n      default:\n        return false;\n    }\n  }\n\n  /**\n   * Get tasks that haven't been synced to Linear yet\n   */\n  private getUnsyncedTasks(): PebblesTask[] {\n    const activeTasks = this.taskStore.getActiveTasks();\n    return activeTasks.filter(\n      (task) => !this.mappings.has(task.id) && !task.external_refs?.linear\n    );\n  }\n\n  /**\n   * Get tasks that have been modified since last sync\n   */\n  private getModifiedTasks(): PebblesTask[] {\n    const tasks: PebblesTask[] = [];\n\n    for (const [taskId, mapping] of this.mappings) {\n      const task = this.taskStore.getTask(taskId);\n      if (task && task.timestamp * 1000 > mapping.lastSyncTimestamp) {\n        tasks.push(task);\n      }\n    }\n\n    return tasks;\n  }\n\n  /**\n   * Update task with Linear reference\n   */\n  private updateTaskWithLinearRef(\n    taskId: string,\n    linearIssue: LinearIssue\n  ): void {\n    const task = this.taskStore.getTask(taskId);\n    if (!task) return;\n\n    // This would need a method in PebblesTaskStore to update external_refs\n    // For now, we'll track this in our mappings\n    logger.info(`Task ${taskId} mapped to Linear ${linearIssue.identifier}`);\n  }\n\n  // Mapping utilities\n\n  private formatDescriptionForLinear(task: PebblesTask): string {\n    let description = task.description || '';\n\n    description += `\\n\\n---\\n**StackMemory Context:**\\n`;\n    description += `- Task ID: ${task.id}\\n`;\n    description += `- Frame: ${task.frame_id}\\n`;\n    description += `- Created: ${new Date(task.created_at * 1000).toISOString()}\\n`;\n\n    if (task.tags.length > 0) {\n      description += `- Tags: ${task.tags.join(', ')}\\n`;\n    }\n\n    if (task.depends_on.length > 0) {\n      description += `- Dependencies: ${task.depends_on.join(', ')}\\n`;\n    }\n\n    return description;\n  }\n\n  private mapPriorityToLinear(priority: TaskPriority): number {\n    const map: Record<TaskPriority, number> = {\n      low: 1, // Low priority in Linear\n      medium: 2, // Medium priority in Linear\n      high: 3, // High priority in Linear\n      urgent: 4, // Urgent priority in Linear\n    };\n    return map[priority] || 2;\n  }\n\n  private mapTagsToLinear(_tags: string[]): string[] | undefined {\n    // In a full implementation, this would map StackMemory tags to Linear label IDs\n    // For now, return undefined to skip label assignment\n    return undefined;\n  }\n\n  private mapLinearStateToStatus(linearStateType: string): TaskStatus {\n    switch (linearStateType) {\n      case 'backlog':\n      case 'unstarted':\n        return 'pending';\n      case 'started':\n        return 'in_progress';\n      case 'completed':\n        return 'completed';\n      case 'cancelled':\n        return 'cancelled';\n      default:\n        return 'pending';\n    }\n  }\n\n  private async mapStatusToLinearState(\n    status: TaskStatus\n  ): Promise<string | undefined> {\n    // Get available states for the team\n    try {\n      const team = await this.linearClient.getTeam();\n      const states = await this.linearClient.getWorkflowStates(team.id);\n\n      // Map StackMemory status to Linear state types\n      const targetStateType = this.getLinearStateTypeFromStatus(status);\n\n      // Find the first state that matches the target type\n      const matchingState = states.find(\n        (state) => state.type === targetStateType\n      );\n      return matchingState?.id;\n    } catch (error) {\n      logger.warn(\n        'Failed to map status to Linear state:',\n        error instanceof Error ? { error } : undefined\n      );\n      return undefined;\n    }\n  }\n\n  private getLinearStateTypeFromStatus(status: TaskStatus): string {\n    switch (status) {\n      case 'pending':\n        return 'unstarted';\n      case 'in_progress':\n        return 'started';\n      case 'completed':\n        return 'completed';\n      case 'cancelled':\n        return 'cancelled';\n      case 'blocked':\n        return 'unstarted'; // Map blocked to unstarted in Linear\n      default:\n        return 'unstarted';\n    }\n  }\n\n  // Persistence for mappings\n\n  private loadMappings(): void {\n    this.mappings.clear();\n\n    if (existsSync(this.mappingsPath)) {\n      try {\n        const data = readFileSync(this.mappingsPath, 'utf8');\n        const mappingsArray: TaskMapping[] = JSON.parse(data);\n        for (const mapping of mappingsArray) {\n          this.mappings.set(mapping.stackmemoryId, mapping);\n        }\n        logger.info(`Loaded ${this.mappings.size} task mappings from disk`);\n      } catch (error) {\n        logger.warn('Failed to load mappings, starting fresh');\n      }\n    }\n  }\n\n  private saveMappings(): void {\n    try {\n      const mappingsArray = Array.from(this.mappings.values());\n      writeFileSync(this.mappingsPath, JSON.stringify(mappingsArray, null, 2));\n      logger.info(`Saved ${this.mappings.size} task mappings to disk`);\n    } catch (error) {\n      logger.error('Failed to save mappings:', error as Error);\n    }\n  }\n\n  /**\n   * Import all issues from Linear to local task store\n   */\n  async importFromLinear(): Promise<{\n    imported: number;\n    skipped: number;\n    errors: string[];\n  }> {\n    const result = { imported: 0, skipped: 0, errors: [] as string[] };\n\n    try {\n      // Get team info\n      if (!this.config.defaultTeamId) {\n        const team = await this.linearClient.getTeam();\n        this.config.defaultTeamId = team.id;\n        logger.info(`Using Linear team: ${team.name} (${team.key})`);\n      }\n\n      // Fetch all issues from Linear (excluding completed/cancelled)\n      const issues = await this.linearClient.getIssues({\n        teamId: this.config.defaultTeamId,\n        limit: 100,\n      });\n\n      logger.info(`Found ${issues.length} issues in Linear`);\n\n      // Build reverse mapping (linearId -> stackmemoryId)\n      const linearIdToTaskId = new Map<string, string>();\n      for (const [taskId, mapping] of this.mappings) {\n        linearIdToTaskId.set(mapping.linearId, taskId);\n      }\n\n      for (const issue of issues) {\n        try {\n          // Skip if already mapped\n          if (linearIdToTaskId.has(issue.id)) {\n            result.skipped++;\n            continue;\n          }\n\n          // Create local task from Linear issue\n          const taskId = await this.createTaskFromLinearIssue(issue);\n\n          if (taskId) {\n            // Create mapping\n            const mapping: TaskMapping = {\n              stackmemoryId: taskId,\n              linearId: issue.id,\n              linearIdentifier: issue.identifier,\n              lastSyncTimestamp: Date.now(),\n              lastLinearUpdate: issue.updatedAt,\n              lastStackMemoryUpdate: Date.now(),\n            };\n            this.mappings.set(taskId, mapping);\n            result.imported++;\n            logger.info(`Imported ${issue.identifier}: ${issue.title}`);\n          }\n        } catch (error) {\n          result.errors.push(\n            `Failed to import ${issue.identifier}: ${String(error)}`\n          );\n          logger.error(`Failed to import ${issue.identifier}:`, error as Error);\n        }\n      }\n\n      this.saveMappings();\n    } catch (error) {\n      result.errors.push(`Import failed: ${String(error)}`);\n      logger.error('Linear import failed:', error as Error);\n    }\n\n    return result;\n  }\n\n  /**\n   * Create a local task from a Linear issue\n   */\n  private async createTaskFromLinearIssue(\n    issue: LinearIssue\n  ): Promise<string | null> {\n    try {\n      const priority = this.mapLinearPriorityToLocal(issue.priority);\n\n      // Build description with Linear context\n      let description = issue.description || '';\n      description += `\\n\\n---\\n**Linear:** ${issue.identifier} | ${issue.url}`;\n\n      // Extract labels (handle both array and {nodes: [...]} formats)\n      const labels = Array.isArray(issue.labels)\n        ? issue.labels\n        : (issue.labels as unknown as { nodes: Array<{ name: string }> })\n            ?.nodes || [];\n      const tags = labels.map((l) => l.name);\n      if (tags.length === 0) tags.push('linear');\n\n      // Create the task via the task store\n      const taskId = this.taskStore.createTask({\n        title: `[${issue.identifier}] ${issue.title}`,\n        description,\n        priority,\n        frameId: 'linear-import',\n        tags,\n        estimatedEffort: issue.estimate ? issue.estimate * 60 : undefined,\n      });\n\n      // Update status if not pending\n      const status = this.mapLinearStateToStatus(issue.state.type);\n      if (status !== 'pending') {\n        this.taskStore.updateTaskStatus(\n          taskId,\n          status,\n          `Imported from Linear as ${status}`\n        );\n      }\n\n      return taskId;\n    } catch (error) {\n      logger.error(\n        `Failed to create task from Linear issue ${issue.identifier}: ${String(error)}`\n      );\n      return null;\n    }\n  }\n\n  /**\n   * Map Linear priority (0-4) to local TaskPriority\n   */\n  private mapLinearPriorityToLocal(priority: number): TaskPriority {\n    switch (priority) {\n      case 1:\n        return 'urgent';\n      case 2:\n        return 'high';\n      case 3:\n        return 'medium';\n      case 4:\n        return 'low';\n      default:\n        return 'medium';\n    }\n  }\n}\n\n/**\n * Default sync configuration\n */\nexport const DEFAULT_SYNC_CONFIG: SyncConfig = {\n  enabled: false,\n  direction: 'bidirectional',\n  autoSync: true,\n  conflictResolution: 'newest_wins',\n  syncInterval: 15, // minutes\n  maxBatchSize: 10, // max tasks per sync batch\n  rateLimitDelay: 500, // 500ms between API calls\n};\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/integrations/linear/types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=types.js.map

package/dist/integrations/linear/types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}