@archicore/sdk 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,258 @@
+/**
+ * ArchiCore JavaScript/TypeScript SDK
+ *
+ * Official client for the ArchiCore Architecture Analysis API.
+ *
+ * @example
+ * ```typescript
+ * import { ArchiCore } from '@archicore/sdk';
+ *
+ * const client = new ArchiCore({ apiKey: 'your-api-key' });
+ * const projects = await client.projects.list();
+ * ```
+ */
+interface ArchiCoreConfig {
+    apiKey: string;
+    baseUrl?: string;
+    timeout?: number;
+}
+interface Project {
+    id: string;
+    name: string;
+    path?: string;
+    status?: 'pending' | 'indexing' | 'ready' | 'error';
+    createdAt?: string;
+    updatedAt?: string;
+    stats?: {
+        files: number;
+        lines: number;
+        symbols: number;
+    };
+}
+interface SearchResult {
+    file: string;
+    line: number;
+    code: string;
+    score: number;
+    context?: string;
+}
+interface AskResponse {
+    response: string;
+    sources?: Array<{
+        file: string;
+        line: number;
+        code: string;
+    }>;
+    confidence?: number;
+}
+interface Metrics {
+    totalFiles: number;
+    totalLines: number;
+    totalSymbols: number;
+    languages: Record<string, number>;
+    complexity?: {
+        average: number;
+        max: number;
+    };
+}
+interface SecurityReport {
+    vulnerabilities: Array<{
+        severity: 'critical' | 'high' | 'medium' | 'low';
+        type: string;
+        message: string;
+        file: string;
+        line: number;
+    }>;
+    summary: {
+        critical: number;
+        high: number;
+        medium: number;
+        low: number;
+    };
+}
+interface ImpactAnalysis {
+    affectedFiles: string[];
+    affectedSymbols: string[];
+    riskLevel: 'low' | 'medium' | 'high';
+    suggestions?: string[];
+}
+interface Webhook {
+    id: string;
+    url: string;
+    events: string[];
+    projectId?: string;
+    createdAt: string;
+    active: boolean;
+}
+interface ApiResponse<T> {
+    success: boolean;
+    data?: T;
+    error?: string;
+    code?: string;
+}
+declare class ArchiCoreError extends Error {
+    code?: string;
+    statusCode?: number;
+    constructor(message: string, code?: string, statusCode?: number);
+}
+declare class AuthenticationError extends ArchiCoreError {
+    constructor(message?: string);
+}
+declare class RateLimitError extends ArchiCoreError {
+    retryAfter?: number;
+    limit?: number;
+    remaining?: number;
+    constructor(message?: string, retryAfter?: number, limit?: number, remaining?: number);
+}
+declare class NotFoundError extends ArchiCoreError {
+    constructor(message?: string);
+}
+declare class ValidationError extends ArchiCoreError {
+    constructor(message?: string);
+}
+declare class ProjectsResource {
+    private client;
+    constructor(client: ArchiCore);
+    /**
+     * List all projects.
+     */
+    list(): Promise<Project[]>;
+    /**
+     * Get a specific project by ID.
+     */
+    get(projectId: string): Promise<Project>;
+    /**
+     * Create a new project.
+     */
+    create(options: {
+        name: string;
+        source?: string;
+        githubUrl?: string;
+        gitlabUrl?: string;
+    }): Promise<Project>;
+    /**
+     * Delete a project.
+     */
+    delete(projectId: string): Promise<void>;
+    /**
+     * Trigger project indexing.
+     */
+    index(projectId: string, options?: {
+        force?: boolean;
+    }): Promise<{
+        status: string;
+    }>;
+    /**
+     * Semantic search in project code.
+     *
+     * @example
+     * ```typescript
+     * const results = await client.projects.search('project-id', {
+     *   query: 'authentication middleware'
+     * });
+     * ```
+     */
+    search(projectId: string, options: {
+        query: string;
+        limit?: number;
+        threshold?: number;
+    }): Promise<SearchResult[]>;
+    /**
+     * 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);
+     * ```
+     */
+    ask(projectId: string, options: {
+        question: string;
+        context?: string;
+    }): Promise<AskResponse>;
+    /**
+     * Get code metrics for a project.
+     */
+    metrics(projectId: string): Promise<Metrics>;
+    /**
+     * Get security scan results.
+     */
+    security(projectId: string): Promise<SecurityReport>;
+    /**
+     * 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`);
+     * ```
+     */
+    analyze(projectId: string, options?: {
+        changes?: Array<{
+            file: string;
+            content: string;
+        }>;
+        files?: string[];
+    }): Promise<ImpactAnalysis>;
+}
+declare class WebhooksResource {
+    private client;
+    constructor(client: ArchiCore);
+    /**
+     * List all webhooks.
+     */
+    list(): Promise<Webhook[]>;
+    /**
+     * Create a new webhook.
+     *
+     * @example
+     * ```typescript
+     * const webhook = await client.webhooks.create({
+     *   url: 'https://example.com/webhook',
+     *   events: ['project.indexed', 'analysis.complete']
+     * });
+     * ```
+     */
+    create(options: {
+        url: string;
+        events: string[];
+        projectId?: string;
+        secret?: string;
+    }): Promise<Webhook>;
+    /**
+     * Delete a webhook.
+     */
+    delete(webhookId: string): Promise<void>;
+}
+declare class ArchiCore {
+    private apiKey;
+    private baseUrl;
+    private timeout;
+    projects: ProjectsResource;
+    webhooks: WebhooksResource;
+    /**
+     * 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: ArchiCoreConfig);
+    /**
+     * Make an API request.
+     * @internal
+     */
+    request<T>(method: string, endpoint: string, data?: Record<string, unknown>): Promise<T>;
+}
+
+export { type ApiResponse, ArchiCore, type ArchiCoreConfig, ArchiCoreError, type AskResponse, AuthenticationError, type ImpactAnalysis, type Metrics, NotFoundError, type Project, RateLimitError, type SearchResult, type SecurityReport, ValidationError, type Webhook, ArchiCore as default };

package/dist/index.js

@@ -0,0 +1,337 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ArchiCore: () => ArchiCore,
+  ArchiCoreError: () => ArchiCoreError,
+  AuthenticationError: () => AuthenticationError,
+  NotFoundError: () => NotFoundError,
+  RateLimitError: () => RateLimitError,
+  ValidationError: () => ValidationError,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+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;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ArchiCore,
+  ArchiCoreError,
+  AuthenticationError,
+  NotFoundError,
+  RateLimitError,
+  ValidationError
+});