@stackmemoryai/stackmemory 0.5.57 → 0.5.59

package/dist/src/services/config-service.js

@@ -0,0 +1,65 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { logger } from "../core/monitoring/logger.js";
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { join } from "path";
+class ConfigService {
+  // Using singleton logger from monitoring
+  config = {};
+  configPath;
+  constructor() {
+    this.configPath = join(process.cwd(), ".stackmemory", "config.json");
+    this.loadConfig();
+  }
+  loadConfig() {
+    try {
+      if (existsSync(this.configPath)) {
+        const content = readFileSync(this.configPath, "utf-8");
+        this.config = JSON.parse(content);
+        logger.debug("Loaded configuration", this.config);
+      }
+    } catch (error) {
+      logger.warn("Failed to load configuration, using defaults", error);
+    }
+  }
+  saveConfig() {
+    try {
+      writeFileSync(this.configPath, JSON.stringify(this.config, null, 2));
+      logger.debug("Saved configuration");
+    } catch (error) {
+      logger.error("Failed to save configuration", error);
+    }
+  }
+  async getConfig() {
+    return this.config;
+  }
+  async updateConfig(updates) {
+    this.config = {
+      ...this.config,
+      ...updates
+    };
+    this.saveConfig();
+  }
+  async getLinearConfig() {
+    return this.config.integrations?.linear || {};
+  }
+  async updateLinearConfig(updates) {
+    if (!this.config.integrations) {
+      this.config.integrations = {};
+    }
+    if (!this.config.integrations.linear) {
+      this.config.integrations.linear = {};
+    }
+    this.config.integrations.linear = {
+      ...this.config.integrations.linear,
+      ...updates
+    };
+    this.saveConfig();
+  }
+}
+export {
+  ConfigService
+};
+//# sourceMappingURL=config-service.js.map

