@deimoscloud/coreai 0.1.8 → 0.1.10

package/src/adapters/native/filesystem.ts

@@ -1,393 +0,0 @@
-/**
- * Native Filesystem Adapter
- *
- * Implements StateProviderAdapter using the Node.js filesystem APIs.
- * Used for local KnowledgeLibrary storage when no MCP server is available.
- */
-
-import { promises as fs } from 'fs';
-import { join, dirname, resolve } from 'path';
-import type { StateProviderAdapter } from '../interfaces.js';
-import type { AdapterInfo, StateEntry, StateOptions } from '../types.js';
-import { AdapterError } from '../types.js';
-
-/**
- * Options for creating a filesystem adapter
- */
-export interface FilesystemAdapterOptions {
-  /**
-   * Base directory for all operations (paths are relative to this)
-   */
-  basePath: string;
-
-  /**
-   * Default encoding for read/write operations
-   */
-  defaultEncoding?: BufferEncoding;
-}
-
-/**
- * Native filesystem adapter for local state management
- */
-export class FilesystemAdapter implements StateProviderAdapter {
-  private basePath: string;
-  private defaultEncoding: BufferEncoding;
-  private connected = false;
-
-  constructor(options: FilesystemAdapterOptions) {
-    this.basePath = resolve(options.basePath);
-    this.defaultEncoding = options.defaultEncoding ?? 'utf-8';
-  }
-
-  /**
-   * Get adapter info
-   */
-  getInfo(): AdapterInfo {
-    return {
-      type: 'state',
-      provider: 'filesystem',
-      implementation: 'native',
-      connected: this.connected,
-    };
-  }
-
-  /**
-   * Check if connected (base path exists and is accessible)
-   */
-  isConnected(): boolean {
-    return this.connected;
-  }
-
-  /**
-   * Connect to the filesystem (verify base path exists)
-   */
-  async connect(): Promise<void> {
-    try {
-      const stat = await fs.stat(this.basePath);
-      if (!stat.isDirectory()) {
-        throw new AdapterError(
-          `Base path is not a directory: ${this.basePath}`,
-          'connection_failed',
-          this.getInfo()
-        );
-      }
-      this.connected = true;
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-        // Create the base directory
-        await fs.mkdir(this.basePath, { recursive: true });
-        this.connected = true;
-      } else {
-        throw new AdapterError(
-          `Failed to connect to filesystem: ${error instanceof Error ? error.message : String(error)}`,
-          'connection_failed',
-          this.getInfo(),
-          error instanceof Error ? error : undefined
-        );
-      }
-    }
-  }
-
-  /**
-   * Disconnect (no-op for filesystem)
-   */
-  async disconnect(): Promise<void> {
-    this.connected = false;
-  }
-
-  /**
-   * Read content from a file
-   */
-  async read(path: string, options?: StateOptions): Promise<string> {
-    this.ensureConnected();
-    const fullPath = this.resolvePath(path);
-    const encoding = options?.encoding ?? this.defaultEncoding;
-
-    try {
-      return await fs.readFile(fullPath, { encoding });
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-        throw new AdapterError(`File not found: ${path}`, 'not_found', this.getInfo());
-      }
-      throw new AdapterError(
-        `Failed to read file: ${error instanceof Error ? error.message : String(error)}`,
-        'operation_failed',
-        this.getInfo(),
-        error instanceof Error ? error : undefined
-      );
-    }
-  }
-
-  /**
-   * Write content to a file
-   */
-  async write(path: string, content: string, options?: StateOptions): Promise<void> {
-    this.ensureConnected();
-    const fullPath = this.resolvePath(path);
-    const encoding = options?.encoding ?? this.defaultEncoding;
-
-    try {
-      if (options?.recursive) {
-        await fs.mkdir(dirname(fullPath), { recursive: true });
-      }
-      await fs.writeFile(fullPath, content, { encoding });
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-        throw new AdapterError(
-          `Parent directory does not exist: ${dirname(path)}`,
-          'not_found',
-          this.getInfo()
-        );
-      }
-      throw new AdapterError(
-        `Failed to write file: ${error instanceof Error ? error.message : String(error)}`,
-        'operation_failed',
-        this.getInfo(),
-        error instanceof Error ? error : undefined
-      );
-    }
-  }
-
-  /**
-   * Check if a path exists
-   */
-  async exists(path: string): Promise<boolean> {
-    this.ensureConnected();
-    const fullPath = this.resolvePath(path);
-
-    try {
-      await fs.access(fullPath);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  /**
-   * List entries in a directory
-   */
-  async list(path: string): Promise<StateEntry[]> {
-    this.ensureConnected();
-    const fullPath = this.resolvePath(path);
-
-    try {
-      const entries = await fs.readdir(fullPath, { withFileTypes: true });
-      const results: StateEntry[] = [];
-
-      for (const entry of entries) {
-        const entryPath = join(path, entry.name);
-        const stat = await fs.stat(join(fullPath, entry.name));
-
-        const stateEntry: StateEntry = {
-          path: entryPath,
-          name: entry.name,
-          type: entry.isDirectory() ? 'directory' : 'file',
-        };
-
-        if (!entry.isDirectory()) {
-          stateEntry.size = stat.size;
-        }
-
-        stateEntry.modified_at = stat.mtime.toISOString();
-
-        results.push(stateEntry);
-      }
-
-      return results;
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-        throw new AdapterError(`Directory not found: ${path}`, 'not_found', this.getInfo());
-      }
-      if ((error as NodeJS.ErrnoException).code === 'ENOTDIR') {
-        throw new AdapterError(
-          `Path is not a directory: ${path}`,
-          'invalid_operation',
-          this.getInfo()
-        );
-      }
-      throw new AdapterError(
-        `Failed to list directory: ${error instanceof Error ? error.message : String(error)}`,
-        'operation_failed',
-        this.getInfo(),
-        error instanceof Error ? error : undefined
-      );
-    }
-  }
-
-  /**
-   * Delete a file or directory
-   */
-  async delete(path: string, options?: StateOptions): Promise<void> {
-    this.ensureConnected();
-    const fullPath = this.resolvePath(path);
-
-    try {
-      const stat = await fs.stat(fullPath);
-
-      if (stat.isDirectory()) {
-        if (options?.recursive) {
-          await fs.rm(fullPath, { recursive: true, force: true });
-        } else {
-          await fs.rmdir(fullPath);
-        }
-      } else {
-        await fs.unlink(fullPath);
-      }
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-        // Already deleted, not an error
-        return;
-      }
-      if ((error as NodeJS.ErrnoException).code === 'ENOTEMPTY') {
-        throw new AdapterError(
-          `Directory not empty: ${path}. Use recursive option to delete non-empty directories.`,
-          'invalid_operation',
-          this.getInfo()
-        );
-      }
-      throw new AdapterError(
-        `Failed to delete: ${error instanceof Error ? error.message : String(error)}`,
-        'operation_failed',
-        this.getInfo(),
-        error instanceof Error ? error : undefined
-      );
-    }
-  }
-
-  /**
-   * Create a directory
-   */
-  async mkdir(path: string, options?: StateOptions): Promise<void> {
-    this.ensureConnected();
-    const fullPath = this.resolvePath(path);
-
-    try {
-      await fs.mkdir(fullPath, { recursive: options?.recursive ?? false });
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === 'EEXIST') {
-        // Directory already exists, not an error
-        return;
-      }
-      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-        throw new AdapterError(
-          `Parent directory does not exist: ${dirname(path)}. Use recursive option.`,
-          'not_found',
-          this.getInfo()
-        );
-      }
-      throw new AdapterError(
-        `Failed to create directory: ${error instanceof Error ? error.message : String(error)}`,
-        'operation_failed',
-        this.getInfo(),
-        error instanceof Error ? error : undefined
-      );
-    }
-  }
-
-  /**
-   * Move/rename a file or directory
-   */
-  async move(source: string, destination: string): Promise<void> {
-    this.ensureConnected();
-    const sourcePath = this.resolvePath(source);
-    const destPath = this.resolvePath(destination);
-
-    try {
-      await fs.rename(sourcePath, destPath);
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-        throw new AdapterError(`Source not found: ${source}`, 'not_found', this.getInfo());
-      }
-      throw new AdapterError(
-        `Failed to move: ${error instanceof Error ? error.message : String(error)}`,
-        'operation_failed',
-        this.getInfo(),
-        error instanceof Error ? error : undefined
-      );
-    }
-  }
-
-  /**
-   * Copy a file or directory
-   */
-  async copy(source: string, destination: string): Promise<void> {
-    this.ensureConnected();
-    const sourcePath = this.resolvePath(source);
-    const destPath = this.resolvePath(destination);
-
-    try {
-      const stat = await fs.stat(sourcePath);
-
-      if (stat.isDirectory()) {
-        await this.copyDirectory(sourcePath, destPath);
-      } else {
-        await fs.copyFile(sourcePath, destPath);
-      }
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-        throw new AdapterError(`Source not found: ${source}`, 'not_found', this.getInfo());
-      }
-      throw new AdapterError(
-        `Failed to copy: ${error instanceof Error ? error.message : String(error)}`,
-        'operation_failed',
-        this.getInfo(),
-        error instanceof Error ? error : undefined
-      );
-    }
-  }
-
-  /**
-   * Resolve a relative path to the full filesystem path
-   */
-  private resolvePath(path: string): string {
-    // Prevent path traversal attacks
-    const resolved = resolve(this.basePath, path);
-    if (!resolved.startsWith(this.basePath)) {
-      throw new AdapterError(
-        `Invalid path: ${path} (path traversal not allowed)`,
-        'invalid_operation',
-        this.getInfo()
-      );
-    }
-    return resolved;
-  }
-
-  /**
-   * Ensure the adapter is connected
-   */
-  private ensureConnected(): void {
-    if (!this.connected) {
-      throw new AdapterError(
-        'Filesystem adapter is not connected. Call connect() first.',
-        'not_connected',
-        this.getInfo()
-      );
-    }
-  }
-
-  /**
-   * Recursively copy a directory
-   */
-  private async copyDirectory(source: string, dest: string): Promise<void> {
-    await fs.mkdir(dest, { recursive: true });
-    const entries = await fs.readdir(source, { withFileTypes: true });
-
-    for (const entry of entries) {
-      const srcPath = join(source, entry.name);
-      const destPath = join(dest, entry.name);
-
-      if (entry.isDirectory()) {
-        await this.copyDirectory(srcPath, destPath);
-      } else {
-        await fs.copyFile(srcPath, destPath);
-      }
-    }
-  }
-}
-
-/**
- * Create a filesystem adapter
- */
-export function createFilesystemAdapter(options: FilesystemAdapterOptions): FilesystemAdapter {
-  return new FilesystemAdapter(options);
-}

