@anymux/ui-kit 0.1.0

package/src/file-browser/providers/GitRepositoryProvider.ts

@@ -0,0 +1,376 @@
+import type { IFileBrowserProvider } from './IFileBrowserProvider';
+import type { FileBrowserItem, IconDefinition, PreviewData } from '../types/FileBrowserTypes';
+import type { IFileSystem, IGitRepo } from '@anymux/file-system';
+
+interface GitRepositoryOptions {
+  repositoryPath: string;
+  branch?: string;
+  enableLogging?: boolean;
+  fileSystem?: IFileSystem;
+  gitRepo?: IGitRepo;
+}
+
+interface GitFileInfo {
+  path: string;
+  type: 'file' | 'directory' | 'symlink';
+  size?: number;
+  lastModified?: Date;
+  sha?: string;
+  staged?: boolean;
+  modified?: boolean;
+}
+
+export class GitRepositoryProvider implements IFileBrowserProvider {
+  readonly id = 'git-repository';
+  readonly name = 'Git Repository Provider';
+  readonly version = '1.0.0';
+
+  private options: GitRepositoryOptions;
+  private fileSystem: IFileSystem | undefined;
+  private gitRepo: IGitRepo | undefined;
+
+  constructor(options: GitRepositoryOptions) {
+    this.options = {
+      branch: 'main',
+      enableLogging: false,
+      ...options
+    };
+    this.fileSystem = options.fileSystem;
+    this.gitRepo = options.gitRepo;
+  }
+
+  async loadItems(path: string): Promise<FileBrowserItem[]> {
+    try {
+      const normalizedPath = this.normalizePath(path);
+      this.log(`Loading git items for path: ${normalizedPath}`);
+
+      // Delegate to real file system if provided
+      if (this.fileSystem) {
+        return this.loadItemsFromFileSystem(normalizedPath);
+      }
+
+      // Fallback to mock data
+      const mockGitFiles = await this.getMockGitFiles(normalizedPath);
+
+      return mockGitFiles.map(file => {
+        const item: FileBrowserItem = {
+          id: file.path,
+          name: this.getFileName(file.path),
+          path: file.path,
+          type: file.type === 'directory' ? 'directory' as const : 'file' as const,
+          hasChildren: file.type === 'directory',
+          metadata: {
+            sha: file.sha,
+            staged: file.staged,
+            modified: file.modified,
+            gitStatus: this.getGitStatus(file)
+          }
+        };
+        if (file.size != null) item.size = file.size;
+        if (file.lastModified != null) item.lastModified = file.lastModified;
+        return item;
+      });
+    } catch (error) {
+      this.log(`Error loading git items: ${error}`);
+      throw new Error(`Failed to load git repository items: ${error}`);
+    }
+  }
+
+  private async loadItemsFromFileSystem(path: string): Promise<FileBrowserItem[]> {
+    if (!this.fileSystem) return [];
+
+    const entries = await this.fileSystem.readdir(path);
+    const items: FileBrowserItem[] = [];
+
+    for (const entry of entries) {
+      const entryPath = path === '/' ? `/${entry}` : `${path}/${entry}`;
+      try {
+        const stat = await this.fileSystem.stat(entryPath);
+        const isDir = stat.isDirectory();
+        const item: FileBrowserItem = {
+          id: entryPath,
+          name: String(entry),
+          path: entryPath,
+          type: isDir ? 'directory' as const : 'file' as const,
+          hasChildren: isDir,
+          lastModified: stat.mtime,
+        };
+        if (!isDir) item.size = stat.size;
+        items.push(item);
+      } catch (err) {
+        console.warn(`[GitRepositoryProvider] stat failed for ${entryPath}, skipping:`, err instanceof Error ? err.message : err);
+      }
+    }
+
+    return items;
+  }
+
+  normalizePath(path: string): string {
+    if (!path || path === '') return '/';
+
+    let normalized = path.replace(/\\/g, '/');
+    normalized = normalized.replace(/\/+/g, '/');
+
+    if (normalized.length > 1 && normalized.endsWith('/')) {
+      normalized = normalized.slice(0, -1);
+    }
+
+    if (!normalized.startsWith('/')) {
+      normalized = '/' + normalized;
+    }
+
+    return normalized;
+  }
+
+  getParentPath(path: string): string | null {
+    const normalized = this.normalizePath(path);
+    if (normalized === '/') return null;
+
+    const parts = normalized.split('/').filter(Boolean);
+    parts.pop();
+
+    return parts.length === 0 ? '/' : '/' + parts.join('/');
+  }
+
+  resolvePath(basePath: string, relativePath: string): string {
+    if (relativePath.startsWith('/')) {
+      return this.normalizePath(relativePath);
+    }
+
+    const base = this.normalizePath(basePath);
+    const resolved = base === '/' ? `/${relativePath}` : `${base}/${relativePath}`;
+    return this.normalizePath(resolved);
+  }
+
+  getItemIcon(item: FileBrowserItem): IconDefinition {
+    const gitStatus = item.metadata?.gitStatus;
+
+    if (item.type === 'directory') {
+      if (gitStatus === 'modified') {
+        return { type: 'lucide', name: 'folder-edit', color: '#f59e0b' };
+      }
+      if (gitStatus === 'staged') {
+        return { type: 'lucide', name: 'folder-check', color: '#10b981' };
+      }
+      return { type: 'lucide', name: 'folder-git-2', color: '#3b82f6' };
+    }
+
+    const ext = item.name.split('.').pop()?.toLowerCase();
+    const baseIcon = this.getBaseFileIcon(ext);
+
+    let color = baseIcon.color;
+    if (gitStatus === 'modified') {
+      color = '#f59e0b';
+    } else if (gitStatus === 'staged') {
+      color = '#10b981';
+    } else if (gitStatus === 'untracked') {
+      color = '#ef4444';
+    }
+
+    const result: IconDefinition = { type: baseIcon.type };
+    if (baseIcon.name) result.name = baseIcon.name;
+    if (color) result.color = color;
+    return result;
+  }
+
+  private getBaseFileIcon(ext?: string): IconDefinition {
+    const iconMap: Record<string, string> = {
+      'gitignore': 'git-branch',
+      'gitattributes': 'git-branch',
+      'gitmodules': 'git-branch',
+      'js': 'file-code',
+      'ts': 'file-code',
+      'jsx': 'file-code',
+      'tsx': 'file-code',
+      'vue': 'file-code',
+      'html': 'file-code',
+      'css': 'file-code',
+      'scss': 'file-code',
+      'json': 'file-code',
+      'yaml': 'file-code',
+      'yml': 'file-code',
+      'md': 'file-text',
+      'txt': 'file-text',
+      'rst': 'file-text',
+      'png': 'image',
+      'jpg': 'image',
+      'jpeg': 'image',
+      'gif': 'image',
+      'svg': 'image',
+      'webp': 'image',
+      'toml': 'settings',
+      'ini': 'settings',
+      'conf': 'settings',
+      'zip': 'file-archive',
+      'tar': 'file-archive',
+      'gz': 'file-archive',
+      'pdf': 'file-text',
+      'lock': 'lock',
+    };
+
+    return {
+      type: 'lucide',
+      name: iconMap[ext || ''] || 'file',
+      color: '#6b7280'
+    };
+  }
+
+  getItemDisplayName(item: FileBrowserItem): string {
+    const gitStatus = item.metadata?.gitStatus;
+
+    const statusIndicators: Record<string, string> = {
+      'modified': ' ●',
+      'staged': ' ✓',
+      'untracked': ' ?',
+      'deleted': ' ✗',
+    };
+
+    const indicator = gitStatus ? statusIndicators[gitStatus] || '' : '';
+    return item.name + indicator;
+  }
+
+  async getItemPreview(item: FileBrowserItem): Promise<PreviewData | null> {
+    if (item.type === 'file') {
+      const ext = item.name.split('.').pop()?.toLowerCase();
+
+      if (['gitignore', 'gitattributes', 'gitmodules'].includes(ext || '')) {
+        return {
+          type: 'text',
+          content: `Git configuration file: ${item.name}`
+        };
+      }
+
+      if (['png', 'jpg', 'jpeg', 'gif', 'svg', 'webp'].includes(ext || '')) {
+        return {
+          type: 'image',
+          url: `git-blob://${this.options.repositoryPath}/${item.path}`
+        };
+      }
+
+      // Read file content from real file system if available
+      if (this.fileSystem && ['txt', 'md', 'json', 'js', 'ts', 'css', 'html', 'yaml', 'yml'].includes(ext || '')) {
+        try {
+          const content = await this.fileSystem.readFile(item.path, 'utf-8');
+          return {
+            type: 'text',
+            content: typeof content === 'string' ? content.slice(0, 4096) : 'Binary file'
+          };
+        } catch {
+          return { type: 'text', content: 'Unable to read file' };
+        }
+      }
+    }
+
+    return null;
+  }
+
+  canPerformAction(action: string, items: FileBrowserItem[]): boolean {
+    const gitActions = ['stage', 'unstage', 'commit', 'revert', 'diff', 'blame'];
+    const basicActions = ['view', 'copy'];
+
+    const supportedActions = [...gitActions, ...basicActions];
+    return supportedActions.includes(action) && items.length > 0;
+  }
+
+  async performAction(action: string, items: FileBrowserItem[]): Promise<any> {
+    this.log(`Performing git action ${action} on items:`, items);
+
+    switch (action) {
+      case 'stage':
+        return { success: true, message: `Staged ${items.length} files` };
+      case 'unstage':
+        return { success: true, message: `Unstaged ${items.length} files` };
+      case 'commit':
+        return { success: true, message: 'Commit created' };
+      case 'revert':
+        return { success: true, message: `Reverted ${items.length} files` };
+      case 'diff':
+        return { success: true, data: 'Diff content would go here' };
+      case 'blame':
+        return { success: true, data: 'Blame information would go here' };
+      default:
+        return { success: true, message: `${action} completed` };
+    }
+  }
+
+  async initialize(): Promise<void> {
+    this.log(`Initializing git repository provider for ${this.options.repositoryPath}`);
+  }
+
+  dispose(): void {
+    this.log('Disposing git repository provider');
+  }
+
+  // Git-specific methods
+  async getCurrentBranch(): Promise<string> {
+    if (this.gitRepo) {
+      const branches = await this.gitRepo.listBranches();
+      const defaultBranch = branches.find(b => b.isDefault);
+      return defaultBranch?.name || this.options.branch || 'main';
+    }
+    return this.options.branch || 'main';
+  }
+
+  async getBranches(): Promise<string[]> {
+    if (this.gitRepo) {
+      const branches = await this.gitRepo.listBranches();
+      return branches.map(b => b.name);
+    }
+    return ['main', 'develop', 'feature/new-feature'];
+  }
+
+  async switchBranch(branch: string): Promise<void> {
+    this.log(`Switching to branch: ${branch}`);
+    this.options.branch = branch;
+  }
+
+  async getCommitHistory(path?: string, limit = 50): Promise<any[]> {
+    if (this.gitRepo) {
+      const options: { path?: string; maxCount?: number } = { maxCount: limit };
+      if (path != null) options.path = path;
+      return this.gitRepo.listCommits(options);
+    }
+    return [];
+  }
+
+  // Private helper methods
+  private async getMockGitFiles(path: string): Promise<GitFileInfo[]> {
+    const mockFiles: Record<string, GitFileInfo[]> = {
+      '/': [
+        { path: '/src', type: 'directory', lastModified: new Date() },
+        { path: '/docs', type: 'directory', lastModified: new Date() },
+        { path: '/package.json', type: 'file', size: 1024, lastModified: new Date(), sha: 'abc123', modified: true },
+        { path: '/README.md', type: 'file', size: 2048, lastModified: new Date(), sha: 'def456' },
+        { path: '/.gitignore', type: 'file', size: 512, lastModified: new Date(), sha: 'ghi789' },
+      ],
+      '/src': [
+        { path: '/src/index.ts', type: 'file', size: 4096, lastModified: new Date(), sha: 'jkl012', staged: true },
+        { path: '/src/components', type: 'directory', lastModified: new Date() },
+        { path: '/src/utils.ts', type: 'file', size: 1536, lastModified: new Date(), sha: 'mno345', modified: true },
+      ],
+      '/docs': [
+        { path: '/docs/guide.md', type: 'file', size: 8192, lastModified: new Date(), sha: 'pqr678' },
+        { path: '/docs/api.md', type: 'file', size: 6144, lastModified: new Date(), sha: 'stu901' },
+      ]
+    };
+
+    return mockFiles[path] || [];
+  }
+
+  private getFileName(path: string): string {
+    const parts = path.split('/');
+    return parts[parts.length - 1] || path;
+  }
+
+  private getGitStatus(file: GitFileInfo): string {
+    if (file.staged) return 'staged';
+    if (file.modified) return 'modified';
+    return 'tracked';
+  }
+
+  private log(message: string, ...args: any[]): void {
+    if (this.options.enableLogging) {
+      console.log(`[GitRepositoryProvider] ${message}`, ...args);
+    }
+  }
+}