package/dist/src/services/config-service.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/services/config-service.ts"],
+  "sourcesContent": ["import { logger } from '../core/monitoring/logger.js';\nimport { readFileSync, writeFileSync, existsSync } from 'fs';\nimport { join } from 'path';\n\nexport interface StackMemoryConfig {\n  version?: string;\n  projectId?: string;\n  integrations?: {\n    linear?: {\n      enabled?: boolean;\n      apiKey?: string;\n      teamId?: string;\n      projectId?: string;\n      syncInterval?: number;\n      webhookSecret?: string;\n    };\n  };\n  webhook?: {\n    port?: number;\n    host?: string;\n    ngrokSubdomain?: string;\n  };\n  features?: {\n    autoSync?: boolean;\n    realTimeSync?: boolean;\n    conflictResolution?: 'manual' | 'auto' | 'prompt';\n  };\n}\n\nexport class ConfigService {\n  // Using singleton logger from monitoring\n  private config: StackMemoryConfig = {};\n  private configPath: string;\n\n  constructor() {\n    // Use singleton logger\n    this.configPath = join(process.cwd(), '.stackmemory', 'config.json');\n    this.loadConfig();\n  }\n\n  private loadConfig(): void {\n    try {\n      if (existsSync(this.configPath)) {\n        const content = readFileSync(this.configPath, 'utf-8');\n        this.config = JSON.parse(content);\n        logger.debug('Loaded configuration', this.config);\n      }\n    } catch (error: unknown) {\n      logger.warn('Failed to load configuration, using defaults', error);\n    }\n  }\n\n  private saveConfig(): void {\n    try {\n      writeFileSync(this.configPath, JSON.stringify(this.config, null, 2));\n      logger.debug('Saved configuration');\n    } catch (error: unknown) {\n      logger.error('Failed to save configuration', error);\n    }\n  }\n\n  public async getConfig(): Promise<StackMemoryConfig> {\n    return this.config;\n  }\n\n  public async updateConfig(\n    updates: Partial<StackMemoryConfig>\n  ): Promise<void> {\n    this.config = {\n      ...this.config,\n      ...updates,\n    };\n    this.saveConfig();\n  }\n\n  public async getLinearConfig() {\n    return this.config.integrations?.linear || {};\n  }\n\n  public async updateLinearConfig(\n    updates: Record<string, unknown>\n  ): Promise<void> {\n    if (!this.config.integrations) {\n      this.config.integrations = {};\n    }\n    if (!this.config.integrations.linear) {\n      this.config.integrations.linear = {};\n    }\n\n    this.config.integrations.linear = {\n      ...this.config.integrations.linear,\n      ...updates,\n    };\n\n    this.saveConfig();\n  }\n}\n"],
+  "mappings": ";;;;AAAA,SAAS,cAAc;AACvB,SAAS,cAAc,eAAe,kBAAkB;AACxD,SAAS,YAAY;AA2Bd,MAAM,cAAc;AAAA;AAAA,EAEjB,SAA4B,CAAC;AAAA,EAC7B;AAAA,EAER,cAAc;AAEZ,SAAK,aAAa,KAAK,QAAQ,IAAI,GAAG,gBAAgB,aAAa;AACnE,SAAK,WAAW;AAAA,EAClB;AAAA,EAEQ,aAAmB;AACzB,QAAI;AACF,UAAI,WAAW,KAAK,UAAU,GAAG;AAC/B,cAAM,UAAU,aAAa,KAAK,YAAY,OAAO;AACrD,aAAK,SAAS,KAAK,MAAM,OAAO;AAChC,eAAO,MAAM,wBAAwB,KAAK,MAAM;AAAA,MAClD;AAAA,IACF,SAAS,OAAgB;AACvB,aAAO,KAAK,gDAAgD,KAAK;AAAA,IACnE;AAAA,EACF;AAAA,EAEQ,aAAmB;AACzB,QAAI;AACF,oBAAc,KAAK,YAAY,KAAK,UAAU,KAAK,QAAQ,MAAM,CAAC,CAAC;AACnE,aAAO,MAAM,qBAAqB;AAAA,IACpC,SAAS,OAAgB;AACvB,aAAO,MAAM,gCAAgC,KAAK;AAAA,IACpD;AAAA,EACF;AAAA,EAEA,MAAa,YAAwC;AACnD,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,MAAa,aACX,SACe;AACf,SAAK,SAAS;AAAA,MACZ,GAAG,KAAK;AAAA,MACR,GAAG;AAAA,IACL;AACA,SAAK,WAAW;AAAA,EAClB;AAAA,EAEA,MAAa,kBAAkB;AAC7B,WAAO,KAAK,OAAO,cAAc,UAAU,CAAC;AAAA,EAC9C;AAAA,EAEA,MAAa,mBACX,SACe;AACf,QAAI,CAAC,KAAK,OAAO,cAAc;AAC7B,WAAK,OAAO,eAAe,CAAC;AAAA,IAC9B;AACA,QAAI,CAAC,KAAK,OAAO,aAAa,QAAQ;AACpC,WAAK,OAAO,aAAa,SAAS,CAAC;AAAA,IACrC;AAEA,SAAK,OAAO,aAAa,SAAS;AAAA,MAChC,GAAG,KAAK,OAAO,aAAa;AAAA,MAC5B,GAAG;AAAA,IACL;AAEA,SAAK,WAAW;AAAA,EAClB;AACF;",
+  "names": []
+}

package/dist/src/services/context-service.js

