promptarchitect 0.6.0

package/src/providers/quickAccessTreeProvider.ts

@@ -0,0 +1,328 @@
+/**
+ * Quick Access Tree View Provider
+ * 
+ * Displays pinned files and auto-detected important project files.
+ * Allows quick navigation to frequently used files.
+ */
+
+import * as vscode from 'vscode';
+import * as path from 'path';
+import * as fs from 'fs';
+
+export interface PinnedItem {
+  name: string;
+  path: string;
+  type: 'file' | 'folder' | 'link';
+  url?: string; // For external links
+  pinned: boolean; // true = user pinned, false = auto-detected
+}
+
+export class QuickAccessTreeProvider implements vscode.TreeDataProvider<QuickAccessTreeItem> {
+  private _onDidChangeTreeData: vscode.EventEmitter<QuickAccessTreeItem | undefined | null | void> = 
+    new vscode.EventEmitter<QuickAccessTreeItem | undefined | null | void>();
+  readonly onDidChangeTreeData: vscode.Event<QuickAccessTreeItem | undefined | null | void> = 
+    this._onDidChangeTreeData.event;
+
+  private pinnedItems: PinnedItem[] = [];
+  private detectedItems: PinnedItem[] = [];
+
+  // Common important files to auto-detect
+  private readonly AUTO_DETECT_FILES = [
+    'README.md',
+    'readme.md',
+    'README',
+    'CONTRIBUTING.md',
+    'CHANGELOG.md',
+    'LICENSE',
+    'LICENSE.md',
+    '.env.example',
+    '.env.template',
+    'docker-compose.yml',
+    'docker-compose.yaml',
+    'Dockerfile',
+  ];
+
+  // Common entry point patterns
+  private readonly ENTRY_POINT_PATTERNS = [
+    'src/index.ts',
+    'src/index.js',
+    'src/main.ts',
+    'src/main.js',
+    'src/App.tsx',
+    'src/App.jsx',
+    'index.ts',
+    'index.js',
+    'main.ts',
+    'main.py',
+    'app.py',
+  ];
+
+  constructor(private context: vscode.ExtensionContext) {
+    // Load pinned items from storage
+    this.pinnedItems = context.workspaceState.get('pinnedItems', []);
+    this.detectImportantFiles();
+  }
+
+  refresh(): void {
+    this.detectImportantFiles();
+    this._onDidChangeTreeData.fire();
+  }
+
+  getTreeItem(element: QuickAccessTreeItem): vscode.TreeItem {
+    return element;
+  }
+
+  async getChildren(element?: QuickAccessTreeItem): Promise<QuickAccessTreeItem[]> {
+    if (!vscode.workspace.workspaceFolders) {
+      return [];
+    }
+
+    if (!element) {
+      // Root level - show categories
+      const items: QuickAccessTreeItem[] = [];
+
+      // Detected files section
+      if (this.detectedItems.length > 0) {
+        items.push(new QuickAccessTreeItem(
+          'Detected',
+          vscode.TreeItemCollapsibleState.Expanded,
+          'category',
+          undefined
+        ));
+      }
+
+      // Pinned files section
+      if (this.pinnedItems.length > 0) {
+        items.push(new QuickAccessTreeItem(
+          '⭐ Pinned',
+          vscode.TreeItemCollapsibleState.Expanded,
+          'category',
+          undefined,
+          true
+        ));
+      }
+
+      // If nothing exists, return empty (welcome view will show)
+      if (items.length === 0) {
+        return [];
+      }
+
+      return items;
+    } else {
+      // Children based on category
+      const isPinnedCategory = element.isPinnedCategory;
+      const sourceItems = isPinnedCategory ? this.pinnedItems : this.detectedItems;
+
+      return sourceItems.map(item => {
+        const treeItem = new QuickAccessTreeItem(
+          item.name,
+          vscode.TreeItemCollapsibleState.None,
+          item.pinned ? 'pinnedFile' : 'detectedFile',
+          item
+        );
+        return treeItem;
+      });
+    }
+  }
+
+  private detectImportantFiles(): void {
+    this.detectedItems = [];
+    const workspaceFolder = vscode.workspace.workspaceFolders?.[0];
+    if (!workspaceFolder) return;
+
+    const rootPath = workspaceFolder.uri.fsPath;
+
+    // Check for auto-detect files
+    for (const fileName of this.AUTO_DETECT_FILES) {
+      const filePath = path.join(rootPath, fileName);
+      if (fs.existsSync(filePath)) {
+        // Skip if already pinned
+        if (!this.pinnedItems.some(p => p.path === filePath)) {
+          this.detectedItems.push({
+            name: fileName,
+            path: filePath,
+            type: 'file',
+            pinned: false,
+          });
+        }
+      }
+    }
+
+    // Check for entry points
+    for (const entryPoint of this.ENTRY_POINT_PATTERNS) {
+      const filePath = path.join(rootPath, entryPoint);
+      if (fs.existsSync(filePath)) {
+        if (!this.pinnedItems.some(p => p.path === filePath) &&
+            !this.detectedItems.some(d => d.path === filePath)) {
+          this.detectedItems.push({
+            name: entryPoint,
+            path: filePath,
+            type: 'file',
+            pinned: false,
+          });
+        }
+        break; // Only add one entry point
+      }
+    }
+  }
+
+  async pinCurrentFile(): Promise<void> {
+    const editor = vscode.window.activeTextEditor;
+    if (!editor) {
+      vscode.window.showWarningMessage('No active file to pin');
+      return;
+    }
+
+    const filePath = editor.document.uri.fsPath;
+    const fileName = path.basename(filePath);
+
+    // Check if already pinned
+    if (this.pinnedItems.some(p => p.path === filePath)) {
+      vscode.window.showInformationMessage(`"${fileName}" is already pinned`);
+      return;
+    }
+
+    const item: PinnedItem = {
+      name: fileName,
+      path: filePath,
+      type: 'file',
+      pinned: true,
+    };
+
+    this.pinnedItems.push(item);
+    await this.context.workspaceState.update('pinnedItems', this.pinnedItems);
+    
+    // Remove from detected if it was there
+    this.detectedItems = this.detectedItems.filter(d => d.path !== filePath);
+    
+    this._onDidChangeTreeData.fire();
+    vscode.window.showInformationMessage(`📌 Pinned "${fileName}"`);
+  }
+
+  async unpinFile(item: QuickAccessTreeItem): Promise<void> {
+    if (!item.pinnedItem) return;
+
+    this.pinnedItems = this.pinnedItems.filter(p => p.path !== item.pinnedItem!.path);
+    await this.context.workspaceState.update('pinnedItems', this.pinnedItems);
+    
+    // Re-detect in case it should appear in detected section
+    this.detectImportantFiles();
+    
+    this._onDidChangeTreeData.fire();
+    vscode.window.showInformationMessage(`Unpinned "${item.pinnedItem.name}"`);
+  }
+
+  async openFile(item: QuickAccessTreeItem): Promise<void> {
+    if (!item.pinnedItem) return;
+
+    const pinnedItem = item.pinnedItem;
+
+    if (pinnedItem.type === 'link' && pinnedItem.url) {
+      vscode.env.openExternal(vscode.Uri.parse(pinnedItem.url));
+    } else if (pinnedItem.type === 'folder') {
+      // Reveal in explorer
+      const uri = vscode.Uri.file(pinnedItem.path);
+      vscode.commands.executeCommand('revealInExplorer', uri);
+    } else {
+      // Open file
+      const uri = vscode.Uri.file(pinnedItem.path);
+      const doc = await vscode.workspace.openTextDocument(uri);
+      await vscode.window.showTextDocument(doc);
+    }
+  }
+
+  async addExternalLink(): Promise<void> {
+    const name = await vscode.window.showInputBox({
+      prompt: 'Enter a name for this link',
+      placeHolder: 'e.g., Jira Board',
+    });
+
+    if (!name) return;
+
+    const url = await vscode.window.showInputBox({
+      prompt: 'Enter the URL',
+      placeHolder: 'https://...',
+    });
+
+    if (!url) return;
+
+    const item: PinnedItem = {
+      name,
+      path: '',
+      type: 'link',
+      url,
+      pinned: true,
+    };
+
+    this.pinnedItems.push(item);
+    await this.context.workspaceState.update('pinnedItems', this.pinnedItems);
+    this._onDidChangeTreeData.fire();
+  }
+}
+
+export class QuickAccessTreeItem extends vscode.TreeItem {
+  public pinnedItem?: PinnedItem;
+  public isPinnedCategory?: boolean;
+
+  constructor(
+    public readonly label: string,
+    public readonly collapsibleState: vscode.TreeItemCollapsibleState,
+    public readonly contextValue: string,
+    pinnedItem?: PinnedItem,
+    isPinnedCategory?: boolean
+  ) {
+    super(label, collapsibleState);
+    this.pinnedItem = pinnedItem;
+    this.isPinnedCategory = isPinnedCategory;
+
+    if (pinnedItem) {
+      this.tooltip = pinnedItem.path || pinnedItem.url;
+      this.description = this.getRelativePath(pinnedItem.path);
+      this.iconPath = this.getIcon(pinnedItem);
+      
+      // Make clickable to open
+      this.command = {
+        command: 'promptarchitect.openQuickAccessFile',
+        title: 'Open File',
+        arguments: [this],
+      };
+    } else if (contextValue === 'category') {
+      this.iconPath = new vscode.ThemeIcon(isPinnedCategory ? 'star-full' : 'eye');
+    }
+  }
+
+  private getRelativePath(filePath: string): string {
+    if (!filePath) return '';
+    const workspaceFolder = vscode.workspace.workspaceFolders?.[0];
+    if (workspaceFolder) {
+      const relativePath = path.relative(workspaceFolder.uri.fsPath, path.dirname(filePath));
+      return relativePath ? `./${relativePath}` : './';
+    }
+    return '';
+  }
+
+  private getIcon(item: PinnedItem): vscode.ThemeIcon {
+    if (item.type === 'link') {
+      return new vscode.ThemeIcon('link-external');
+    } else if (item.type === 'folder') {
+      return new vscode.ThemeIcon('folder');
+    } else {
+      // Use file-specific icons based on extension
+      const ext = path.extname(item.name).toLowerCase();
+      const iconMap: Record<string, string> = {
+        '.md': 'markdown',
+        '.json': 'json',
+        '.ts': 'symbol-namespace',
+        '.tsx': 'symbol-namespace',
+        '.js': 'symbol-method',
+        '.jsx': 'symbol-method',
+        '.py': 'symbol-misc',
+        '.yml': 'settings-gear',
+        '.yaml': 'settings-gear',
+        '.env': 'symbol-key',
+        '': 'file',
+      };
+      return new vscode.ThemeIcon(iconMap[ext] || 'file');
+    }
+  }
+}