package/src/file-browser/providers/IFileBrowserProvider.ts

@@ -0,0 +1,56 @@
+import { FileBrowserItem, IconDefinition, PreviewData } from '../types/FileBrowserTypes';
+import { LeftPanelMode } from '../models/LeftPanelManagerModel';
+import { ViewModeDefinition } from '../models/RightPanelManagerModel';
+
+export interface IFileBrowserProvider {
+  // Identification
+  readonly id: string;
+  readonly name: string;
+  readonly version: string;
+
+  // Core data operations
+  loadItems(path: string): Promise<FileBrowserItem[]>;
+  
+  // Dual-panel support
+  getLeftPanelModes?(): LeftPanelMode[];
+  getRightPanelViewModes?(): ViewModeDefinition[];
+  
+  // Path operations
+  normalizePath?(path: string): string;
+  getParentPath?(path: string): string | null;
+  resolvePath?(basePath: string, relativePath: string): string;
+  
+  // Item customization
+  getItemIcon?(item: FileBrowserItem): IconDefinition;
+  getItemPreview?(item: FileBrowserItem): Promise<PreviewData | null>;
+  getItemDisplayName?(item: FileBrowserItem): string;
+  
+  // File preview capabilities
+  canPreviewFile?(item: FileBrowserItem): boolean;
+  getFilePreview?(item: FileBrowserItem): Promise<PreviewData>;
+  
+  // Optional capabilities
+  canPerformAction?(action: string, items: FileBrowserItem[]): boolean;
+  performAction?(action: string, items: FileBrowserItem[]): Promise<any>;
+  
+  // Lifecycle
+  initialize?(): Promise<void>;
+  dispose?(): void;
+}
+
+export interface ProviderCapabilities {
+  canCreate: boolean;
+  canRead: boolean;
+  canUpdate: boolean;
+  canDelete: boolean;
+  canMove: boolean;
+  canCopy: boolean;
+  canRename: boolean;
+  supportsNavigation: boolean;
+  supportsSelection: boolean;
+  supportsHierarchy: boolean;
+  // Panel capabilities
+  supportsLeftPanelModes: boolean;
+  supportsRightPanelViewModes: boolean;
+  supportsFilePreview: boolean;
+}