@@ -0,0 +1,194 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { logger } from "../core/monitoring/logger.js";
+import Database from "better-sqlite3";
+import { join } from "path";
+import { existsSync } from "fs";
+class ContextService {
+  // Using singleton logger from monitoring
+  db = null;
+  tasks = /* @__PURE__ */ new Map();
+  constructor() {
+    this.initializeDatabase();
+  }
+  initializeDatabase() {
+    try {
+      const dbPath = join(process.cwd(), ".stackmemory", "context.db");
+      if (existsSync(dbPath)) {
+        this.db = new Database(dbPath);
+        this.loadTasksFromDatabase();
+      }
+    } catch (error) {
+      logger.warn(
+        "Could not connect to database, using in-memory storage",
+        error
+      );
+    }
+  }
+  loadTasksFromDatabase() {
+    if (!this.db) return;
+    try {
+      this.db.exec(`
+        CREATE TABLE IF NOT EXISTS tasks (
+          id TEXT PRIMARY KEY,
+          title TEXT NOT NULL,
+          description TEXT,
+          status TEXT DEFAULT 'todo',
+          priority TEXT,
+          tags TEXT,
+          external_id TEXT,
+          external_identifier TEXT,
+          external_url TEXT,
+          metadata TEXT,
+          created_at INTEGER,
+          updated_at INTEGER
+        )
+      `);
+      const stmt = this.db.prepare("SELECT * FROM tasks");
+      const rows = stmt.all();
+      for (const row of rows) {
+        const task = {
+          id: row.id,
+          title: row.title,
+          description: row.description || "",
+          status: row.status || "todo",
+          priority: row.priority || void 0,
+          tags: row.tags ? JSON.parse(row.tags) : [],
+          externalId: row.external_id || void 0,
+          externalIdentifier: row.external_identifier || void 0,
+          externalUrl: row.external_url || void 0,
+          metadata: row.metadata ? JSON.parse(row.metadata) : void 0,
+          createdAt: new Date(row.created_at),
+          updatedAt: new Date(row.updated_at)
+        };
+        this.tasks.set(task.id, task);
+      }
+      logger.info(`Loaded ${rows.length} tasks from database`);
+    } catch (error) {
+      logger.error("Failed to load tasks from database", error);
+    }
+  }
+  async getTask(id) {
+    return this.tasks.get(id) || null;
+  }
+  async getTaskByExternalId(externalId) {
+    for (const task of this.tasks.values()) {
+      if (task.externalId === externalId) {
+        return task;
+      }
+    }
+    return null;
+  }
+  async getAllTasks() {
+    return Array.from(this.tasks.values());
+  }
+  async createTask(taskData) {
+    const task = {
+      id: this.generateId(),
+      title: taskData.title || "Untitled Task",
+      description: taskData.description || "",
+      status: taskData.status || "todo",
+      priority: taskData.priority,
+      tags: taskData.tags || [],
+      externalId: taskData.externalId,
+      externalIdentifier: taskData.externalIdentifier,
+      externalUrl: taskData.externalUrl,
+      metadata: taskData.metadata,
+      createdAt: taskData.createdAt || /* @__PURE__ */ new Date(),
+      updatedAt: taskData.updatedAt || /* @__PURE__ */ new Date()
+    };
+    this.tasks.set(task.id, task);
+    if (this.db) {
+      try {
+        const stmt = this.db.prepare(`
+          INSERT INTO tasks (id, title, description, status, priority, tags, 
+                           external_id, external_identifier, external_url, 
+                           metadata, created_at, updated_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `);
+        stmt.run(
+          task.id,
+          task.title,
+          task.description,
+          task.status,
+          task.priority || null,
+          JSON.stringify(task.tags),
+          task.externalId || null,
+          task.externalIdentifier || null,
+          task.externalUrl || null,
+          task.metadata ? JSON.stringify(task.metadata) : null,
+          task.createdAt.getTime(),
+          task.updatedAt.getTime()
+        );
+      } catch (error) {
+        logger.error("Failed to persist task to database", error);
+      }
+    }
+    logger.debug(`Created task: ${task.id} - ${task.title}`);
+    return task;
+  }
+  async updateTask(id, updates) {
+    const task = this.tasks.get(id);
+    if (!task) {
+      return null;
+    }
+    const updatedTask = {
+      ...task,
+      ...updates,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.tasks.set(id, updatedTask);
+    if (this.db) {
+      try {
+        const stmt = this.db.prepare(`
+          UPDATE tasks SET title = ?, description = ?, status = ?, 
+                          priority = ?, tags = ?, external_id = ?, 
+                          external_identifier = ?, external_url = ?, 
+                          metadata = ?, updated_at = ?
+          WHERE id = ?
+        `);
+        stmt.run(
+          updatedTask.title,
+          updatedTask.description,
+          updatedTask.status,
+          updatedTask.priority || null,
+          JSON.stringify(updatedTask.tags),
+          updatedTask.externalId || null,
+          updatedTask.externalIdentifier || null,
+          updatedTask.externalUrl || null,
+          updatedTask.metadata ? JSON.stringify(updatedTask.metadata) : null,
+          updatedTask.updatedAt.getTime(),
+          id
+        );
+      } catch (error) {
+        logger.error("Failed to update task in database", error);
+      }
+    }
+    logger.debug(`Updated task: ${id} - ${updatedTask.title}`);
+    return updatedTask;
+  }
+  async deleteTask(id) {
+    const deleted = this.tasks.delete(id);
+    if (deleted) {
+      if (this.db) {
+        try {
+          const stmt = this.db.prepare("DELETE FROM tasks WHERE id = ?");
+          stmt.run(id);
+        } catch (error) {
+          logger.error("Failed to delete task from database", error);
+        }
+      }
+      logger.debug(`Deleted task: ${id}`);
+    }
+    return deleted;
+  }
+  generateId() {
+    return "task_" + Date.now() + "_" + Math.random().toString(36).substr(2, 9);
+  }
+}
+export {
+  ContextService
+};
+//# sourceMappingURL=context-service.js.map

package/dist/src/services/context-service.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/services/context-service.ts"],
+  "sourcesContent": ["import { Task } from '../types/task.js';\n// TaskStatus and TaskPriority will be used in future implementations\n// import { TaskStatus, TaskPriority } from '../types/task.js';\nimport { logger } from '../core/monitoring/logger.js';\nimport Database from 'better-sqlite3';\nimport { join } from 'path';\nimport { existsSync } from 'fs';\n\ninterface TaskRow {\n  id: string;\n  title: string;\n  description?: string;\n  status?: string;\n  priority?: string;\n  tags?: string;\n  external_id?: string;\n  external_identifier?: string;\n  external_url?: string;\n  metadata?: string;\n  created_at: number;\n  updated_at: number;\n}\n\nexport class ContextService {\n  // Using singleton logger from monitoring\n  private db: Database.Database | null = null;\n  private tasks: Map<string, Task> = new Map();\n\n  constructor() {\n    // Use singleton logger\n    this.initializeDatabase();\n  }\n\n  private initializeDatabase(): void {\n    try {\n      const dbPath = join(process.cwd(), '.stackmemory', 'context.db');\n      if (existsSync(dbPath)) {\n        this.db = new Database(dbPath);\n        this.loadTasksFromDatabase();\n      }\n    } catch (error: unknown) {\n      logger.warn(\n        'Could not connect to database, using in-memory storage',\n        error\n      );\n    }\n  }\n\n  private loadTasksFromDatabase(): void {\n    if (!this.db) return;\n\n    try {\n      // Create tasks table if it doesn't exist\n      this.db.exec(`\n        CREATE TABLE IF NOT EXISTS tasks (\n          id TEXT PRIMARY KEY,\n          title TEXT NOT NULL,\n          description TEXT,\n          status TEXT DEFAULT 'todo',\n          priority TEXT,\n          tags TEXT,\n          external_id TEXT,\n          external_identifier TEXT,\n          external_url TEXT,\n          metadata TEXT,\n          created_at INTEGER,\n          updated_at INTEGER\n        )\n      `);\n\n      // Load all tasks from database\n      const stmt = this.db.prepare('SELECT * FROM tasks');\n      const rows = stmt.all() as TaskRow[];\n\n      for (const row of rows) {\n        const task: Task = {\n          id: row.id,\n          title: row.title,\n          description: row.description || '',\n          status: row.status || 'todo',\n          priority: row.priority || undefined,\n          tags: row.tags ? JSON.parse(row.tags) : [],\n          externalId: row.external_id || undefined,\n          externalIdentifier: row.external_identifier || undefined,\n          externalUrl: row.external_url || undefined,\n          metadata: row.metadata ? JSON.parse(row.metadata) : undefined,\n          createdAt: new Date(row.created_at),\n          updatedAt: new Date(row.updated_at),\n        };\n        this.tasks.set(task.id, task);\n      }\n\n      logger.info(`Loaded ${rows.length} tasks from database`);\n    } catch (error: unknown) {\n      logger.error('Failed to load tasks from database', error);\n    }\n  }\n\n  public async getTask(id: string): Promise<Task | null> {\n    return this.tasks.get(id) || null;\n  }\n\n  public async getTaskByExternalId(externalId: string): Promise<Task | null> {\n    for (const task of this.tasks.values()) {\n      if (task.externalId === externalId) {\n        return task;\n      }\n    }\n    return null;\n  }\n\n  public async getAllTasks(): Promise<Task[]> {\n    return Array.from(this.tasks.values());\n  }\n\n  public async createTask(taskData: Partial<Task>): Promise<Task> {\n    const task: Task = {\n      id: this.generateId(),\n      title: taskData.title || 'Untitled Task',\n      description: taskData.description || '',\n      status: taskData.status || 'todo',\n      priority: taskData.priority,\n      tags: taskData.tags || [],\n      externalId: taskData.externalId,\n      externalIdentifier: taskData.externalIdentifier,\n      externalUrl: taskData.externalUrl,\n      metadata: taskData.metadata,\n      createdAt: taskData.createdAt || new Date(),\n      updatedAt: taskData.updatedAt || new Date(),\n    };\n\n    this.tasks.set(task.id, task);\n\n    // Persist to database if available\n    if (this.db) {\n      try {\n        const stmt = this.db.prepare(`\n          INSERT INTO tasks (id, title, description, status, priority, tags, \n                           external_id, external_identifier, external_url, \n                           metadata, created_at, updated_at)\n          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)\n        `);\n        stmt.run(\n          task.id,\n          task.title,\n          task.description,\n          task.status,\n          task.priority || null,\n          JSON.stringify(task.tags),\n          task.externalId || null,\n          task.externalIdentifier || null,\n          task.externalUrl || null,\n          task.metadata ? JSON.stringify(task.metadata) : null,\n          task.createdAt.getTime(),\n          task.updatedAt.getTime()\n        );\n      } catch (error: unknown) {\n        logger.error('Failed to persist task to database', error);\n      }\n    }\n\n    logger.debug(`Created task: ${task.id} - ${task.title}`);\n    return task;\n  }\n\n  public async updateTask(\n    id: string,\n    updates: Partial<Task>\n  ): Promise<Task | null> {\n    const task = this.tasks.get(id);\n    if (!task) {\n      return null;\n    }\n\n    const updatedTask = {\n      ...task,\n      ...updates,\n      updatedAt: new Date(),\n    };\n\n    this.tasks.set(id, updatedTask);\n\n    // Update in database if available\n    if (this.db) {\n      try {\n        const stmt = this.db.prepare(`\n          UPDATE tasks SET title = ?, description = ?, status = ?, \n                          priority = ?, tags = ?, external_id = ?, \n                          external_identifier = ?, external_url = ?, \n                          metadata = ?, updated_at = ?\n          WHERE id = ?\n        `);\n        stmt.run(\n          updatedTask.title,\n          updatedTask.description,\n          updatedTask.status,\n          updatedTask.priority || null,\n          JSON.stringify(updatedTask.tags),\n          updatedTask.externalId || null,\n          updatedTask.externalIdentifier || null,\n          updatedTask.externalUrl || null,\n          updatedTask.metadata ? JSON.stringify(updatedTask.metadata) : null,\n          updatedTask.updatedAt.getTime(),\n          id\n        );\n      } catch (error: unknown) {\n        logger.error('Failed to update task in database', error);\n      }\n    }\n\n    logger.debug(`Updated task: ${id} - ${updatedTask.title}`);\n    return updatedTask;\n  }\n\n  public async deleteTask(id: string): Promise<boolean> {\n    const deleted = this.tasks.delete(id);\n\n    if (deleted) {\n      // Delete from database if available\n      if (this.db) {\n        try {\n          const stmt = this.db.prepare('DELETE FROM tasks WHERE id = ?');\n          stmt.run(id);\n        } catch (error: unknown) {\n          logger.error('Failed to delete task from database', error);\n        }\n      }\n      logger.debug(`Deleted task: ${id}`);\n    }\n    return deleted;\n  }\n\n  private generateId(): string {\n    return 'task_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9);\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/src/skills/api-discovery.js

@@ -0,0 +1,354 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { execSync } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { logger } from "../core/monitoring/logger.js";
+import { getAPISkill } from "./api-skill.js";
+const API_PATTERNS = [
+  // Direct API URLs
+  {
+    pattern: /https?:\/\/api\.([a-z0-9-]+)\.(com|io|dev|app|co)/,
+    nameGroup: 1
+  },
+  // REST API paths in docs
+  { pattern: /https?:\/\/([a-z0-9-]+)\.com\/api/, nameGroup: 1 },
+  // Developer docs
+  { pattern: /https?:\/\/developer\.([a-z0-9-]+)\.com/, nameGroup: 1 },
+  // Docs subdomains
+  { pattern: /https?:\/\/docs\.([a-z0-9-]+)\.(com|io|dev)/, nameGroup: 1 }
+];
+const KNOWN_SPECS = {
+  github: "https://raw.githubusercontent.com/github/rest-api-description/main/descriptions/api.github.com/api.github.com.json",
+  stripe: "https://raw.githubusercontent.com/stripe/openapi/master/openapi/spec3.json",
+  twilio: "https://raw.githubusercontent.com/twilio/twilio-oai/main/spec/json/twilio_api_v2010.json",
+  slack: "https://api.slack.com/specs/openapi/v2/slack_web.json",
+  discord: "https://raw.githubusercontent.com/discord/discord-api-spec/main/specs/openapi.json",
+  openai: "https://raw.githubusercontent.com/openai/openai-openapi/master/openapi.yaml",
+  anthropic: "https://raw.githubusercontent.com/anthropics/anthropic-sdk-python/main/openapi.json",
+  linear: "https://api.linear.app/graphql",
+  // GraphQL, not REST
+  notion: "https://raw.githubusercontent.com/NotionX/notion-sdk-js/main/openapi.json",
+  vercel: "https://openapi.vercel.sh/",
+  cloudflare: "https://raw.githubusercontent.com/cloudflare/api-schemas/main/openapi.json",
+  // Google Cloud Platform - uses Google Discovery format
+  gcp: "https://www.googleapis.com/discovery/v1/apis",
+  "gcp-compute": "https://compute.googleapis.com/$discovery/rest?version=v1",
+  "gcp-storage": "https://storage.googleapis.com/$discovery/rest?version=v1",
+  "gcp-run": "https://run.googleapis.com/$discovery/rest?version=v2",
+  "gcp-functions": "https://cloudfunctions.googleapis.com/$discovery/rest?version=v2",
+  "gcp-bigquery": "https://bigquery.googleapis.com/$discovery/rest?version=v2",
+  "gcp-aiplatform": "https://aiplatform.googleapis.com/$discovery/rest?version=v1",
+  // Railway - GraphQL API
+  railway: "https://backboard.railway.com/graphql/v2"
+  // GraphQL endpoint
+};
+const KNOWN_BASES = {
+  github: "https://api.github.com",
+  stripe: "https://api.stripe.com",
+  twilio: "https://api.twilio.com",
+  slack: "https://slack.com/api",
+  discord: "https://discord.com/api",
+  openai: "https://api.openai.com",
+  anthropic: "https://api.anthropic.com",
+  linear: "https://api.linear.app",
+  notion: "https://api.notion.com",
+  vercel: "https://api.vercel.com",
+  cloudflare: "https://api.cloudflare.com",
+  // Google Cloud Platform
+  gcp: "https://www.googleapis.com",
+  "gcp-compute": "https://compute.googleapis.com",
+  "gcp-storage": "https://storage.googleapis.com",
+  "gcp-run": "https://run.googleapis.com",
+  "gcp-functions": "https://cloudfunctions.googleapis.com",
+  "gcp-bigquery": "https://bigquery.googleapis.com",
+  "gcp-aiplatform": "https://aiplatform.googleapis.com",
+  // Railway (GraphQL)
+  railway: "https://backboard.railway.com/graphql/v2"
+};
+const API_TYPES = {
+  railway: "graphql",
+  linear: "graphql",
+  gcp: "google-discovery",
+  "gcp-compute": "google-discovery",
+  "gcp-storage": "google-discovery",
+  "gcp-run": "google-discovery",
+  "gcp-functions": "google-discovery",
+  "gcp-bigquery": "google-discovery",
+  "gcp-aiplatform": "google-discovery"
+};
+class APIDiscoverySkill {
+  discoveryLog;
+  discoveredAPIs = /* @__PURE__ */ new Map();
+  constructor() {
+    this.discoveryLog = path.join(
+      os.homedir(),
+      ".stackmemory",
+      "api-discovery.log"
+    );
+  }
+  /**
+   * Analyze a URL for potential API endpoints
+   */
+  analyzeUrl(url) {
+    if (url.includes("googleapis.com")) {
+      const gcpMatch = url.match(/https?:\/\/([a-z]+)\.googleapis\.com/);
+      if (gcpMatch) {
+        const service = gcpMatch[1];
+        const name = `gcp-${service}`;
+        return {
+          name,
+          baseUrl: `https://${service}.googleapis.com`,
+          specUrl: KNOWN_SPECS[name] || `https://${service}.googleapis.com/$discovery/rest?version=v1`,
+          source: "known",
+          confidence: 0.95,
+          apiType: "google-discovery"
+        };
+      }
+    }
+    if (url.includes("railway.com") || url.includes("railway.app")) {
+      return {
+        name: "railway",
+        baseUrl: KNOWN_BASES["railway"],
+        specUrl: KNOWN_SPECS["railway"],
+        source: "known",
+        confidence: 0.95,
+        apiType: "graphql"
+      };
+    }
+    for (const [name, baseUrl] of Object.entries(KNOWN_BASES)) {
+      if (url.includes(name) || url.includes(baseUrl)) {
+        return {
+          name,
+          baseUrl,
+          specUrl: KNOWN_SPECS[name],
+          source: "known",
+          confidence: 0.95,
+          apiType: API_TYPES[name] || "rest"
+        };
+      }
+    }
+    for (const { pattern, nameGroup } of API_PATTERNS) {
+      const match = url.match(pattern);
+      if (match) {
+        const name = match[nameGroup].toLowerCase();
+        const baseUrl = this.inferBaseUrl(url, name);
+        return {
+          name,
+          baseUrl,
+          source: "inferred",
+          confidence: 0.7,
+          apiType: "rest"
+        };
+      }
+    }
+    return null;
+  }
+  /**
+   * Infer base URL from a discovered URL
+   */
+  inferBaseUrl(url, name) {
+    const patterns = [
+      `https://api.${name}.com`,
+      `https://api.${name}.io`,
+      `https://${name}.com/api`
+    ];
+    try {
+      const urlObj = new URL(url);
+      if (urlObj.hostname.startsWith("api.")) {
+        return `${urlObj.protocol}//${urlObj.hostname}`;
+      }
+      if (urlObj.pathname.includes("/api")) {
+        return `${urlObj.protocol}//${urlObj.hostname}/api`;
+      }
+      return `${urlObj.protocol}//${urlObj.hostname}`;
+    } catch {
+      return patterns[0];
+    }
+  }
+  /**
+   * Try to discover OpenAPI spec for a service
+   */
+  async discoverSpec(name, baseUrl) {
+    if (KNOWN_SPECS[name]) {
+      return KNOWN_SPECS[name];
+    }
+    const specPaths = [
+      "/openapi.json",
+      "/openapi.yaml",
+      "/swagger.json",
+      "/swagger.yaml",
+      "/api-docs",
+      "/v1/openapi.json",
+      "/v2/openapi.json",
+      "/docs/openapi.json",
+      "/.well-known/openapi.json"
+    ];
+    for (const specPath of specPaths) {
+      const specUrl = `${baseUrl}${specPath}`;
+      try {
+        execSync(`curl -sI --max-time 2 "${specUrl}" | grep -q "200 OK"`, {
+          stdio: "pipe"
+        });
+        return specUrl;
+      } catch {
+      }
+    }
+    return null;
+  }
+  /**
+   * Process a URL and auto-register if it's an API
+   */
+  async processUrl(url, autoRegister = true) {
+    const discovered = this.analyzeUrl(url);
+    if (!discovered) {
+      return null;
+    }
+    const existing = this.discoveredAPIs.get(discovered.name);
+    if (existing) {
+      return existing;
+    }
+    if (!discovered.specUrl && discovered.source !== "known") {
+      try {
+        discovered.specUrl = await this.discoverSpec(discovered.name, discovered.baseUrl) || void 0;
+      } catch {
+      }
+    }
+    this.discoveredAPIs.set(discovered.name, discovered);
+    this.logDiscovery(discovered, url);
+    if (autoRegister && discovered.confidence >= 0.7) {
+      await this.registerAPI(discovered);
+    }
+    return discovered;
+  }
+  /**
+   * Register a discovered API
+   */
+  async registerAPI(api) {
+    const skill = getAPISkill();
+    try {
+      const result = await skill.add(api.name, api.baseUrl, {
+        spec: api.specUrl
+      });
+      if (result.success) {
+        logger.info(`Auto-registered API: ${api.name}`);
+        return true;
+      }
+    } catch (error) {
+      logger.warn(`Failed to auto-register API ${api.name}:`, error);
+    }
+    return false;
+  }
+  /**
+   * Log discovery for debugging
+   */
+  logDiscovery(api, sourceUrl) {
+    const entry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      api,
+      sourceUrl
+    };
+    try {
+      const dir = path.dirname(this.discoveryLog);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      fs.appendFileSync(this.discoveryLog, JSON.stringify(entry) + "\n");
+    } catch (error) {
+      logger.warn("Failed to log API discovery:", error);
+    }
+  }
+  /**
+   * Get all discovered APIs
+   */
+  getDiscoveredAPIs() {
+    return Array.from(this.discoveredAPIs.values());
+  }
+  /**
+   * Suggest API registration based on recent activity
+   */
+  async suggestFromContext(recentUrls) {
+    const result = {
+      discovered: [],
+      registered: [],
+      skipped: []
+    };
+    for (const url of recentUrls) {
+      const discovered = await this.processUrl(url, false);
+      if (discovered) {
+        result.discovered.push(discovered);
+        const skill = getAPISkill();
+        const listResult = await skill.list();
+        const existingAPIs = listResult.data || [];
+        if (existingAPIs.some((api) => api.name === discovered.name)) {
+          result.skipped.push(discovered.name);
+        } else if (discovered.confidence >= 0.7) {
+          const registered = await this.registerAPI(discovered);
+          if (registered) {
+            result.registered.push(discovered.name);
+          }
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Get help text
+   */
+  getHelp() {
+    const restAPIs = Object.keys(KNOWN_SPECS).filter(
+      (s) => !API_TYPES[s] || API_TYPES[s] === "rest"
+    );
+    const graphqlAPIs = Object.keys(KNOWN_SPECS).filter(
+      (s) => API_TYPES[s] === "graphql"
+    );
+    const gcpAPIs = Object.keys(KNOWN_SPECS).filter(
+      (s) => API_TYPES[s] === "google-discovery"
+    );
+    return `
+API Auto-Discovery
+
+Automatically detects and registers APIs when you browse documentation.
+
+REST APIs (OpenAPI specs):
+${restAPIs.map((s) => `  - ${s}`).join("\n")}
+
+GraphQL APIs:
+${graphqlAPIs.map((s) => `  - ${s}`).join("\n")}
+
+Google Cloud Platform (Discovery format):
+${gcpAPIs.map((s) => `  - ${s}`).join("\n")}
+
+How It Works:
+1. Monitors URLs you access during development
+2. Identifies API documentation and endpoints
+3. Finds OpenAPI specs automatically
+4. Registers APIs for easy access via /api exec
+
+Usage:
+  # Check if a URL is a known API
+  stackmemory api discover <url>
+
+  # List discovered APIs
+  stackmemory api discovered
+
+  # Register all discovered APIs
+  stackmemory api register-discovered
+`;
+  }
+}
+let discoveryInstance = null;
+function getAPIDiscovery() {
+  if (!discoveryInstance) {
+    discoveryInstance = new APIDiscoverySkill();
+  }
+  return discoveryInstance;
+}
+export {
+  APIDiscoverySkill,
+  getAPIDiscovery
+};
+//# sourceMappingURL=api-discovery.js.map