@archicore/sdk 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 ArchiCore
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,221 @@
+# @archicore/sdk
+
+Official TypeScript/JavaScript SDK for the [ArchiCore](https://archicore.io) Architecture Analysis API.
+
+## Installation
+
+```bash
+npm install @archicore/sdk
+# or
+yarn add @archicore/sdk
+# or
+pnpm add @archicore/sdk
+```
+
+## Quick Start
+
+```typescript
+import { ArchiCore } from '@archicore/sdk';
+
+// Initialize client
+const client = new ArchiCore({ apiKey: 'your-api-key' });
+
+// List projects
+const projects = await client.projects.list();
+console.log(projects);
+
+// Search code semantically
+const results = await client.projects.search('project-id', {
+  query: 'authentication middleware'
+});
+
+// Ask AI assistant
+const answer = await client.projects.ask('project-id', {
+  question: 'How does the authentication system work?'
+});
+console.log(answer.response);
+```
+
+## Features
+
+- **Full TypeScript Support**: Complete type definitions included
+- **Projects**: Create, list, delete, and manage projects
+- **Semantic Search**: Search code using natural language
+- **AI Assistant**: Ask questions about your codebase
+- **Impact Analysis**: Analyze how changes affect your codebase
+- **Code Metrics**: Get code quality metrics
+- **Security Scanning**: Identify vulnerabilities
+- **Webhooks**: Subscribe to events
+
+## API Reference
+
+### Projects
+
+```typescript
+// List all projects
+const projects = await client.projects.list();
+
+// Get a specific project
+const project = await client.projects.get('project-id');
+
+// Create a project
+const project = await client.projects.create({
+  name: 'my-project',
+  githubUrl: 'https://github.com/user/repo'
+});
+
+// Delete a project
+await client.projects.delete('project-id');
+
+// Trigger indexing
+await client.projects.index('project-id', { force: true });
+```
+
+### Search & AI
+
+```typescript
+// Semantic search
+const results = await client.projects.search('project-id', {
+  query: 'error handling',
+  limit: 20,
+  threshold: 0.8
+});
+
+// Ask AI assistant
+const answer = await client.projects.ask('project-id', {
+  question: 'What design patterns are used?',
+  context: 'Focus on the authentication module'
+});
+```
+
+### Analysis
+
+```typescript
+// Get code metrics
+const metrics = await client.projects.metrics('project-id');
+console.log(`Total files: ${metrics.totalFiles}`);
+console.log(`Total lines: ${metrics.totalLines}`);
+
+// Get security scan results
+const security = await client.projects.security('project-id');
+for (const vuln of security.vulnerabilities) {
+  console.log(`[${vuln.severity}] ${vuln.message}`);
+}
+
+// Impact analysis
+const impact = await client.projects.analyze('project-id', {
+  files: ['src/auth/login.ts', 'src/auth/middleware.ts']
+});
+console.log(`Affected files: ${impact.affectedFiles.length}`);
+```
+
+### Webhooks
+
+```typescript
+// List webhooks
+const webhooks = await client.webhooks.list();
+
+// Create a webhook
+const webhook = await client.webhooks.create({
+  url: 'https://example.com/webhook',
+  events: ['project.indexed', 'analysis.complete'],
+  secret: 'your-webhook-secret'
+});
+
+// Delete a webhook
+await client.webhooks.delete('webhook-id');
+```
+
+## Error Handling
+
+```typescript
+import {
+  ArchiCore,
+  AuthenticationError,
+  RateLimitError,
+  NotFoundError,
+  ValidationError
+} from '@archicore/sdk';
+
+const client = new ArchiCore({ apiKey: 'your-api-key' });
+
+try {
+  const project = await client.projects.get('non-existent-id');
+} catch (error) {
+  if (error instanceof NotFoundError) {
+    console.log('Project not found');
+  } else if (error instanceof AuthenticationError) {
+    console.log('Invalid API key');
+  } else if (error instanceof RateLimitError) {
+    console.log(`Rate limited. Retry after ${error.retryAfter} seconds`);
+  } else if (error instanceof ValidationError) {
+    console.log(`Invalid request: ${error.message}`);
+  }
+}
+```
+
+## Configuration
+
+### Custom Base URL
+
+For self-hosted instances:
+
+```typescript
+const client = new ArchiCore({
+  apiKey: 'your-api-key',
+  baseUrl: 'https://your-instance.com/api/v1'
+});
+```
+
+### Timeout
+
+```typescript
+const client = new ArchiCore({
+  apiKey: 'your-api-key',
+  timeout: 60000 // milliseconds
+});
+```
+
+## Browser Support
+
+This SDK works in both Node.js and browser environments. It uses the native `fetch` API.
+
+For Node.js < 18, you may need to polyfill `fetch`:
+
+```typescript
+import fetch from 'node-fetch';
+globalThis.fetch = fetch;
+```
+
+## TypeScript
+
+Full TypeScript support is included. All types are exported:
+
+```typescript
+import type {
+  Project,
+  SearchResult,
+  AskResponse,
+  Metrics,
+  SecurityReport,
+  ImpactAnalysis,
+  Webhook,
+  ArchiCoreConfig
+} from '@archicore/sdk';
+```
+
+## Requirements
+
+- Node.js >= 16 (for native fetch) or polyfill
+- Modern browsers with fetch support
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.
+
+## Links
+
+- [Documentation](https://docs.archicore.io)
+- [API Reference](https://docs.archicore.io/docs/api/overview)
+- [ArchiCore Website](https://archicore.io)
+- [Report Issues](https://archicore.io/report-issue)

package/dist/index.d.mts

@@ -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 };