package/src/adapters/native/github.test.ts

@@ -1,173 +0,0 @@
-/**
- * Native GitHub Adapter Tests
- */
-
-import { GitHubAdapter, createGitHubAdapter } from './github.js';
-import type { GitHubAdapterOptions } from './github.js';
-import { AdapterError } from '../types.js';
-
-describe('GitHubAdapter', () => {
-  describe('constructor', () => {
-    it('should create adapter with valid repository', () => {
-      const adapter = new GitHubAdapter({ repository: 'owner/repo' });
-      expect(adapter).toBeInstanceOf(GitHubAdapter);
-    });
-
-    it('should use default gh path', () => {
-      const adapter = new GitHubAdapter({ repository: 'owner/repo' });
-      const info = adapter.getInfo();
-      expect(info.provider).toBe('github');
-    });
-
-    it('should accept custom gh path', () => {
-      const adapter = new GitHubAdapter({
-        repository: 'owner/repo',
-        ghPath: '/usr/local/bin/gh',
-      });
-      expect(adapter).toBeInstanceOf(GitHubAdapter);
-    });
-
-    it('should throw for invalid repository format', () => {
-      expect(() => new GitHubAdapter({ repository: 'invalid' })).toThrow(AdapterError);
-    });
-
-    it('should throw for empty owner', () => {
-      expect(() => new GitHubAdapter({ repository: '/repo' })).toThrow(AdapterError);
-    });
-
-    it('should throw for empty repo', () => {
-      expect(() => new GitHubAdapter({ repository: 'owner/' })).toThrow(AdapterError);
-    });
-  });
-
-  describe('getInfo', () => {
-    it('should return adapter info', () => {
-      const adapter = new GitHubAdapter({ repository: 'owner/repo' });
-      const info = adapter.getInfo();
-
-      expect(info.type).toBe('git');
-      expect(info.provider).toBe('github');
-      expect(info.implementation).toBe('native');
-      expect(info.connected).toBe(false);
-    });
-
-    it('should reflect connection status', () => {
-      const adapter = new GitHubAdapter({ repository: 'owner/repo' });
-
-      expect(adapter.getInfo().connected).toBe(false);
-      expect(adapter.isConnected()).toBe(false);
-    });
-  });
-
-  describe('isConnected', () => {
-    it('should return false initially', () => {
-      const adapter = new GitHubAdapter({ repository: 'owner/repo' });
-      expect(adapter.isConnected()).toBe(false);
-    });
-  });
-
-  describe('disconnect', () => {
-    it('should disconnect successfully', async () => {
-      const adapter = new GitHubAdapter({ repository: 'owner/repo' });
-      await adapter.disconnect();
-      expect(adapter.isConnected()).toBe(false);
-    });
-  });
-
-  describe('operations without connection', () => {
-    let adapter: GitHubAdapter;
-
-    beforeEach(() => {
-      adapter = new GitHubAdapter({ repository: 'owner/repo' });
-    });
-
-    it('should throw on getPullRequest without connection', async () => {
-      await expect(adapter.getPullRequest(1)).rejects.toThrow(AdapterError);
-    });
-
-    it('should throw on listPullRequests without connection', async () => {
-      await expect(adapter.listPullRequests()).rejects.toThrow(AdapterError);
-    });
-
-    it('should throw on createPullRequest without connection', async () => {
-      await expect(
-        adapter.createPullRequest({
-          title: 'Test PR',
-          source_branch: 'feature',
-          target_branch: 'main',
-        })
-      ).rejects.toThrow(AdapterError);
-    });
-
-    it('should throw on updatePullRequest without connection', async () => {
-      await expect(adapter.updatePullRequest(1, { title: 'New title' })).rejects.toThrow(
-        AdapterError
-      );
-    });
-
-    it('should throw on mergePullRequest without connection', async () => {
-      await expect(adapter.mergePullRequest(1)).rejects.toThrow(AdapterError);
-    });
-
-    it('should throw on closePullRequest without connection', async () => {
-      await expect(adapter.closePullRequest(1)).rejects.toThrow(AdapterError);
-    });
-
-    it('should throw on addReview without connection', async () => {
-      await expect(adapter.addReview(1, { decision: 'approved' })).rejects.toThrow(AdapterError);
-    });
-
-    it('should throw on getReviews without connection', async () => {
-      await expect(adapter.getReviews(1)).rejects.toThrow(AdapterError);
-    });
-
-    it('should throw on requestReviewers without connection', async () => {
-      await expect(adapter.requestReviewers(1, ['reviewer'])).rejects.toThrow(AdapterError);
-    });
-
-    it('should throw on addPullRequestComment without connection', async () => {
-      await expect(adapter.addPullRequestComment(1, 'comment')).rejects.toThrow(AdapterError);
-    });
-
-    it('should throw on getPullRequestDiff without connection', async () => {
-      await expect(adapter.getPullRequestDiff(1)).rejects.toThrow(AdapterError);
-    });
-
-    it('should throw on getPullRequestFiles without connection', async () => {
-      await expect(adapter.getPullRequestFiles(1)).rejects.toThrow(AdapterError);
-    });
-  });
-});
-
-describe('createGitHubAdapter', () => {
-  it('should create adapter instance', () => {
-    const adapter = createGitHubAdapter({ repository: 'owner/repo' });
-    expect(adapter).toBeInstanceOf(GitHubAdapter);
-  });
-
-  it('should accept all options', () => {
-    const options: GitHubAdapterOptions = {
-      repository: 'owner/repo',
-      ghPath: '/custom/gh',
-    };
-
-    const adapter = createGitHubAdapter(options);
-    expect(adapter).toBeInstanceOf(GitHubAdapter);
-  });
-});
-
-describe('GitHubAdapter internal mapping', () => {
-  // These tests verify the internal state mapping logic by checking
-  // the adapter info since we can't easily test the gh CLI calls
-
-  it('should handle string PR number', () => {
-    const adapter = new GitHubAdapter({ repository: 'owner/repo' });
-    // Verify adapter was created - the actual PR operations would need gh CLI
-    expect(adapter.getInfo().type).toBe('git');
-  });
-
-  it('should handle numeric PR number', () => {
-    const adapter = new GitHubAdapter({ repository: 'owner/repo' });
-    expect(adapter.getInfo().type).toBe('git');
-  });
-});