promptarchitect 0.6.0

package/src/providers/environmentTreeProvider.ts

@@ -0,0 +1,311 @@
+/**
+ * Environment Tree View Provider
+ * 
+ * Displays environment variables from .env files and provides
+ * quick copy/edit functionality.
+ */
+
+import * as vscode from 'vscode';
+import * as path from 'path';
+import * as fs from 'fs';
+
+export interface EnvVariable {
+  key: string;
+  value: string;
+  source: string; // filename like '.env', '.env.local'
+  isSecret: boolean; // Heuristic based on key name
+  lineNumber: number;
+}
+
+export class EnvironmentTreeProvider implements vscode.TreeDataProvider<EnvTreeItem> {
+  private _onDidChangeTreeData: vscode.EventEmitter<EnvTreeItem | undefined | null | void> = 
+    new vscode.EventEmitter<EnvTreeItem | undefined | null | void>();
+  readonly onDidChangeTreeData: vscode.Event<EnvTreeItem | undefined | null | void> = 
+    this._onDidChangeTreeData.event;
+
+  private envFiles: Map<string, EnvVariable[]> = new Map();
+  private revealedSecrets: Set<string> = new Set(); // key@source format
+
+  // Patterns that suggest a value is secret
+  private readonly SECRET_PATTERNS = [
+    /secret/i,
+    /password/i,
+    /api[_-]?key/i,
+    /token/i,
+    /private/i,
+    /auth/i,
+    /credential/i,
+    /key$/i,
+  ];
+
+  // Common env file names to look for
+  private readonly ENV_FILES = [
+    '.env',
+    '.env.local',
+    '.env.development',
+    '.env.production',
+    '.env.test',
+    '.env.example',
+  ];
+
+  constructor(private context: vscode.ExtensionContext) {
+    this.detectEnvFiles();
+
+    // Watch for .env file changes
+    const watcher = vscode.workspace.createFileSystemWatcher('**/.env*');
+    watcher.onDidChange(() => this.refresh());
+    watcher.onDidCreate(() => this.refresh());
+    watcher.onDidDelete(() => this.refresh());
+    context.subscriptions.push(watcher);
+  }
+
+  refresh(): void {
+    this.detectEnvFiles();
+    this._onDidChangeTreeData.fire();
+  }
+
+  getTreeItem(element: EnvTreeItem): vscode.TreeItem {
+    return element;
+  }
+
+  async getChildren(element?: EnvTreeItem): Promise<EnvTreeItem[]> {
+    if (!vscode.workspace.workspaceFolders) {
+      return [];
+    }
+
+    if (this.envFiles.size === 0) {
+      return [];
+    }
+
+    if (!element) {
+      // Root level - show env file categories
+      const items: EnvTreeItem[] = [];
+
+      for (const [source, vars] of this.envFiles.entries()) {
+        if (vars.length > 0) {
+          items.push(new EnvTreeItem(
+            source,
+            vscode.TreeItemCollapsibleState.Expanded,
+            'envFile',
+            undefined,
+            source
+          ));
+        }
+      }
+
+      return items;
+    } else {
+      // Children - show variables for this file
+      const source = element.source || '';
+      const vars = this.envFiles.get(source) || [];
+
+      return vars.map(envVar => {
+        const isRevealed = this.revealedSecrets.has(`${envVar.key}@${envVar.source}`);
+        const displayValue = envVar.isSecret && !isRevealed 
+          ? '••••••••••' 
+          : envVar.value;
+
+        const item = new EnvTreeItem(
+          envVar.key,
+          vscode.TreeItemCollapsibleState.None,
+          'envVar',
+          envVar,
+          envVar.source
+        );
+        item.description = displayValue;
+        item.tooltip = new vscode.MarkdownString(
+          `**${envVar.key}**\n\n` +
+          `Value: \`${envVar.isSecret && !isRevealed ? '(hidden)' : envVar.value}\`\n\n` +
+          `Source: ${envVar.source}\n\n` +
+          `Line: ${envVar.lineNumber}\n\n` +
+          `_Click to copy value_`
+        );
+        item.iconPath = new vscode.ThemeIcon(
+          envVar.isSecret ? 'key' : 'symbol-variable'
+        );
+
+        return item;
+      });
+    }
+  }
+
+  private detectEnvFiles(): void {
+    this.envFiles.clear();
+    const workspaceFolder = vscode.workspace.workspaceFolders?.[0];
+    if (!workspaceFolder) return;
+
+    const rootPath = workspaceFolder.uri.fsPath;
+
+    for (const envFileName of this.ENV_FILES) {
+      const envPath = path.join(rootPath, envFileName);
+      
+      try {
+        if (fs.existsSync(envPath)) {
+          const variables = this.parseEnvFile(envPath, envFileName);
+          if (variables.length > 0) {
+            this.envFiles.set(envFileName, variables);
+          }
+        }
+      } catch (error) {
+        console.error(`Error reading ${envFileName}:`, error);
+      }
+    }
+  }
+
+  private parseEnvFile(filePath: string, source: string): EnvVariable[] {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const lines = content.split('\n');
+    const variables: EnvVariable[] = [];
+
+    lines.forEach((line, index) => {
+      // Skip comments and empty lines
+      const trimmedLine = line.trim();
+      if (!trimmedLine || trimmedLine.startsWith('#')) {
+        return;
+      }
+
+      // Parse KEY=VALUE format
+      const match = trimmedLine.match(/^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/);
+      if (match) {
+        const key = match[1];
+        let value = match[2];
+
+        // Remove surrounding quotes if present
+        if ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+          value = value.slice(1, -1);
+        }
+
+        // Check if this looks like a secret
+        const isSecret = this.SECRET_PATTERNS.some(pattern => pattern.test(key));
+
+        variables.push({
+          key,
+          value,
+          source,
+          isSecret,
+          lineNumber: index + 1,
+        });
+      }
+    });
+
+    return variables;
+  }
+
+  async copyValue(item: EnvTreeItem): Promise<void> {
+    if (!item.envVar) return;
+
+    await vscode.env.clipboard.writeText(item.envVar.value);
+    vscode.window.showInformationMessage(`📋 Copied ${item.envVar.key} value`);
+  }
+
+  toggleReveal(item: EnvTreeItem): void {
+    if (!item.envVar) return;
+
+    const key = `${item.envVar.key}@${item.envVar.source}`;
+    if (this.revealedSecrets.has(key)) {
+      this.revealedSecrets.delete(key);
+    } else {
+      this.revealedSecrets.add(key);
+    }
+    this._onDidChangeTreeData.fire();
+  }
+
+  async createEnvFile(): Promise<void> {
+    const workspaceFolder = vscode.workspace.workspaceFolders?.[0];
+    if (!workspaceFolder) {
+      vscode.window.showWarningMessage('No workspace folder open');
+      return;
+    }
+
+    const envPath = path.join(workspaceFolder.uri.fsPath, '.env');
+    
+    if (fs.existsSync(envPath)) {
+      // Open existing file
+      const doc = await vscode.workspace.openTextDocument(envPath);
+      await vscode.window.showTextDocument(doc);
+      return;
+    }
+
+    // Create new .env file with template
+    const template = `# Environment Variables
+# Add your environment-specific variables here
+
+# Example:
+# DATABASE_URL=postgres://user:pass@localhost:5432/db
+# API_KEY=your-api-key-here
+# NODE_ENV=development
+
+`;
+
+    fs.writeFileSync(envPath, template);
+    const doc = await vscode.workspace.openTextDocument(envPath);
+    await vscode.window.showTextDocument(doc);
+    
+    this.refresh();
+    vscode.window.showInformationMessage('Created .env file');
+  }
+
+  async openEnvFile(item: EnvTreeItem): Promise<void> {
+    const source = item.source;
+    if (!source) return;
+
+    const workspaceFolder = vscode.workspace.workspaceFolders?.[0];
+    if (!workspaceFolder) return;
+
+    const envPath = path.join(workspaceFolder.uri.fsPath, source);
+    
+    try {
+      const doc = await vscode.workspace.openTextDocument(envPath);
+      await vscode.window.showTextDocument(doc);
+
+      // If we have a specific line number, go to it
+      if (item.envVar && item.envVar.lineNumber > 0) {
+        const editor = vscode.window.activeTextEditor;
+        if (editor) {
+          const line = item.envVar.lineNumber - 1;
+          const position = new vscode.Position(line, 0);
+          editor.selection = new vscode.Selection(position, position);
+          editor.revealRange(new vscode.Range(position, position));
+        }
+      }
+    } catch (error) {
+      vscode.window.showErrorMessage(`Could not open ${source}`);
+    }
+  }
+}
+
+export class EnvTreeItem extends vscode.TreeItem {
+  public envVar?: EnvVariable;
+  public source?: string;
+
+  constructor(
+    public readonly label: string,
+    public readonly collapsibleState: vscode.TreeItemCollapsibleState,
+    public readonly contextValue: string,
+    envVar?: EnvVariable,
+    source?: string
+  ) {
+    super(label, collapsibleState);
+    this.envVar = envVar;
+    this.source = source;
+
+    if (contextValue === 'envFile') {
+      this.iconPath = new vscode.ThemeIcon('file');
+      this.tooltip = `Environment file: ${source}`;
+      // Make clickable to open the file
+      this.command = {
+        command: 'promptarchitect.openEnvFile',
+        title: 'Open File',
+        arguments: [this],
+      };
+    } else if (contextValue === 'envVar') {
+      // Make clickable to copy
+      this.command = {
+        command: 'promptarchitect.copyEnvValue',
+        title: 'Copy Value',
+        arguments: [this],
+      };
+    }
+  }
+}

