archicore-sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,307 @@
+// src/index.ts
+var ArchiCoreError = class extends Error {
+  constructor(message, code, statusCode) {
+    super(message);
+    this.name = "ArchiCoreError";
+    this.code = code;
+    this.statusCode = statusCode;
+  }
+};
+var AuthenticationError = class extends ArchiCoreError {
+  constructor(message = "Invalid or missing API key") {
+    super(message, "UNAUTHORIZED", 401);
+    this.name = "AuthenticationError";
+  }
+};
+var RateLimitError = class extends ArchiCoreError {
+  constructor(message = "Rate limit exceeded", retryAfter, limit, remaining) {
+    super(message, "RATE_LIMITED", 429);
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+    this.limit = limit;
+    this.remaining = remaining;
+  }
+};
+var NotFoundError = class extends ArchiCoreError {
+  constructor(message = "Resource not found") {
+    super(message, "NOT_FOUND", 404);
+    this.name = "NotFoundError";
+  }
+};
+var ValidationError = class extends ArchiCoreError {
+  constructor(message = "Invalid request parameters") {
+    super(message, "VALIDATION_ERROR", 400);
+    this.name = "ValidationError";
+  }
+};
+async function httpRequest(url, options) {
+  const controller = new AbortController();
+  const timeout = options.timeout || 3e4;
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+  try {
+    const response = await fetch(url, {
+      ...options,
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    return handleResponse(response);
+  } catch (error) {
+    clearTimeout(timeoutId);
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new ArchiCoreError("Request timed out", "TIMEOUT");
+    }
+    throw error;
+  }
+}
+async function handleResponse(response) {
+  const rateLimitInfo = {
+    limit: response.headers.get("X-RateLimit-Limit"),
+    remaining: response.headers.get("X-RateLimit-Remaining"),
+    reset: response.headers.get("X-RateLimit-Reset")
+  };
+  if (response.ok) {
+    if (response.status === 204) {
+      return { success: true };
+    }
+    const text = await response.text();
+    return text ? JSON.parse(text) : { success: true };
+  }
+  let errorMessage = "Unknown error";
+  let errorCode;
+  try {
+    const errorData = await response.json();
+    errorMessage = errorData.error || errorData.message || errorMessage;
+    errorCode = errorData.code;
+  } catch {
+    errorMessage = response.statusText || errorMessage;
+  }
+  switch (response.status) {
+    case 401:
+      throw new AuthenticationError(errorMessage);
+    case 403:
+      throw new ArchiCoreError(errorMessage, "FORBIDDEN", 403);
+    case 404:
+      throw new NotFoundError(errorMessage);
+    case 429:
+      throw new RateLimitError(
+        errorMessage,
+        parseInt(response.headers.get("Retry-After") || "60", 10),
+        rateLimitInfo.limit ? parseInt(rateLimitInfo.limit, 10) : void 0,
+        rateLimitInfo.remaining ? parseInt(rateLimitInfo.remaining, 10) : void 0
+      );
+    case 400:
+      throw new ValidationError(errorMessage);
+    default:
+      if (response.status >= 500) {
+        throw new ArchiCoreError(errorMessage, "SERVER_ERROR", response.status);
+      }
+      throw new ArchiCoreError(errorMessage, errorCode, response.status);
+  }
+}
+var ProjectsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List all projects.
+   */
+  async list() {
+    const response = await this.client.request("GET", "/projects");
+    return response.data || response.projects || [];
+  }
+  /**
+   * Get a specific project by ID.
+   */
+  async get(projectId) {
+    const response = await this.client.request("GET", `/projects/${projectId}`);
+    return response.data || response.project || response;
+  }
+  /**
+   * Create a new project.
+   */
+  async create(options) {
+    const response = await this.client.request("POST", "/projects", options);
+    return response.data || response.project || response;
+  }
+  /**
+   * Delete a project.
+   */
+  async delete(projectId) {
+    await this.client.request("DELETE", `/projects/${projectId}`);
+  }
+  /**
+   * Trigger project indexing.
+   */
+  async index(projectId, options) {
+    const response = await this.client.request(
+      "POST",
+      `/projects/${projectId}/index`,
+      options
+    );
+    return response.data || response;
+  }
+  /**
+   * Semantic search in project code.
+   *
+   * @example
+   * ```typescript
+   * const results = await client.projects.search('project-id', {
+   *   query: 'authentication middleware'
+   * });
+   * ```
+   */
+  async search(projectId, options) {
+    const response = await this.client.request(
+      "POST",
+      `/projects/${projectId}/search`,
+      options
+    );
+    return response.data || response.results || [];
+  }
+  /**
+   * Ask AI assistant about the project.
+   *
+   * @example
+   * ```typescript
+   * const answer = await client.projects.ask('project-id', {
+   *   question: 'How does the auth system work?'
+   * });
+   * console.log(answer.response);
+   * ```
+   */
+  async ask(projectId, options) {
+    const response = await this.client.request(
+      "POST",
+      `/projects/${projectId}/ask`,
+      options
+    );
+    return response.data || response;
+  }
+  /**
+   * Get code metrics for a project.
+   */
+  async metrics(projectId) {
+    const response = await this.client.request(
+      "GET",
+      `/projects/${projectId}/metrics`
+    );
+    return response.data || response.metrics || response;
+  }
+  /**
+   * Get security scan results.
+   */
+  async security(projectId) {
+    const response = await this.client.request(
+      "GET",
+      `/projects/${projectId}/security`
+    );
+    return response.data || response.security || response;
+  }
+  /**
+   * Perform impact analysis.
+   *
+   * @example
+   * ```typescript
+   * const impact = await client.projects.analyze('project-id', {
+   *   files: ['src/auth/login.ts']
+   * });
+   * console.log(`Affected: ${impact.affectedFiles.length} files`);
+   * ```
+   */
+  async analyze(projectId, options) {
+    const response = await this.client.request(
+      "POST",
+      `/projects/${projectId}/analyze`,
+      options
+    );
+    return response.data || response;
+  }
+};
+var WebhooksResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List all webhooks.
+   */
+  async list() {
+    const response = await this.client.request("GET", "/webhooks");
+    return response.data || response.webhooks || [];
+  }
+  /**
+   * Create a new webhook.
+   *
+   * @example
+   * ```typescript
+   * const webhook = await client.webhooks.create({
+   *   url: 'https://example.com/webhook',
+   *   events: ['project.indexed', 'analysis.complete']
+   * });
+   * ```
+   */
+  async create(options) {
+    const response = await this.client.request("POST", "/webhooks", options);
+    return response.data || response.webhook || response;
+  }
+  /**
+   * Delete a webhook.
+   */
+  async delete(webhookId) {
+    await this.client.request("DELETE", `/webhooks/${webhookId}`);
+  }
+};
+var ArchiCore = class {
+  /**
+   * Create a new ArchiCore client.
+   *
+   * @param config - Client configuration
+   *
+   * @example
+   * ```typescript
+   * const client = new ArchiCore({
+   *   apiKey: 'your-api-key',
+   *   baseUrl: 'https://api.archicore.io/api/v1' // optional
+   * });
+   * ```
+   */
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new Error("apiKey is required");
+    }
+    this.apiKey = config.apiKey;
+    this.baseUrl = (config.baseUrl || "https://api.archicore.io/api/v1").replace(/\/+$/, "");
+    this.timeout = config.timeout || 3e4;
+    this.projects = new ProjectsResource(this);
+    this.webhooks = new WebhooksResource(this);
+  }
+  /**
+   * Make an API request.
+   * @internal
+   */
+  async request(method, endpoint, data) {
+    const url = `${this.baseUrl}${endpoint}`;
+    const options = {
+      method,
+      headers: {
+        "Authorization": `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json",
+        "User-Agent": "@archicore/sdk/0.1.0"
+      },
+      timeout: this.timeout
+    };
+    if (data && ["POST", "PUT", "PATCH"].includes(method)) {
+      options.body = JSON.stringify(data);
+    }
+    return httpRequest(url, options);
+  }
+};
+var index_default = ArchiCore;
+export {
+  ArchiCore,
+  ArchiCoreError,
+  AuthenticationError,
+  NotFoundError,
+  RateLimitError,
+  ValidationError,
+  index_default as default
+};

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "archicore-sdk",
+  "version": "0.1.0",
+  "description": "Official TypeScript/JavaScript SDK for ArchiCore Architecture Analysis API",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint src --ext .ts",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "archicore",
+    "architecture",
+    "code-analysis",
+    "api",
+    "sdk",
+    "typescript",
+    "ai",
+    "llm"
+  ],
+  "author": "ArchiCore Team <support@archicore.io>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/archicore/archicore-js.git"
+  },
+  "bugs": {
+    "url": "https://github.com/archicore/archicore-js/issues"
+  },
+  "homepage": "https://archicore.io",
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0",
+    "vitest": "^1.0.0",
+    "eslint": "^8.55.0",
+    "@typescript-eslint/eslint-plugin": "^6.13.0",
+    "@typescript-eslint/parser": "^6.13.0"
+  }
+}