package/src/providers/scriptsTreeProvider.ts

@@ -0,0 +1,324 @@
+/**
+ * Scripts Tree View Provider
+ * 
+ * Detects and displays project scripts from package.json, Makefile, tasks.json, etc.
+ * Provides one-click execution and status tracking.
+ */
+
+import * as vscode from 'vscode';
+import * as path from 'path';
+import * as fs from 'fs';
+
+export interface ScriptItem {
+  name: string;
+  command: string;
+  source: string; // 'npm', 'make', 'task', 'custom'
+  description?: string;
+  isRunning?: boolean;
+}
+
+export class ScriptsTreeProvider implements vscode.TreeDataProvider<ScriptTreeItem> {
+  private _onDidChangeTreeData: vscode.EventEmitter<ScriptTreeItem | undefined | null | void> = 
+    new vscode.EventEmitter<ScriptTreeItem | undefined | null | void>();
+  readonly onDidChangeTreeData: vscode.Event<ScriptTreeItem | undefined | null | void> = 
+    this._onDidChangeTreeData.event;
+
+  private scripts: Map<string, ScriptItem[]> = new Map();
+  private runningScripts: Map<string, vscode.Terminal> = new Map();
+  private customScripts: ScriptItem[] = [];
+
+  constructor(private context: vscode.ExtensionContext) {
+    // Load custom scripts from storage
+    this.customScripts = context.workspaceState.get('customScripts', []);
+  }
+
+  refresh(): void {
+    this.detectScripts();
+    this._onDidChangeTreeData.fire();
+  }
+
+  getTreeItem(element: ScriptTreeItem): vscode.TreeItem {
+    return element;
+  }
+
+  async getChildren(element?: ScriptTreeItem): Promise<ScriptTreeItem[]> {
+    if (!vscode.workspace.workspaceFolders) {
+      return [];
+    }
+
+    // If no scripts detected yet, detect them
+    if (this.scripts.size === 0 && this.customScripts.length === 0) {
+      await this.detectScripts();
+    }
+
+    if (!element) {
+      // Root level - return source categories
+      const categories: ScriptTreeItem[] = [];
+
+      for (const [source, scripts] of this.scripts.entries()) {
+        if (scripts.length > 0) {
+          categories.push(new ScriptTreeItem(
+            this.getSourceLabel(source),
+            vscode.TreeItemCollapsibleState.Expanded,
+            'category',
+            source
+          ));
+        }
+      }
+
+      // Add custom scripts category if any exist
+      if (this.customScripts.length > 0) {
+        categories.push(new ScriptTreeItem(
+          '⚡ Custom Commands',
+          vscode.TreeItemCollapsibleState.Expanded,
+          'category',
+          'custom'
+        ));
+      }
+
+      return categories;
+    } else {
+      // Child level - return scripts for this category
+      const source = element.source;
+      let sourceScripts: ScriptItem[] = [];
+
+      if (source === 'custom') {
+        sourceScripts = this.customScripts;
+      } else {
+        sourceScripts = this.scripts.get(source || '') || [];
+      }
+
+      return sourceScripts.map(script => {
+        const isRunning = this.runningScripts.has(script.name);
+        const item = new ScriptTreeItem(
+          script.name,
+          vscode.TreeItemCollapsibleState.None,
+          isRunning ? 'runningScript' : 'script',
+          script.source
+        );
+        item.script = script;
+        item.description = isRunning ? '● Running' : script.description;
+        item.tooltip = `${script.command}\n\nClick to run`;
+        item.command = {
+          command: 'promptarchitect.runScript',
+          title: 'Run Script',
+          arguments: [item]
+        };
+        item.iconPath = new vscode.ThemeIcon(isRunning ? 'loading~spin' : 'play');
+        return item;
+      });
+    }
+  }
+
+  private getSourceLabel(source: string): string {
+    const labels: Record<string, string> = {
+      'npm': '📦 package.json',
+      'make': '🔧 Makefile',
+      'task': '⚙️ tasks.json',
+      'cargo': '🦀 Cargo.toml',
+      'python': '🐍 pyproject.toml',
+    };
+    return labels[source] || source;
+  }
+
+  private async detectScripts(): Promise<void> {
+    this.scripts.clear();
+    const workspaceFolder = vscode.workspace.workspaceFolders?.[0];
+    if (!workspaceFolder) return;
+
+    const rootPath = workspaceFolder.uri.fsPath;
+
+    // Detect npm scripts from package.json
+    await this.detectNpmScripts(rootPath);
+
+    // Detect tasks from tasks.json
+    await this.detectTasksJson(rootPath);
+
+    // Detect Makefile targets
+    await this.detectMakefileTargets(rootPath);
+  }
+
+  private async detectNpmScripts(rootPath: string): Promise<void> {
+    const packageJsonPath = path.join(rootPath, 'package.json');
+    
+    try {
+      if (fs.existsSync(packageJsonPath)) {
+        const content = fs.readFileSync(packageJsonPath, 'utf-8');
+        const pkg = JSON.parse(content);
+        
+        if (pkg.scripts) {
+          const scripts: ScriptItem[] = Object.entries(pkg.scripts).map(([name, command]) => ({
+            name,
+            command: `npm run ${name}`,
+            source: 'npm',
+            description: String(command).substring(0, 50) + (String(command).length > 50 ? '...' : ''),
+          }));
+          this.scripts.set('npm', scripts);
+        }
+      }
+    } catch (error) {
+      console.error('Error detecting npm scripts:', error);
+    }
+  }
+
+  private async detectTasksJson(rootPath: string): Promise<void> {
+    const tasksPath = path.join(rootPath, '.vscode', 'tasks.json');
+    
+    try {
+      if (fs.existsSync(tasksPath)) {
+        const content = fs.readFileSync(tasksPath, 'utf-8');
+        // Remove comments from JSON (VS Code allows them)
+        const cleanContent = content.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
+        const tasks = JSON.parse(cleanContent);
+        
+        if (tasks.tasks && Array.isArray(tasks.tasks)) {
+          const scripts: ScriptItem[] = tasks.tasks.map((task: any) => ({
+            name: task.label || task.taskName || 'Unnamed Task',
+            command: task.command || task.script || '',
+            source: 'task',
+            description: task.detail || task.type,
+          }));
+          this.scripts.set('task', scripts);
+        }
+      }
+    } catch (error) {
+      console.error('Error detecting tasks.json:', error);
+    }
+  }
+
+  private async detectMakefileTargets(rootPath: string): Promise<void> {
+    const makefilePath = path.join(rootPath, 'Makefile');
+    
+    try {
+      if (fs.existsSync(makefilePath)) {
+        const content = fs.readFileSync(makefilePath, 'utf-8');
+        const targetRegex = /^([a-zA-Z_][a-zA-Z0-9_-]*):/gm;
+        const targets: ScriptItem[] = [];
+        
+        let match;
+        while ((match = targetRegex.exec(content)) !== null) {
+          const targetName = match[1];
+          // Skip common non-runnable targets
+          if (!targetName.startsWith('.') && !['PHONY', 'FORCE'].includes(targetName)) {
+            targets.push({
+              name: targetName,
+              command: `make ${targetName}`,
+              source: 'make',
+            });
+          }
+        }
+        
+        if (targets.length > 0) {
+          this.scripts.set('make', targets);
+        }
+      }
+    } catch (error) {
+      console.error('Error detecting Makefile targets:', error);
+    }
+  }
+
+  async runScript(item: ScriptTreeItem): Promise<void> {
+    if (!item.script) return;
+
+    const script = item.script;
+    const terminalName = `PromptArchitect: ${script.name}`;
+
+    // Check if already running
+    if (this.runningScripts.has(script.name)) {
+      const existingTerminal = this.runningScripts.get(script.name);
+      existingTerminal?.show();
+      return;
+    }
+
+    // Create new terminal and run
+    const terminal = vscode.window.createTerminal({
+      name: terminalName,
+      cwd: vscode.workspace.workspaceFolders?.[0].uri.fsPath,
+    });
+
+    terminal.show();
+    terminal.sendText(script.command);
+
+    // Track running script
+    this.runningScripts.set(script.name, terminal);
+    this._onDidChangeTreeData.fire();
+
+    // Listen for terminal close
+    const disposable = vscode.window.onDidCloseTerminal((closedTerminal) => {
+      if (closedTerminal === terminal) {
+        this.runningScripts.delete(script.name);
+        this._onDidChangeTreeData.fire();
+        disposable.dispose();
+      }
+    });
+  }
+
+  stopScript(item: ScriptTreeItem): void {
+    if (!item.script) return;
+
+    const terminal = this.runningScripts.get(item.script.name);
+    if (terminal) {
+      terminal.dispose();
+      this.runningScripts.delete(item.script.name);
+      this._onDidChangeTreeData.fire();
+    }
+  }
+
+  async addCustomScript(): Promise<void> {
+    const name = await vscode.window.showInputBox({
+      prompt: 'Enter a name for this command',
+      placeHolder: 'e.g., deploy-staging',
+    });
+
+    if (!name) return;
+
+    const command = await vscode.window.showInputBox({
+      prompt: 'Enter the command to run',
+      placeHolder: 'e.g., npm run build && firebase deploy',
+    });
+
+    if (!command) return;
+
+    const script: ScriptItem = {
+      name,
+      command,
+      source: 'custom',
+      description: command.substring(0, 50),
+    };
+
+    this.customScripts.push(script);
+    await this.context.workspaceState.update('customScripts', this.customScripts);
+    this._onDidChangeTreeData.fire();
+
+    vscode.window.showInformationMessage(`Custom command "${name}" added!`);
+  }
+}
+
+export class ScriptTreeItem extends vscode.TreeItem {
+  public script?: ScriptItem;
+  public source?: string;
+
+  constructor(
+    public readonly label: string,
+    public readonly collapsibleState: vscode.TreeItemCollapsibleState,
+    public readonly contextValue: string,
+    source?: string
+  ) {
+    super(label, collapsibleState);
+    this.source = source;
+    
+    if (contextValue === 'category') {
+      this.iconPath = this.getCategoryIcon(source || '');
+    }
+  }
+
+  private getCategoryIcon(source: string): vscode.ThemeIcon {
+    const icons: Record<string, string> = {
+      'npm': 'package',
+      'make': 'tools',
+      'task': 'tasklist',
+      'custom': 'zap',
+    };
+    return new vscode.ThemeIcon(icons[source] || 'folder');
+  }
+}