package/src/providers/index.ts

@@ -0,0 +1,9 @@
+/**
+ * Provider exports
+ */
+
+export { ScriptsTreeProvider, ScriptTreeItem } from './scriptsTreeProvider';
+export { QuickAccessTreeProvider, QuickAccessTreeItem } from './quickAccessTreeProvider';
+export { EnvironmentTreeProvider, EnvTreeItem } from './environmentTreeProvider';
+export { NotesTreeProvider, NoteTreeItem } from './notesTreeProvider';
+export { AIChatViewProvider } from './aiChatViewProvider';

package/src/providers/notesTreeProvider.ts

@@ -0,0 +1,301 @@
+/**
+ * Notes Tree View Provider
+ * 
+ * A lightweight, project-scoped TODO list and scratchpad.
+ * Notes are persisted per-project in workspace state.
+ */
+
+import * as vscode from 'vscode';
+
+export interface NoteItem {
+  id: string;
+  text: string;
+  completed: boolean;
+  priority: 'none' | 'high' | 'medium' | 'low';
+  createdAt: number;
+  completedAt?: number;
+}
+
+export class NotesTreeProvider implements vscode.TreeDataProvider<NoteTreeItem> {
+  private _onDidChangeTreeData: vscode.EventEmitter<NoteTreeItem | undefined | null | void> = 
+    new vscode.EventEmitter<NoteTreeItem | undefined | null | void>();
+  readonly onDidChangeTreeData: vscode.Event<NoteTreeItem | undefined | null | void> = 
+    this._onDidChangeTreeData.event;
+
+  private notes: NoteItem[] = [];
+
+  constructor(private context: vscode.ExtensionContext) {
+    // Load notes from workspace storage
+    this.notes = context.workspaceState.get('projectNotes', []);
+  }
+
+  refresh(): void {
+    this._onDidChangeTreeData.fire();
+  }
+
+  getTreeItem(element: NoteTreeItem): vscode.TreeItem {
+    return element;
+  }
+
+  async getChildren(element?: NoteTreeItem): Promise<NoteTreeItem[]> {
+    if (!element) {
+      // Root level - show categories
+      const activeNotes = this.notes.filter(n => !n.completed);
+      const completedNotes = this.notes.filter(n => n.completed);
+      
+      const items: NoteTreeItem[] = [];
+
+      // Active notes (shown directly, no category header if few)
+      if (activeNotes.length > 0) {
+        // Sort by priority then by creation date
+        const sorted = this.sortNotes(activeNotes);
+        sorted.forEach(note => {
+          items.push(this.createNoteTreeItem(note));
+        });
+      }
+
+      // Completed section (collapsible)
+      if (completedNotes.length > 0) {
+        items.push(new NoteTreeItem(
+          `Completed (${completedNotes.length})`,
+          vscode.TreeItemCollapsibleState.Collapsed,
+          'completedCategory',
+          undefined
+        ));
+      }
+
+      return items;
+    } else if (element.contextValue === 'completedCategory') {
+      // Show completed notes
+      const completedNotes = this.notes.filter(n => n.completed);
+      const sorted = completedNotes.sort((a, b) => (b.completedAt || 0) - (a.completedAt || 0));
+      return sorted.map(note => this.createNoteTreeItem(note));
+    }
+
+    return [];
+  }
+
+  private sortNotes(notes: NoteItem[]): NoteItem[] {
+    const priorityOrder: Record<string, number> = {
+      'high': 0,
+      'medium': 1,
+      'low': 2,
+      'none': 3,
+    };
+
+    return notes.sort((a, b) => {
+      const priorityDiff = priorityOrder[a.priority] - priorityOrder[b.priority];
+      if (priorityDiff !== 0) return priorityDiff;
+      return a.createdAt - b.createdAt;
+    });
+  }
+
+  private createNoteTreeItem(note: NoteItem): NoteTreeItem {
+    const item = new NoteTreeItem(
+      note.text,
+      vscode.TreeItemCollapsibleState.None,
+      note.completed ? 'noteCompleted' : 'noteActive',
+      note
+    );
+
+    // Set checkbox icon
+    item.iconPath = new vscode.ThemeIcon(
+      note.completed ? 'pass-filled' : 'circle-large-outline'
+    );
+
+    // Add priority indicator
+    const priorityIcons: Record<string, string> = {
+      'high': '🔴',
+      'medium': '🟡',
+      'low': '🟢',
+      'none': '',
+    };
+    const priorityIndicator = priorityIcons[note.priority];
+    
+    if (note.completed) {
+      item.description = this.getRelativeTime(note.completedAt || note.createdAt);
+    } else if (priorityIndicator) {
+      item.description = priorityIndicator;
+    }
+
+    // Tooltip with details
+    item.tooltip = new vscode.MarkdownString(
+      `${note.completed ? '✅' : '☐'} ${note.text}\n\n` +
+      `Priority: ${note.priority}\n\n` +
+      `Created: ${new Date(note.createdAt).toLocaleString()}\n\n` +
+      (note.completed && note.completedAt 
+        ? `Completed: ${new Date(note.completedAt).toLocaleString()}` 
+        : '_Click to toggle completion_')
+    );
+
+    // Click to toggle
+    item.command = {
+      command: 'promptarchitect.toggleNote',
+      title: 'Toggle Note',
+      arguments: [item],
+    };
+
+    return item;
+  }
+
+  private getRelativeTime(timestamp: number): string {
+    const now = Date.now();
+    const diff = now - timestamp;
+    const minutes = Math.floor(diff / 60000);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+
+    if (days > 0) return `${days}d ago`;
+    if (hours > 0) return `${hours}h ago`;
+    if (minutes > 0) return `${minutes}m ago`;
+    return 'just now';
+  }
+
+  private generateId(): string {
+    return `note_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  private async saveNotes(): Promise<void> {
+    await this.context.workspaceState.update('projectNotes', this.notes);
+  }
+
+  async addNote(): Promise<void> {
+    const text = await vscode.window.showInputBox({
+      prompt: 'Enter your note or TODO',
+      placeHolder: 'e.g., Fix authentication bug',
+    });
+
+    if (!text) return;
+
+    // Ask for priority
+    const priority = await vscode.window.showQuickPick(
+      [
+        { label: '🔴 High', value: 'high' },
+        { label: '🟡 Medium', value: 'medium' },
+        { label: '🟢 Low', value: 'low' },
+        { label: 'No Priority', value: 'none' },
+      ],
+      {
+        placeHolder: 'Set priority (optional)',
+      }
+    );
+
+    const note: NoteItem = {
+      id: this.generateId(),
+      text,
+      completed: false,
+      priority: (priority?.value as NoteItem['priority']) || 'none',
+      createdAt: Date.now(),
+    };
+
+    this.notes.unshift(note);
+    await this.saveNotes();
+    this._onDidChangeTreeData.fire();
+  }
+
+  async toggleNote(item: NoteTreeItem): Promise<void> {
+    if (!item.note) return;
+
+    const noteIndex = this.notes.findIndex(n => n.id === item.note!.id);
+    if (noteIndex === -1) return;
+
+    this.notes[noteIndex].completed = !this.notes[noteIndex].completed;
+    
+    if (this.notes[noteIndex].completed) {
+      this.notes[noteIndex].completedAt = Date.now();
+    } else {
+      this.notes[noteIndex].completedAt = undefined;
+    }
+
+    await this.saveNotes();
+    this._onDidChangeTreeData.fire();
+  }
+
+  async deleteNote(item: NoteTreeItem): Promise<void> {
+    if (!item.note) return;
+
+    const confirm = await vscode.window.showQuickPick(['Yes', 'No'], {
+      placeHolder: `Delete "${item.note.text.substring(0, 30)}..."?`,
+    });
+
+    if (confirm !== 'Yes') return;
+
+    this.notes = this.notes.filter(n => n.id !== item.note!.id);
+    await this.saveNotes();
+    this._onDidChangeTreeData.fire();
+  }
+
+  async editNote(item: NoteTreeItem): Promise<void> {
+    if (!item.note) return;
+
+    const newText = await vscode.window.showInputBox({
+      prompt: 'Edit note',
+      value: item.note.text,
+    });
+
+    if (!newText) return;
+
+    const noteIndex = this.notes.findIndex(n => n.id === item.note!.id);
+    if (noteIndex === -1) return;
+
+    this.notes[noteIndex].text = newText;
+    await this.saveNotes();
+    this._onDidChangeTreeData.fire();
+  }
+
+  async cyclePriority(item: NoteTreeItem): Promise<void> {
+    if (!item.note) return;
+
+    const noteIndex = this.notes.findIndex(n => n.id === item.note!.id);
+    if (noteIndex === -1) return;
+
+    const priorities: NoteItem['priority'][] = ['none', 'high', 'medium', 'low'];
+    const currentIndex = priorities.indexOf(this.notes[noteIndex].priority);
+    const nextIndex = (currentIndex + 1) % priorities.length;
+
+    this.notes[noteIndex].priority = priorities[nextIndex];
+    await this.saveNotes();
+    this._onDidChangeTreeData.fire();
+  }
+
+  async clearCompleted(): Promise<void> {
+    const completedCount = this.notes.filter(n => n.completed).length;
+    if (completedCount === 0) {
+      vscode.window.showInformationMessage('No completed notes to clear');
+      return;
+    }
+
+    const confirm = await vscode.window.showQuickPick(['Yes', 'No'], {
+      placeHolder: `Clear ${completedCount} completed note(s)?`,
+    });
+
+    if (confirm !== 'Yes') return;
+
+    this.notes = this.notes.filter(n => !n.completed);
+    await this.saveNotes();
+    this._onDidChangeTreeData.fire();
+    vscode.window.showInformationMessage(`Cleared ${completedCount} completed note(s)`);
+  }
+
+  getActiveCount(): number {
+    return this.notes.filter(n => !n.completed).length;
+  }
+}
+
+export class NoteTreeItem extends vscode.TreeItem {
+  public note?: NoteItem;
+
+  constructor(
+    public readonly label: string,
+    public readonly collapsibleState: vscode.TreeItemCollapsibleState,
+    public readonly contextValue: string,
+    note?: NoteItem
+  ) {
+    super(label, collapsibleState);
+    this.note = note;
+
+    if (contextValue === 'completedCategory') {
+      this.iconPath = new vscode.ThemeIcon('checklist');
+    }
+  }
+}