@codeguide/core 0.0.5 → 0.0.7

package/README.md

@@ -0,0 +1,503 @@
+# @codeguide/core
+
+The core package for CodeGuide with programmatic API access. This package provides TypeScript interfaces and services for integrating CodeGuide functionality into your applications.
+
+## Features
+
+- 🔑 **API Key Management**: Full CRUD operations for API keys
+- 📝 **Project Management**: Create and manage projects programmatically
+- 🎯 **Task Management**: Organize and track development tasks
+- 📊 **Usage Analytics**: Monitor API usage and credits
+- 🔍 **Repository Analysis**: Analyze code repositories
+- 🎨 **Code Generation**: Generate code with AI assistance
+- 🔐 **Multiple Authentication**: Support for various auth methods
+- 🛡️ **TypeScript Support**: Full type safety and IntelliSense
+
+## Installation
+
+```bash
+npm install @codeguide/core
+```
+
+## Quick Start
+
+### Basic Usage
+
+```typescript
+import { CodeGuide } from '@codeguide/core'
+
+const codeguide = new CodeGuide({
+  baseUrl: 'https://api.codeguide.ai',
+  databaseApiKey: 'sk_your_database_api_key'
+})
+
+// Get all API keys
+const keysResponse = await codeguide.apiKeyEnhanced.getAllApiKeys()
+console.log(`Found ${keysResponse.data.length} API keys`)
+
+// Create a new API key
+const newKey = await codeguide.apiKeyEnhanced.createApiKey({
+  name: 'My Application'
+})
+console.log(`Created key: ${newKey.data.api_key}`)
+```
+
+### API Key Management
+
+```typescript
+import {
+  CodeGuide,
+  ApiKeyListResponse,
+  CreateApiKeyRequest
+} from '@codeguide/core'
+
+const codeguide = new CodeGuide({
+  baseUrl: 'https://api.codeguide.ai',
+  databaseApiKey: 'sk_your_database_api_key'
+})
+
+// List all API keys
+const keysResponse: ApiKeyListResponse = await codeguide.apiKeyEnhanced.getAllApiKeys()
+
+// Check if you can create new keys
+const permission = await codeguide.apiKeyEnhanced.checkApiKeyPermission()
+if (permission.data.can_create) {
+  console.log('You can create new API keys')
+}
+
+// Create a new key
+const createRequest: CreateApiKeyRequest = {
+  name: 'Production Application'
+}
+const newKey = await codeguide.apiKeyEnhanced.createApiKey(createRequest)
+
+// Revoke a key
+await codeguide.apiKeyEnhanced.revokeApiKey('key-id-123')
+```
+
+### Project Management
+
+```typescript
+import { CodeGuide } from '@codeguide/core'
+
+const codeguide = new CodeGuide({
+  baseUrl: 'https://api.codeguide.ai',
+  databaseApiKey: 'sk_your_database_api_key'
+})
+
+// Create a new project
+const project = await codeguide.projects.createProject({
+  title: 'My Web Application',
+  description: 'A modern web app built with React'
+})
+
+// Get project details
+const projectDetails = await codeguide.projects.getProject(project.id)
+
+// List all projects
+const projects = await codeguide.projects.getAllProjects()
+```
+
+### Task Management
+
+```typescript
+import { CodeGuide } from '@codeguide/core'
+
+const codeguide = new CodeGuide({
+  baseUrl: 'https://api.codeguide.ai',
+  databaseApiKey: 'sk_your_database_api_key'
+})
+
+// Generate tasks for a project
+const tasks = await codeguide.tasks.generateTasks({
+  project_id: 'project-id-123',
+  context: 'Building a React application with TypeScript'
+})
+
+// Get all tasks for a project
+const projectTasks = await codeguide.tasks.getProjectTasks('project-id-123')
+
+// Update task status
+await codeguide.tasks.updateTask('task-id-123', {
+  status: 'in_progress',
+  notes: 'Started working on authentication module'
+})
+```
+
+## Authentication
+
+The CodeGuide client supports multiple authentication methods with automatic priority handling:
+
+### 1. Database API Key (Highest Priority)
+
+```typescript
+const codeguide = new CodeGuide({
+  baseUrl: 'https://api.codeguide.ai',
+  databaseApiKey: 'sk_your_database_api_key'
+})
+```
+
+### 2. Legacy API Key + User ID
+
+```typescript
+const codeguide = new CodeGuide({
+  baseUrl: 'https://api.codeguide.ai',
+  apiKey: 'your_api_key',
+  userId: 'your_user_id'
+})
+```
+
+### 3. Clerk JWT Token
+
+```typescript
+const codeguide = new CodeGuide({
+  baseUrl: 'https://api.codeguide.ai',
+  jwtToken: 'your_jwt_token'
+})
+```
+
+### Automatic Fallback
+
+The client automatically falls back through authentication methods:
+
+```typescript
+const codeguide = new CodeGuide({
+  baseUrl: 'https://api.codeguide.ai',
+  databaseApiKey: 'sk_key',        // Will try this first
+  apiKey: 'legacy_key',             // Fallback if database key fails
+  userId: 'user_id',                // Required for legacy auth
+  jwtToken: 'jwt_token'             // Final fallback
+})
+```
+
+## API Reference
+
+### ApiKeyEnhancedService
+
+#### getAllApiKeys()
+```typescript
+async getAllApiKeys(): Promise<ApiKeyListResponse>
+```
+Get all API keys for the authenticated user.
+
+**Returns:** `Promise<ApiKeyListResponse>`
+
+**Example:**
+```typescript
+const response = await codeguide.apiKeyEnhanced.getAllApiKeys()
+console.log(response.data) // Array of ApiKey objects
+```
+
+#### createApiKey(request)
+```typescript
+async createApiKey(request: CreateApiKeyRequest): Promise<CreateApiKeyResponse>
+```
+Create a new API key.
+
+**Parameters:**
+- `request.name` (string): Name for the new API key
+
+**Returns:** `Promise<CreateApiKeyResponse>`
+
+**Example:**
+```typescript
+const response = await codeguide.apiKeyEnhanced.createApiKey({
+  name: 'My Application'
+})
+console.log(response.data.api_key) // The new API key
+```
+
+#### revokeApiKey(apiKeyId)
+```typescript
+async revokeApiKey(apiKeyId: string): Promise<RevokeApiKeyResponse>
+```
+Revoke an API key by ID.
+
+**Parameters:**
+- `apiKeyId` (string): ID of the API key to revoke
+
+**Returns:** `Promise<RevokeApiKeyResponse>`
+
+#### checkApiKeyPermission()
+```typescript
+async checkApiKeyPermission(): Promise<ApiKeyPermissionResponse>
+```
+Check if the user can create new API keys.
+
+**Returns:** `Promise<ApiKeyPermissionResponse>`
+
+### ProjectService
+
+#### createProject(request)
+```typescript
+async createProject(request: CreateProjectRequest): Promise<ProjectResponse>
+```
+Create a new project.
+
+#### getProject(projectId)
+```typescript
+async getProject(projectId: string): Promise<ProjectResponse>
+```
+Get project details by ID.
+
+#### getAllProjects()
+```typescript
+async getAllProjects(): Promise<ProjectsListResponse>
+```
+Get all projects for the authenticated user.
+
+### TaskService
+
+#### generateTasks(request)
+```typescript
+async generateTasks(request: GenerateTasksRequest): Promise<TasksResponse>
+```
+Generate tasks for a project.
+
+#### getProjectTasks(projectId)
+```typescript
+async getProjectTasks(projectId: string): Promise<TasksResponse>
+```
+Get all tasks for a project.
+
+#### updateTask(taskId, update)
+```typescript
+async updateTask(taskId: string, update: UpdateTaskRequest): Promise<TaskResponse>
+```
+Update task status and notes.
+
+## Types
+
+### ApiKey
+```typescript
+interface ApiKey {
+  id: string
+  key: string           // Full API key string
+  user_id: string
+  name: string
+  created_at: string
+  expires_at?: string
+  is_active: boolean
+  metadata?: Record<string, any>
+}
+```
+
+### ApiKeyListResponse
+```typescript
+interface ApiKeyListResponse {
+  status: string
+  data: ApiKey[]
+}
+```
+
+### CreateApiKeyRequest
+```typescript
+interface CreateApiKeyRequest {
+  name: string
+}
+```
+
+### CreateApiKeyResponse
+```typescript
+interface CreateApiKeyResponse {
+  status: string
+  data: {
+    api_key: string
+    id: string
+    name: string
+    created_at: string
+    expires_at?: string
+    is_active: boolean
+    metadata?: Record<string, any>
+  }
+  message?: string
+}
+```
+
+### APIServiceConfig
+```typescript
+interface APIServiceConfig {
+  baseUrl: string
+  databaseApiKey?: string    // Highest priority
+  apiKey?: string           // Legacy API key
+  userId?: string           // Required for legacy auth
+  jwtToken?: string         // Clerk JWT token
+  timeout?: number          // Default: 3600000 (1 hour)
+}
+```
+
+## Error Handling
+
+The client provides detailed error information:
+
+```typescript
+try {
+  const keys = await codeguide.apiKeyEnhanced.getAllApiKeys()
+} catch (error) {
+  if (error.message.includes('401')) {
+    console.error('Authentication failed:', error.message)
+  } else if (error.message.includes('403')) {
+    console.error('Permission denied:', error.message)
+  } else if (error.message.includes('429')) {
+    console.error('Rate limited:', error.message)
+  } else {
+    console.error('API error:', error.message)
+  }
+}
+```
+
+## Configuration
+
+### Timeout Configuration
+
+```typescript
+const codeguide = new CodeGuide({
+  baseUrl: 'https://api.codeguide.ai',
+  databaseApiKey: 'sk_your_key',
+  timeout: 1800000 // 30 minutes
+})
+```
+
+### Verbose Logging
+
+```typescript
+const codeguide = new CodeGuide({
+  baseUrl: 'https://api.codeguide.ai',
+  databaseApiKey: 'sk_your_key'
+}, {
+  verbose: true // Enable detailed logging
+})
+```
+
+## Advanced Usage
+
+### Custom Headers
+
+The BaseService allows you to intercept and modify requests:
+
+```typescript
+// Access the underlying axios instance
+const client = codeguide.apiKeyEnhanced.client
+
+// Add custom headers
+client.interceptors.request.use(config => {
+  config.headers['X-Custom-Header'] = 'value'
+  return config
+})
+```
+
+### Response Interceptors
+
+```typescript
+// Add custom response handling
+client.interceptors.response.use(
+  response => response,
+  error => {
+    // Custom error handling
+    console.error('API Error:', error.response?.data)
+    return Promise.reject(error)
+  }
+)
+```
+
+## Examples
+
+### Complete API Key Management Flow
+
+```typescript
+import { CodeGuide } from '@codeguide/core'
+
+async function manageApiKeys() {
+  const codeguide = new CodeGuide({
+    baseUrl: 'https://api.codeguide.ai',
+    databaseApiKey: 'sk_your_key'
+  })
+
+  try {
+    // Check permissions
+    const permission = await codeguide.apiKeyEnhanced.checkApiKeyPermission()
+    if (!permission.data.can_create) {
+      console.log('Cannot create new keys:', permission.data.reason)
+      return
+    }
+
+    // List current keys
+    const currentKeys = await codeguide.apiKeyEnhanced.getAllApiKeys()
+    console.log(`Current keys: ${currentKeys.data.length}`)
+
+    // Create new key
+    const newKey = await codeguide.apiKeyEnhanced.createApiKey({
+      name: 'Production Application'
+    })
+    console.log('Created key:', newKey.data.api_key)
+
+    // Revoke old key if needed
+    if (currentKeys.data.length > 5) {
+      await codeguide.apiKeyEnhanced.revokeApiKey(currentKeys.data[0].id)
+      console.log('Revoked oldest key')
+    }
+
+  } catch (error) {
+    console.error('API key management failed:', error.message)
+  }
+}
+```
+
+### Project Setup with Tasks
+
+```typescript
+import { CodeGuide } from '@codeguide/core'
+
+async function setupProject() {
+  const codeguide = new CodeGuide({
+    baseUrl: 'https://api.codeguide.ai',
+    databaseApiKey: 'sk_your_key'
+  })
+
+  try {
+    // Create project
+    const project = await codeguide.projects.createProject({
+      title: 'E-commerce Platform',
+      description: 'Modern e-commerce solution with React and Node.js'
+    })
+
+    // Generate tasks
+    const tasks = await codeguide.tasks.generateTasks({
+      project_id: project.id,
+      context: 'Building a full-stack e-commerce platform'
+    })
+
+    console.log(`Created project with ${tasks.data.length} tasks`)
+
+    // Start first task
+    if (tasks.data.length > 0) {
+      await codeguide.tasks.updateTask(tasks.data[0].id, {
+        status: 'in_progress',
+        notes: 'Starting project setup'
+      })
+    }
+
+  } catch (error) {
+    console.error('Project setup failed:', error.message)
+  }
+}
+```
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Add tests
+5. Submit a pull request
+
+## Support
+
+- **Documentation**: [Main README](../../README.md)
+- **CLI Package**: [@codeguide/cli](../cli/README.md)
+- **Issues**: [GitHub Issues](https://github.com/CodeGuide-dev/codeguide/issues)
+- **Discussions**: [GitHub Discussions](https://github.com/CodeGuide-dev/codeguide/discussions)
+
+## License
+
+MIT License - see [LICENSE](../../LICENSE) file for details.

package/codeguide.ts

@@ -13,6 +13,7 @@ import {
   RepositoryAnalysisService,
   TaskService,
   ApiKeyEnhancedService,
+  SubscriptionService,
 } from './services'
 import { APIServiceConfig, CodeGuideOptions } from './types'
 
@@ -23,6 +24,7 @@ export class CodeGuide {
   public repositoryAnalysis: RepositoryAnalysisService
   public tasks: TaskService
   public apiKeyEnhanced: ApiKeyEnhancedService
+  public subscription: SubscriptionService
   private options: CodeGuideOptions
 
   constructor(config: APIServiceConfig, options: CodeGuideOptions = {}) {
@@ -35,6 +37,7 @@ export class CodeGuide {
     this.repositoryAnalysis = new RepositoryAnalysisService(config)
     this.tasks = new TaskService(config)
     this.apiKeyEnhanced = new ApiKeyEnhancedService(config)
+    this.subscription = new SubscriptionService(config)
   }
 
   // Convenience method for backward compatibility

package/dist/codeguide.d.ts

@@ -1,4 +1,4 @@
-import { GenerationService, ProjectService, UsageService, RepositoryAnalysisService, TaskService, ApiKeyEnhancedService } from './services';
+import { GenerationService, ProjectService, UsageService, RepositoryAnalysisService, TaskService, ApiKeyEnhancedService, SubscriptionService } from './services';
 import { APIServiceConfig, CodeGuideOptions } from './types';
 export declare class CodeGuide {
     generation: GenerationService;
@@ -7,6 +7,7 @@ export declare class CodeGuide {
     repositoryAnalysis: RepositoryAnalysisService;
     tasks: TaskService;
     apiKeyEnhanced: ApiKeyEnhancedService;
+    subscription: SubscriptionService;
     private options;
     constructor(config: APIServiceConfig, options?: CodeGuideOptions);
     getGuidance(prompt: string): Promise<any>;

package/dist/codeguide.js

@@ -22,6 +22,7 @@ class CodeGuide {
         this.repositoryAnalysis = new services_1.RepositoryAnalysisService(config);
         this.tasks = new services_1.TaskService(config);
         this.apiKeyEnhanced = new services_1.ApiKeyEnhancedService(config);
+        this.subscription = new services_1.SubscriptionService(config);
     }
     // Convenience method for backward compatibility
     async getGuidance(prompt) {

package/dist/services/api-key-enhanced/api-key-enhanced-service.d.ts

@@ -1,12 +1,12 @@
 import { BaseService } from '../base/base-service';
-import { ApiKey, CreateApiKeyRequest, CreateApiKeyResponse, ApiKeyPermission, RevokeApiKeyResponse } from '../../types';
+import { CreateApiKeyRequest, CreateApiKeyResponse, ApiKeyPermissionResponse, RevokeApiKeyResponse, ApiKeyListResponse, ApiKeyResponse } from '../../types';
 export declare class ApiKeyEnhancedService extends BaseService {
     constructor(config: any);
     /**
      * Get all API keys for the authenticated user
      * GET /api-key-enhanced/
      */
-    getAllApiKeys(): Promise<ApiKey[]>;
+    getAllApiKeys(): Promise<ApiKeyListResponse>;
     /**
      * Create a new API key
      * POST /api-key-enhanced/
@@ -21,32 +21,35 @@ export declare class ApiKeyEnhancedService extends BaseService {
      * Check if user can create API keys
      * GET /api-key-enhanced/check-permission
      */
-    checkApiKeyPermission(): Promise<ApiKeyPermission>;
+    checkApiKeyPermission(): Promise<ApiKeyPermissionResponse>;
     /**
      * Get API key details by ID
      * GET /api-key-enhanced/{api_key_id}
      */
-    getApiKeyById(apiKeyId: string): Promise<ApiKey>;
+    getApiKeyById(apiKeyId: string): Promise<ApiKeyResponse>;
     /**
      * Update API key name (if supported by API)
      * PUT /api-key-enhanced/{api_key_id}
      */
-    updateApiKeyName(apiKeyId: string, name: string): Promise<ApiKey>;
+    updateApiKeyName(apiKeyId: string, name: string): Promise<ApiKeyResponse>;
     /**
      * Toggle API key active status (if supported by API)
      * PATCH /api-key-enhanced/{api_key_id}/toggle
      */
-    toggleApiKeyStatus(apiKeyId: string): Promise<ApiKey>;
+    toggleApiKeyStatus(apiKeyId: string): Promise<ApiKeyResponse>;
     /**
      * Get API key usage statistics (if supported by API)
      * GET /api-key-enhanced/{api_key_id}/usage
      */
     getApiKeyUsage(apiKeyId: string): Promise<{
-        usage_count: number;
-        last_used?: string;
-        daily_usage?: Array<{
-            date: string;
-            count: number;
-        }>;
+        status: string;
+        data: {
+            usage_count: number;
+            last_used?: string;
+            daily_usage?: Array<{
+                date: string;
+                count: number;
+            }>;
+        };
     }>;
 }

package/dist/services/index.d.ts

@@ -5,9 +5,11 @@ export { UsageService } from './usage';
 export { RepositoryAnalysisService } from './repository-analysis';
 export { TaskService } from './tasks';
 export { ApiKeyEnhancedService } from './api-key-enhanced';
+export { SubscriptionService } from './subscriptions';
 export * from './generation';
 export * from './projects';
 export * from './usage';
 export * from './repository-analysis';
 export * from './tasks';
 export * from './api-key-enhanced';
+export * from './subscriptions';

package/dist/services/index.js

@@ -17,7 +17,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ApiKeyEnhancedService = exports.TaskService = exports.RepositoryAnalysisService = exports.UsageService = exports.ProjectService = exports.GenerationService = exports.BaseService = void 0;
+exports.SubscriptionService = exports.ApiKeyEnhancedService = exports.TaskService = exports.RepositoryAnalysisService = exports.UsageService = exports.ProjectService = exports.GenerationService = exports.BaseService = void 0;
 const dotenv_1 = __importDefault(require("dotenv"));
 const path_1 = __importDefault(require("path"));
 // Load environment variables from project root
@@ -39,6 +39,8 @@ var tasks_1 = require("./tasks");
 Object.defineProperty(exports, "TaskService", { enumerable: true, get: function () { return tasks_1.TaskService; } });
 var api_key_enhanced_1 = require("./api-key-enhanced");
 Object.defineProperty(exports, "ApiKeyEnhancedService", { enumerable: true, get: function () { return api_key_enhanced_1.ApiKeyEnhancedService; } });
+var subscriptions_1 = require("./subscriptions");
+Object.defineProperty(exports, "SubscriptionService", { enumerable: true, get: function () { return subscriptions_1.SubscriptionService; } });
 // Re-export all types for convenience
 __exportStar(require("./generation"), exports);
 __exportStar(require("./projects"), exports);
@@ -46,3 +48,4 @@ __exportStar(require("./usage"), exports);
 __exportStar(require("./repository-analysis"), exports);
 __exportStar(require("./tasks"), exports);
 __exportStar(require("./api-key-enhanced"), exports);
+__exportStar(require("./subscriptions"), exports);

package/dist/services/subscriptions/index.d.ts

@@ -0,0 +1 @@
+export { SubscriptionService } from './subscription-service';

package/dist/services/subscriptions/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubscriptionService = void 0;
+var subscription_service_1 = require("./subscription-service");
+Object.defineProperty(exports, "SubscriptionService", { enumerable: true, get: function () { return subscription_service_1.SubscriptionService; } });

package/dist/services/subscriptions/subscription-service.d.ts

@@ -0,0 +1,103 @@
+import { BaseService } from '../base/base-service';
+import { CurrentSubscriptionResponse, UserSubscriptionsResponse, CancelSubscriptionRequest, CancelSubscriptionResponse } from '../../types';
+export declare class SubscriptionService extends BaseService {
+    constructor(config: any);
+    /**
+     * Get the currently active subscription for the authenticated user
+     * GET /subscriptions/current
+     */
+    getCurrentSubscription(): Promise<CurrentSubscriptionResponse>;
+    /**
+     * Get all subscriptions (active and historical) for the authenticated user
+     * GET /subscriptions/
+     */
+    getAllSubscriptions(): Promise<UserSubscriptionsResponse>;
+    /**
+     * Cancel subscription but keep it active until the end of the current billing period
+     * POST /subscriptions/{subscription_id}/cancel
+     */
+    cancelSubscription(subscriptionId: string, request: CancelSubscriptionRequest): Promise<CancelSubscriptionResponse>;
+    /**
+     * Get subscription details by ID
+     * GET /subscriptions/{subscription_id}
+     */
+    getSubscriptionById(subscriptionId: string): Promise<{
+        status: string;
+        data: {
+            subscription: any;
+            product: any;
+            price: any;
+        };
+    }>;
+    /**
+     * Reactivate a canceled subscription (if supported by API)
+     * POST /subscriptions/{subscription_id}/reactivate
+     */
+    reactivateSubscription(subscriptionId: string): Promise<{
+        status: string;
+        message: string;
+        data: any;
+    }>;
+    /**
+     * Update subscription quantity or other parameters
+     * PUT /subscriptions/{subscription_id}
+     */
+    updateSubscription(subscriptionId: string, updates: {
+        quantity?: number;
+        metadata?: Record<string, any>;
+    }): Promise<{
+        status: string;
+        data: any;
+    }>;
+    /**
+     * Get subscription usage statistics (if supported by API)
+     * GET /subscriptions/{subscription_id}/usage
+     */
+    getSubscriptionUsage(subscriptionId: string): Promise<{
+        status: string;
+        data: {
+            current_usage: number;
+            limit: number;
+            period_start: string;
+            period_end: string;
+            usage_breakdown?: Array<{
+                feature: string;
+                used: number;
+                limit: number;
+            }>;
+        };
+    }>;
+    /**
+     * Get upcoming invoice for subscription
+     * GET /subscriptions/{subscription_id}/upcoming-invoice
+     */
+    getUpcomingInvoice(subscriptionId: string): Promise<{
+        status: string;
+        data: {
+            amount: number;
+            currency: string;
+            date: string;
+            line_items: Array<{
+                description: string;
+                amount: number;
+                currency: string;
+            }>;
+        };
+    }>;
+    /**
+     * Get subscription history and payments
+     * GET /subscriptions/{subscription_id}/history
+     */
+    getSubscriptionHistory(subscriptionId: string): Promise<{
+        status: string;
+        data: Array<{
+            id: string;
+            type: 'payment' | 'invoice' | 'refund';
+            amount: number;
+            currency: string;
+            status: string;
+            created: string;
+            description?: string;
+        }>;
+    }>;
+}

package/dist/services/subscriptions/subscription-service.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubscriptionService = void 0;
+const base_service_1 = require("../base/base-service");
+class SubscriptionService extends base_service_1.BaseService {
+    constructor(config) {
+        super(config);
+    }
+    /**
+     * Get the currently active subscription for the authenticated user
+     * GET /subscriptions/current
+     */
+    async getCurrentSubscription() {
+        return this.get('/subscriptions/current');
+    }
+    /**
+     * Get all subscriptions (active and historical) for the authenticated user
+     * GET /subscriptions/
+     */
+    async getAllSubscriptions() {
+        return this.get('/subscriptions/');
+    }
+    /**
+     * Cancel subscription but keep it active until the end of the current billing period
+     * POST /subscriptions/{subscription_id}/cancel
+     */
+    async cancelSubscription(subscriptionId, request) {
+        return this.post(`/subscriptions/${subscriptionId}/cancel`, request);
+    }
+    /**
+     * Get subscription details by ID
+     * GET /subscriptions/{subscription_id}
+     */
+    async getSubscriptionById(subscriptionId) {
+        return this.get(`/subscriptions/${subscriptionId}`);
+    }
+    /**
+     * Reactivate a canceled subscription (if supported by API)
+     * POST /subscriptions/{subscription_id}/reactivate
+     */
+    async reactivateSubscription(subscriptionId) {
+        return this.post(`/subscriptions/${subscriptionId}/reactivate`, {});
+    }
+    /**
+     * Update subscription quantity or other parameters
+     * PUT /subscriptions/{subscription_id}
+     */
+    async updateSubscription(subscriptionId, updates) {
+        return this.put(`/subscriptions/${subscriptionId}`, updates);
+    }
+    /**
+     * Get subscription usage statistics (if supported by API)
+     * GET /subscriptions/{subscription_id}/usage
+     */
+    async getSubscriptionUsage(subscriptionId) {
+        return this.get(`/subscriptions/${subscriptionId}/usage`);
+    }
+    /**
+     * Get upcoming invoice for subscription
+     * GET /subscriptions/{subscription_id}/upcoming-invoice
+     */
+    async getUpcomingInvoice(subscriptionId) {
+        return this.get(`/subscriptions/${subscriptionId}/upcoming-invoice`);
+    }
+    /**
+     * Get subscription history and payments
+     * GET /subscriptions/{subscription_id}/history
+     */
+    async getSubscriptionHistory(subscriptionId) {
+        return this.get(`/subscriptions/${subscriptionId}/history`);
+    }
+}
+exports.SubscriptionService = SubscriptionService;

package/dist/types.d.ts

@@ -42,31 +42,111 @@ export interface CodeGuideOptions {
 }
 export interface ApiKey {
     id: string;
+    key: string;
+    user_id: string;
     name: string;
-    prefix: string;
     created_at: string;
-    last_used?: string;
+    expires_at?: string;
     is_active: boolean;
-    usage_count?: number;
+    metadata?: Record<string, any>;
+}
+export interface ApiKeyListResponse {
+    status: string;
+    data: ApiKey[];
 }
 export interface CreateApiKeyRequest {
     name: string;
 }
 export interface CreateApiKeyResponse {
-    api_key: string;
+    status: string;
+    data: {
+        api_key: string;
+        id: string;
+        name: string;
+        created_at: string;
+        expires_at?: string;
+        is_active: boolean;
+        metadata?: Record<string, any>;
+    };
+    message?: string;
+}
+export interface ApiKeyPermissionResponse {
+    status: string;
+    data: {
+        can_create: boolean;
+        reason?: string;
+        current_keys_count?: number;
+        max_keys_allowed?: number;
+    };
+}
+export interface ApiKeyResponse {
+    status: string;
+    data: ApiKey;
+}
+export interface RevokeApiKeyResponse {
+    status: string;
+    message: string;
+    revoked_key_id?: string;
+}
+export interface Subscription {
     id: string;
+    user_id: string;
+    status: 'active' | 'canceled' | 'past_due' | 'unpaid' | 'trialing' | 'incomplete' | 'incomplete_expired';
+    metadata: Record<string, any>;
+    price_id: string;
+    quantity: number;
+    cancel_at_period_end: boolean;
+    created: string;
+    current_period_start: string;
+    current_period_end: string;
+    ended_at?: string | null;
+    cancel_at?: string | null;
+    canceled_at?: string | null;
+    trial_start?: string | null;
+    trial_end?: string | null;
+    org_id?: string | null;
+}
+export interface Product {
+    id: string;
+    active: boolean;
     name: string;
-    prefix: string;
-    created_at: string;
-    message: string;
+    description: string;
+    image: string;
+    metadata: Record<string, any>;
+    marketing_features: string[];
+    live_mode: boolean;
+    is_team_plan: boolean;
+}
+export interface Price {
+    id: string;
+    product_id: string;
+    active: boolean;
+    description: string;
+    unit_amount: number;
+    currency: string;
+    type: 'recurring' | 'one_time';
+    interval: 'day' | 'week' | 'month' | 'year';
+    interval_count: number;
+    trial_period_days?: number | null;
+    metadata?: Record<string, any> | null;
 }
-export interface ApiKeyPermission {
-    can_create: boolean;
-    reason?: string;
-    current_keys_count?: number;
-    max_keys_allowed?: number;
+export interface CurrentSubscriptionResponse {
+    status: string;
+    data: {
+        subscription: Subscription;
+        product: Product;
+        price: Price;
+    };
 }
-export interface RevokeApiKeyResponse {
+export interface UserSubscriptionsResponse {
+    status: string;
+    data: Subscription[];
+}
+export interface CancelSubscriptionRequest {
+    cancel_at_period_end: boolean;
+}
+export interface CancelSubscriptionResponse {
+    status: string;
     message: string;
-    revoked_key_id: string;
+    data: Subscription;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codeguide/core",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "Core package for code guidance with programmatic API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/services/api-key-enhanced/api-key-enhanced-service.ts

@@ -3,8 +3,10 @@ import {
   ApiKey,
   CreateApiKeyRequest,
   CreateApiKeyResponse,
-  ApiKeyPermission,
+  ApiKeyPermissionResponse,
   RevokeApiKeyResponse,
+  ApiKeyListResponse,
+  ApiKeyResponse,
 } from '../../types'
 
 export class ApiKeyEnhancedService extends BaseService {
@@ -16,8 +18,8 @@ export class ApiKeyEnhancedService extends BaseService {
    * Get all API keys for the authenticated user
    * GET /api-key-enhanced/
    */
-  async getAllApiKeys(): Promise<ApiKey[]> {
-    return this.get<ApiKey[]>('/api-key-enhanced/')
+  async getAllApiKeys(): Promise<ApiKeyListResponse> {
+    return this.get<ApiKeyListResponse>('/api-key-enhanced/')
   }
 
   /**
@@ -40,32 +42,32 @@ export class ApiKeyEnhancedService extends BaseService {
    * Check if user can create API keys
    * GET /api-key-enhanced/check-permission
    */
-  async checkApiKeyPermission(): Promise<ApiKeyPermission> {
-    return this.get<ApiKeyPermission>('/api-key-enhanced/check-permission')
+  async checkApiKeyPermission(): Promise<ApiKeyPermissionResponse> {
+    return this.get<ApiKeyPermissionResponse>('/api-key-enhanced/check-permission')
   }
 
   /**
    * Get API key details by ID
    * GET /api-key-enhanced/{api_key_id}
    */
-  async getApiKeyById(apiKeyId: string): Promise<ApiKey> {
-    return this.get<ApiKey>(`/api-key-enhanced/${apiKeyId}`)
+  async getApiKeyById(apiKeyId: string): Promise<ApiKeyResponse> {
+    return this.get<ApiKeyResponse>(`/api-key-enhanced/${apiKeyId}`)
   }
 
   /**
    * Update API key name (if supported by API)
    * PUT /api-key-enhanced/{api_key_id}
    */
-  async updateApiKeyName(apiKeyId: string, name: string): Promise<ApiKey> {
-    return this.put<ApiKey>(`/api-key-enhanced/${apiKeyId}`, { name })
+  async updateApiKeyName(apiKeyId: string, name: string): Promise<ApiKeyResponse> {
+    return this.put<ApiKeyResponse>(`/api-key-enhanced/${apiKeyId}`, { name })
   }
 
   /**
    * Toggle API key active status (if supported by API)
    * PATCH /api-key-enhanced/{api_key_id}/toggle
    */
-  async toggleApiKeyStatus(apiKeyId: string): Promise<ApiKey> {
-    return this.post<ApiKey>(`/api-key-enhanced/${apiKeyId}/toggle`, {})
+  async toggleApiKeyStatus(apiKeyId: string): Promise<ApiKeyResponse> {
+    return this.post<ApiKeyResponse>(`/api-key-enhanced/${apiKeyId}/toggle`, {})
   }
 
   /**
@@ -73,9 +75,12 @@ export class ApiKeyEnhancedService extends BaseService {
    * GET /api-key-enhanced/{api_key_id}/usage
    */
   async getApiKeyUsage(apiKeyId: string): Promise<{
-    usage_count: number
-    last_used?: string
-    daily_usage?: Array<{ date: string; count: number }>
+    status: string
+    data: {
+      usage_count: number
+      last_used?: string
+      daily_usage?: Array<{ date: string; count: number }>
+    }
   }> {
     return this.get(`/api-key-enhanced/${apiKeyId}/usage`)
   }

package/services/index.ts

@@ -14,6 +14,7 @@ export { UsageService } from './usage'
 export { RepositoryAnalysisService } from './repository-analysis'
 export { TaskService } from './tasks'
 export { ApiKeyEnhancedService } from './api-key-enhanced'
+export { SubscriptionService } from './subscriptions'
 
 // Re-export all types for convenience
 export * from './generation'
@@ -22,3 +23,4 @@ export * from './usage'
 export * from './repository-analysis'
 export * from './tasks'
 export * from './api-key-enhanced'
+export * from './subscriptions'

package/services/subscriptions/index.ts

@@ -0,0 +1 @@
+export { SubscriptionService } from './subscription-service'

package/services/subscriptions/subscription-service.ts

@@ -0,0 +1,147 @@
+import { BaseService } from '../base/base-service'
+import {
+  CurrentSubscriptionResponse,
+  UserSubscriptionsResponse,
+  CancelSubscriptionRequest,
+  CancelSubscriptionResponse,
+} from '../../types'
+
+export class SubscriptionService extends BaseService {
+  constructor(config: any) {
+    super(config)
+  }
+
+  /**
+   * Get the currently active subscription for the authenticated user
+   * GET /subscriptions/current
+   */
+  async getCurrentSubscription(): Promise<CurrentSubscriptionResponse> {
+    return this.get<CurrentSubscriptionResponse>('/subscriptions/current')
+  }
+
+  /**
+   * Get all subscriptions (active and historical) for the authenticated user
+   * GET /subscriptions/
+   */
+  async getAllSubscriptions(): Promise<UserSubscriptionsResponse> {
+    return this.get<UserSubscriptionsResponse>('/subscriptions/')
+  }
+
+  /**
+   * Cancel subscription but keep it active until the end of the current billing period
+   * POST /subscriptions/{subscription_id}/cancel
+   */
+  async cancelSubscription(
+    subscriptionId: string,
+    request: CancelSubscriptionRequest
+  ): Promise<CancelSubscriptionResponse> {
+    return this.post<CancelSubscriptionResponse>(
+      `/subscriptions/${subscriptionId}/cancel`,
+      request
+    )
+  }
+
+  /**
+   * Get subscription details by ID
+   * GET /subscriptions/{subscription_id}
+   */
+  async getSubscriptionById(subscriptionId: string): Promise<{
+    status: string
+    data: {
+      subscription: any
+      product: any
+      price: any
+    }
+  }> {
+    return this.get(`/subscriptions/${subscriptionId}`)
+  }
+
+  /**
+   * Reactivate a canceled subscription (if supported by API)
+   * POST /subscriptions/{subscription_id}/reactivate
+   */
+  async reactivateSubscription(subscriptionId: string): Promise<{
+    status: string
+    message: string
+    data: any
+  }> {
+    return this.post(`/subscriptions/${subscriptionId}/reactivate`, {})
+  }
+
+  /**
+   * Update subscription quantity or other parameters
+   * PUT /subscriptions/{subscription_id}
+   */
+  async updateSubscription(
+    subscriptionId: string,
+    updates: {
+      quantity?: number
+      metadata?: Record<string, any>
+    }
+  ): Promise<{
+    status: string
+    data: any
+  }> {
+    return this.put(`/subscriptions/${subscriptionId}`, updates)
+  }
+
+  /**
+   * Get subscription usage statistics (if supported by API)
+   * GET /subscriptions/{subscription_id}/usage
+   */
+  async getSubscriptionUsage(subscriptionId: string): Promise<{
+    status: string
+    data: {
+      current_usage: number
+      limit: number
+      period_start: string
+      period_end: string
+      usage_breakdown?: Array<{
+        feature: string
+        used: number
+        limit: number
+      }>
+    }
+  }> {
+    return this.get(`/subscriptions/${subscriptionId}/usage`)
+  }
+
+  /**
+   * Get upcoming invoice for subscription
+   * GET /subscriptions/{subscription_id}/upcoming-invoice
+   */
+  async getUpcomingInvoice(subscriptionId: string): Promise<{
+    status: string
+    data: {
+      amount: number
+      currency: string
+      date: string
+      line_items: Array<{
+        description: string
+        amount: number
+        currency: string
+      }>
+    }
+  }> {
+    return this.get(`/subscriptions/${subscriptionId}/upcoming-invoice`)
+  }
+
+  /**
+   * Get subscription history and payments
+   * GET /subscriptions/{subscription_id}/history
+   */
+  async getSubscriptionHistory(subscriptionId: string): Promise<{
+    status: string
+    data: Array<{
+      id: string
+      type: 'payment' | 'invoice' | 'refund'
+      amount: number
+      currency: string
+      status: string
+      created: string
+      description?: string
+    }>
+  }> {
+    return this.get(`/subscriptions/${subscriptionId}/history`)
+  }
+}

package/types.ts

@@ -53,12 +53,19 @@ export interface CodeGuideOptions {
 // API Key Enhanced Types
 export interface ApiKey {
   id: string
+  key: string
+  user_id: string
   name: string
-  prefix: string
   created_at: string
-  last_used?: string
+  expires_at?: string
   is_active: boolean
-  usage_count?: number
+  metadata?: Record<string, any>
+}
+
+// API Response wrapper
+export interface ApiKeyListResponse {
+  status: string
+  data: ApiKey[]
 }
 
 export interface CreateApiKeyRequest {
@@ -66,22 +73,106 @@ export interface CreateApiKeyRequest {
 }
 
 export interface CreateApiKeyResponse {
-  api_key: string
+  status: string
+  data: {
+    api_key: string
+    id: string
+    name: string
+    created_at: string
+    expires_at?: string
+    is_active: boolean
+    metadata?: Record<string, any>
+  }
+  message?: string
+}
+
+export interface ApiKeyPermissionResponse {
+  status: string
+  data: {
+    can_create: boolean
+    reason?: string
+    current_keys_count?: number
+    max_keys_allowed?: number
+  }
+}
+
+export interface ApiKeyResponse {
+  status: string
+  data: ApiKey
+}
+
+export interface RevokeApiKeyResponse {
+  status: string
+  message: string
+  revoked_key_id?: string
+}
+
+// Subscription Types
+export interface Subscription {
   id: string
+  user_id: string
+  status: 'active' | 'canceled' | 'past_due' | 'unpaid' | 'trialing' | 'incomplete' | 'incomplete_expired'
+  metadata: Record<string, any>
+  price_id: string
+  quantity: number
+  cancel_at_period_end: boolean
+  created: string
+  current_period_start: string
+  current_period_end: string
+  ended_at?: string | null
+  cancel_at?: string | null
+  canceled_at?: string | null
+  trial_start?: string | null
+  trial_end?: string | null
+  org_id?: string | null
+}
+
+export interface Product {
+  id: string
+  active: boolean
   name: string
-  prefix: string
-  created_at: string
-  message: string
+  description: string
+  image: string
+  metadata: Record<string, any>
+  marketing_features: string[]
+  live_mode: boolean
+  is_team_plan: boolean
 }
 
-export interface ApiKeyPermission {
-  can_create: boolean
-  reason?: string
-  current_keys_count?: number
-  max_keys_allowed?: number
+export interface Price {
+  id: string
+  product_id: string
+  active: boolean
+  description: string
+  unit_amount: number
+  currency: string
+  type: 'recurring' | 'one_time'
+  interval: 'day' | 'week' | 'month' | 'year'
+  interval_count: number
+  trial_period_days?: number | null
+  metadata?: Record<string, any> | null
 }
 
-export interface RevokeApiKeyResponse {
+export interface CurrentSubscriptionResponse {
+  status: string
+  data: {
+    subscription: Subscription
+    product: Product
+    price: Price
+  }
+}
+
+export interface UserSubscriptionsResponse {
+  status: string
+  data: Subscription[]
+}
+
+export interface CancelSubscriptionRequest {
+  cancel_at_period_end: boolean
+}
+
+export interface CancelSubscriptionResponse {
+  status: string
   message: string
-  revoked_key_id: string
+  data: Subscription
 }