thatgfsj-code 0.2.1 → 0.2.2

package/src/utils/memory.ts

@@ -1,223 +0,0 @@
-/**
- * Session Memory - Remember modifications during conversation
- */
-
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
-import { join, dirname } from 'path';
-import { homedir } from 'os';
-
-export interface MemoryEntry {
-  id: string;
-  timestamp: number;
-  type: 'file_read' | 'file_write' | 'file_edit' | 'command' | 'git' | 'note';
-  description: string;
-  details: Record<string, any>;
-}
-
-export class SessionMemory {
-  private entries: MemoryEntry[] = [];
-  private sessionId: string;
-  private memoryFile?: string;
-
-  constructor(sessionId?: string) {
-    this.sessionId = sessionId || this.generateId();
-  }
-
-  /**
-   * Add an entry to memory
-   */
-  add(entry: Omit<MemoryEntry, 'id' | 'timestamp'>): void {
-    this.entries.push({
-      ...entry,
-      id: this.generateId(),
-      timestamp: Date.now()
-    });
-  }
-
-  /**
-   * Record file read
-   */
-  recordRead(path: string, lines?: number): void {
-    this.add({
-      type: 'file_read',
-      description: `Read ${path}`,
-      details: { path, lines }
-    });
-  }
-
-  /**
-   * Record file write
-   */
-  recordWrite(path: string, content?: string): void {
-    this.add({
-      type: 'file_write',
-      description: `Wrote ${path}`,
-      details: { path, size: content?.length || 0 }
-    });
-  }
-
-  /**
-   * Record file edit
-   */
-  recordEdit(path: string, operation: string): void {
-    this.add({
-      type: 'file_edit',
-      description: `Edited ${path}: ${operation}`,
-      details: { path, operation }
-    });
-  }
-
-  /**
-   * Record command execution
-   */
-  recordCommand(command: string, output?: string): void {
-    this.add({
-      type: 'command',
-      description: `Executed: ${command}`,
-      details: { command, output: output?.slice(0, 200) }
-    });
-  }
-
-  /**
-   * Record git operation
-   */
-  recordGit(operation: string, result: string): void {
-    this.add({
-      type: 'git',
-      description: `Git ${operation}`,
-      details: { operation, result: result.slice(0, 200) }
-    });
-  }
-
-  /**
-   * Record a note
-   */
-  recordNote(note: string): void {
-    this.add({
-      type: 'note',
-      description: note,
-      details: {}
-    });
-  }
-
-  /**
-   * Get all entries
-   */
-  getEntries(): MemoryEntry[] {
-    return [...this.entries];
-  }
-
-  /**
-   * Get recent entries
-   */
-  getRecent(count: number = 10): MemoryEntry[] {
-    return this.entries.slice(-count);
-  }
-
-  /**
-   * Get entries by type
-   */
-  getByType(type: MemoryEntry['type']): MemoryEntry[] {
-    return this.entries.filter(e => e.type === type);
-  }
-
-  /**
-   * Search entries
-   */
-  search(query: string): MemoryEntry[] {
-    const lower = query.toLowerCase();
-    return this.entries.filter(e => 
-      e.description.toLowerCase().includes(lower) ||
-      JSON.stringify(e.details).toLowerCase().includes(lower)
-    );
-  }
-
-  /**
-   * Get summary
-   */
-  getSummary(): string {
-    if (this.entries.length === 0) {
-      return 'No actions recorded yet.';
-    }
-
-    const types = this.entries.reduce((acc, e) => {
-      acc[e.type] = (acc[e.type] || 0) + 1;
-      return acc;
-    }, {} as Record<string, number>);
-
-    const lines = ['📋 Session Summary:'];
-    
-    for (const [type, count] of Object.entries(types)) {
-      const emoji = {
-        'file_read': '📖',
-        'file_write': '✍️',
-        'file_edit': '📝',
-        'command': '⚡',
-        'git': '📊',
-        'note': '📌'
-      }[type] || '•';
-      
-      lines.push(`  ${emoji} ${type}: ${count}`);
-    }
-
-    return lines.join('\n');
-  }
-
-  /**
-   * Export to file
-   */
-  save(): void {
-    if (!this.memoryFile) {
-      const homeDir = homedir();
-      const memDir = join(homeDir, '.thatgfsj', 'memory');
-      
-      if (!existsSync(memDir)) {
-        mkdirSync(memDir, { recursive: true });
-      }
-      
-      this.memoryFile = join(memDir, `${this.sessionId}.json`);
-    }
-
-    writeFileSync(this.memoryFile, JSON.stringify({
-      sessionId: this.sessionId,
-      entries: this.entries,
-      savedAt: Date.now()
-    }, null, 2));
-  }
-
-  /**
-   * Load from file
-   */
-  load(sessionId: string): boolean {
-    const homeDir = homedir();
-    const memoryFile = join(homeDir, '.thatgfsj', 'memory', `${sessionId}.json`);
-    
-    if (!existsSync(memoryFile)) {
-      return false;
-    }
-
-    try {
-      const data = JSON.parse(readFileSync(memoryFile, 'utf-8'));
-      this.entries = data.entries || [];
-      this.sessionId = data.sessionId;
-      this.memoryFile = memoryFile;
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  /**
-   * Clear memory
-   */
-  clear(): void {
-    this.entries = [];
-  }
-
-  /**
-   * Generate unique ID
-   */
-  private generateId(): string {
-    return `${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-  }
-}

package/src/utils/project-context.ts

@@ -1,207 +0,0 @@
-/**
- * Project Context - Auto-detect and read project files
- */
-
-import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
-import { join, relative } from 'path';
-
-export interface ProjectInfo {
-  root: string;
-  name: string;
-  language: string;
-  buildTool?: string;
-  gitIgnore: string[];
-  files: string[];
-  hasGit: boolean;
-  packageJson?: PackageJson;
-}
-
-export interface PackageJson {
-  name: string;
-  version: string;
-  description?: string;
-  scripts?: Record<string, string>;
-  dependencies?: Record<string, string>;
-  devDependencies?: Record<string, string>;
-}
-
-export class ProjectContext {
-  private root: string;
-
-  constructor(root: string = process.cwd()) {
-    this.root = root;
-  }
-
-  /**
-   * Detect project type and gather context
-   */
-  async detect(): Promise<ProjectInfo> {
-    const info: ProjectInfo = {
-      root: this.root,
-      name: this.getProjectName(),
-      language: this.detectLanguage(),
-      buildTool: this.detectBuildTool(),
-      gitIgnore: this.readGitIgnore(),
-      files: this.listFiles(),
-      hasGit: existsSync(join(this.root, '.git'))
-    };
-
-    const pkg = this.readPackageJson();
-    if (pkg) {
-      info.packageJson = pkg;
-    }
-
-    return info;
-  }
-
-  /**
-   * Get project name
-   */
-  private getProjectName(): string {
-    const pkg = this.readPackageJson();
-    if (pkg?.name) {
-      return pkg.name;
-    }
-    return this.root.split(/[\\/]/).pop() || 'unknown';
-  }
-
-  /**
-   * Detect primary language
-   */
-  private detectLanguage(): string {
-    const langCounts: Record<string, number> = {};
-    
-    const scan = (dir: string, depth: number = 0) => {
-      if (depth > 3) return;
-      try {
-        const items = readdirSync(dir);
-        for (const item of items) {
-          if (['node_modules', '.git', 'dist'].includes(item)) continue;
-          const fullPath = join(dir, item);
-          try {
-            const stat = statSync(fullPath);
-            if (stat.isDirectory()) {
-              scan(fullPath, depth + 1);
-            } else if (stat.isFile()) {
-              const ext = item.split('.').pop()?.toLowerCase();
-              if (ext) langCounts[ext] = (langCounts[ext] || 0) + 1;
-            }
-          } catch { /* skip */ }
-        }
-      } catch { /* skip */ }
-    };
-    
-    scan(this.root);
-    
-    const extToLang: Record<string, string> = {
-      'ts': 'TypeScript', 'tsx': 'TypeScript',
-      'js': 'JavaScript', 'jsx': 'JavaScript', 'mjs': 'JavaScript',
-      'py': 'Python', 'java': 'Java', 'go': 'Go', 'rs': 'Rust',
-      'c': 'C/C++', 'cpp': 'C/C++', 'h': 'C/C++', 'hpp': 'C/C++',
-      'cs': 'C#', 'rb': 'Ruby', 'php': 'PHP',
-    };
-    
-    for (const [ext, count] of Object.entries(langCounts)) {
-      const lang = extToLang[ext];
-      if (lang && count > 0) return lang;
-    }
-    
-    return 'Unknown';
-  }
-
-  /**
-   * Detect build tool
-   */
-  private detectBuildTool(): string | undefined {
-    if (existsSync(join(this.root, 'package.json'))) return 'npm/yarn/pnpm';
-    if (existsSync(join(this.root, 'Cargo.toml'))) return 'Cargo';
-    if (existsSync(join(this.root, 'go.mod'))) return 'Go';
-    if (existsSync(join(this.root, 'pom.xml'))) return 'Maven';
-    if (existsSync(join(this.root, 'build.gradle'))) return 'Gradle';
-    if (existsSync(join(this.root, 'Makefile'))) return 'Make';
-    return undefined;
-  }
-
-  /**
-   * Read .gitignore
-   */
-  private readGitIgnore(): string[] {
-    const path = join(this.root, '.gitignore');
-    if (!existsSync(path)) return [];
-    try {
-      return readFileSync(path, 'utf-8').split('\n')
-        .map(l => l.trim()).filter(l => l && !l.startsWith('#'));
-    } catch { return []; }
-  }
-
-  /**
-   * Read package.json
-   */
-  private readPackageJson(): PackageJson | null {
-    const path = join(this.root, 'package.json');
-    if (!existsSync(path)) return null;
-    try {
-      return JSON.parse(readFileSync(path, 'utf-8'));
-    } catch { return null; }
-  }
-
-  /**
-   * List project files
-   */
-  private listFiles(maxFiles: number = 100): string[] {
-    const files: string[] = [];
-    const gitIgnore = this.readGitIgnore();
-    
-    const scan = (dir: string, depth: number = 0) => {
-      if (depth > 4 || files.length >= maxFiles) return;
-      try {
-        const items = readdirSync(dir);
-        for (const item of items) {
-          if (files.length >= maxFiles) break;
-          if (this.isIgnored(item, gitIgnore)) continue;
-          const fullPath = join(dir, item);
-          const relPath = relative(this.root, fullPath);
-          try {
-            const stat = statSync(fullPath);
-            if (stat.isDirectory()) {
-              files.push(relPath + '/');
-              scan(fullPath, depth + 1);
-            } else if (stat.isFile()) {
-              files.push(relPath);
-            }
-          } catch { /* skip */ }
-        }
-      } catch { /* skip */ }
-    };
-    
-    scan(this.root);
-    return files;
-  }
-
-  /**
-   * Check if ignored
-   */
-  private isIgnored(name: string, gitIgnore: string[]): boolean {
-    const common = ['node_modules', '.git', 'dist', 'build', '__pycache__', '.env'];
-    if (common.includes(name)) return true;
-    return gitIgnore.includes(name);
-  }
-
-  /**
-   * Get context summary
-   */
-  async getContextSummary(): Promise<string> {
-    const info = await this.detect();
-    const lines = [`📁 Project: ${info.name}`, `💻 Language: ${info.language}`];
-    if (info.buildTool) lines.push(`🔧 Build: ${info.buildTool}`);
-    if (info.hasGit) lines.push(`📊 Git: Yes`);
-    if (info.packageJson) {
-      lines.push(`📦 Package: ${info.packageJson.name}@${info.packageJson.version}`);
-      if (info.packageJson.scripts) {
-        lines.push(`   Scripts: ${Object.keys(info.packageJson.scripts).slice(0, 5).join(', ')}`);
-      }
-    }
-    lines.push(`📁 Files: ${info.files.length} files scanned`);
-    return lines.join('\n');
-  }
-}

package/tsconfig.json

@@ -1,19 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "moduleResolution": "node",
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}