promptarchitect 0.6.0

package/src/refinerPanel.ts

@@ -0,0 +1,620 @@
+/**
+ * PromptArchitect Refiner Panel
+ * 
+ * A webview panel that provides an in-place prompt refinement experience.
+ * Users type their prompt, click Refine, and the text transforms before their eyes.
+ */
+
+import * as vscode from 'vscode';
+import { PromptArchitectAPI } from './api';
+import { getWorkspaceContext, hasWorkspaceIndex, ensureWorkspaceIndexed } from './extension';
+
+export class RefinerPanel {
+  public static currentPanel: RefinerPanel | undefined;
+  private readonly panel: vscode.WebviewPanel;
+  private readonly api: PromptArchitectAPI;
+  private disposables: vscode.Disposable[] = [];
+
+  private constructor(panel: vscode.WebviewPanel, api: PromptArchitectAPI) {
+    this.panel = panel;
+    this.api = api;
+
+    // Set initial HTML content
+    this.updateWebview();
+
+    // Handle messages from webview
+    this.panel.webview.onDidReceiveMessage(
+      async (message) => {
+        switch (message.command) {
+          case 'refine':
+            await this.handleRefine(message.text, message.mode);
+            break;
+          case 'copyToClipboard':
+            await vscode.env.clipboard.writeText(message.text);
+            vscode.window.showInformationMessage('✅ Copied to clipboard!');
+            break;
+          case 'sendToChat':
+            await vscode.env.clipboard.writeText(message.text);
+            // Try to open Copilot Chat
+            try {
+              await vscode.commands.executeCommand('workbench.panel.chat.view.copilot.focus');
+            } catch {
+              // Fallback: try generic chat command
+              try {
+                await vscode.commands.executeCommand('workbench.action.chat.open');
+              } catch {
+                // If no chat available, just inform user
+              }
+            }
+            vscode.window.showInformationMessage('✅ Copied! Paste (Ctrl+V) in the chat input.');
+            break;
+          case 'insertInEditor':
+            await this.insertInActiveEditor(message.text);
+            break;
+          case 'indexWorkspace':
+            await vscode.commands.executeCommand('promptarchitect.indexWorkspace');
+            // Refresh the webview to update index status
+            this.updateWebview();
+            break;
+        }
+      },
+      null,
+      this.disposables
+    );
+
+    // Clean up on panel close
+    this.panel.onDidDispose(() => this.dispose(), null, this.disposables);
+  }
+
+  public static createOrShow(api: PromptArchitectAPI) {
+    const column = vscode.ViewColumn.Beside;
+
+    // If panel exists, show it
+    if (RefinerPanel.currentPanel) {
+      RefinerPanel.currentPanel.panel.reveal(column);
+      return;
+    }
+
+    // Create new panel
+    const panel = vscode.window.createWebviewPanel(
+      'promptArchitectRefiner',
+      '✨ Prompt Refiner',
+      column,
+      {
+        enableScripts: true,
+        retainContextWhenHidden: true,
+      }
+    );
+
+    RefinerPanel.currentPanel = new RefinerPanel(panel, api);
+  }
+
+  public static prefill(text: string) {
+    if (RefinerPanel.currentPanel) {
+      RefinerPanel.currentPanel.panel.webview.postMessage({
+        command: 'prefill',
+        text,
+      });
+    }
+  }
+
+  private async handleRefine(text: string, mode: string) {
+    if (!text.trim()) {
+      this.panel.webview.postMessage({
+        command: 'error',
+        message: 'Please enter some text to refine.',
+      });
+      return;
+    }
+
+    // Send loading state
+    this.panel.webview.postMessage({ command: 'loading', loading: true });
+
+    // Automatically ensure workspace is indexed (no user interaction)
+    // This runs silently in the background
+    await ensureWorkspaceIndexed();
+
+    try {
+      const config = vscode.workspace.getConfiguration('promptarchitect');
+      const targetModel = config.get<string>('targetModel') || 'general';
+      const useWorkspaceContext = config.get<boolean>('useWorkspaceContext') !== false;
+
+      // Get feedback based on refinement mode
+      const feedbackMap: Record<string, string> = {
+        clarity: 'Make this prompt clearer and more specific. Improve structure and reduce ambiguity.',
+        detailed: 'Expand this prompt with more context, requirements, and specific details.',
+        concise: 'Make this prompt more concise while keeping the core intent. Remove redundancy.',
+        technical: 'Make this prompt more technically precise with proper terminology and specifications.',
+        creative: 'Make this prompt more engaging and creative while maintaining clarity.',
+        structured: 'Add clear structure with sections, bullet points, or numbered steps.',
+      };
+
+      let feedback = feedbackMap[mode] || feedbackMap.clarity;
+      
+      // Append workspace context if available
+      if (useWorkspaceContext) {
+        const workspaceContext = getWorkspaceContext();
+        if (workspaceContext) {
+          feedback += `\n\n--- WORKSPACE CONTEXT ---\n${workspaceContext}\n--- END WORKSPACE CONTEXT ---\n\nUse the workspace context above to make the prompt more relevant to this specific project, using appropriate terminology, patterns, and conventions.`;
+        }
+      }
+
+      const result = await this.api.refinePrompt({
+        prompt: text,
+        feedback,
+        targetModel,
+        preserveStructure: mode === 'structured',
+      });
+
+      // Send refined text back to webview
+      this.panel.webview.postMessage({
+        command: 'refined',
+        text: result.refinedPrompt,
+        changes: result.changes,
+      });
+    } catch (error) {
+      this.panel.webview.postMessage({
+        command: 'error',
+        message: `Refinement failed: ${error}`,
+      });
+    } finally {
+      this.panel.webview.postMessage({ command: 'loading', loading: false });
+    }
+  }
+
+  private async insertInActiveEditor(text: string) {
+    const editor = vscode.window.activeTextEditor;
+    if (editor) {
+      await editor.edit((editBuilder) => {
+        if (editor.selection.isEmpty) {
+          editBuilder.insert(editor.selection.active, text);
+        } else {
+          editBuilder.replace(editor.selection, text);
+        }
+      });
+      vscode.window.showInformationMessage('✅ Inserted into editor!');
+    } else {
+      // Create new document with the text
+      const doc = await vscode.workspace.openTextDocument({ content: text });
+      await vscode.window.showTextDocument(doc);
+    }
+  }
+
+  private updateWebview() {
+    const isIndexed = hasWorkspaceIndex();
+    this.panel.webview.html = this.getHtmlContent(isIndexed);
+  }
+
+  private getHtmlContent(isIndexed: boolean): string {
+    const indexStatus = isIndexed 
+      ? '<span class="index-status indexed">📁 Workspace indexed</span>'
+      : '<span class="index-status not-indexed" title="Click to index workspace for better refinement">⚠️ Not indexed</span>';
+    
+    return /*html*/ `
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Prompt Refiner</title>
+  <style>
+    * {
+      box-sizing: border-box;
+      margin: 0;
+      padding: 0;
+    }
+    
+    body {
+      font-family: var(--vscode-font-family);
+      background: var(--vscode-editor-background);
+      color: var(--vscode-editor-foreground);
+      padding: 16px;
+      height: 100vh;
+      display: flex;
+      flex-direction: column;
+    }
+    
+    .header {
+      display: flex;
+      align-items: center;
+      gap: 8px;
+      margin-bottom: 16px;
+      padding-bottom: 12px;
+      border-bottom: 1px solid var(--vscode-widget-border);
+    }
+    
+    .header h1 {
+      font-size: 16px;
+      font-weight: 600;
+    }
+    
+    .header .sparkle {
+      font-size: 20px;
+    }
+    
+    .input-container {
+      flex: 1;
+      display: flex;
+      flex-direction: column;
+      min-height: 0;
+    }
+    
+    .prompt-input {
+      flex: 1;
+      width: 100%;
+      padding: 12px;
+      border: 1px solid var(--vscode-input-border);
+      background: var(--vscode-input-background);
+      color: var(--vscode-input-foreground);
+      border-radius: 6px;
+      font-family: var(--vscode-editor-font-family);
+      font-size: 13px;
+      line-height: 1.5;
+      resize: none;
+      min-height: 150px;
+    }
+    
+    .prompt-input:focus {
+      outline: none;
+      border-color: var(--vscode-focusBorder);
+    }
+    
+    .prompt-input::placeholder {
+      color: var(--vscode-input-placeholderForeground);
+    }
+    
+    .mode-selector {
+      display: flex;
+      gap: 6px;
+      margin: 12px 0;
+      flex-wrap: wrap;
+    }
+    
+    .mode-btn {
+      padding: 6px 12px;
+      border: 1px solid var(--vscode-button-secondaryBackground);
+      background: var(--vscode-button-secondaryBackground);
+      color: var(--vscode-button-secondaryForeground);
+      border-radius: 16px;
+      font-size: 11px;
+      cursor: pointer;
+      transition: all 0.15s ease;
+    }
+    
+    .mode-btn:hover {
+      background: var(--vscode-button-secondaryHoverBackground);
+    }
+    
+    .mode-btn.active {
+      background: var(--vscode-button-background);
+      color: var(--vscode-button-foreground);
+      border-color: var(--vscode-button-background);
+    }
+    
+    .actions {
+      display: flex;
+      gap: 8px;
+      margin-top: 12px;
+    }
+    
+    .btn {
+      flex: 1;
+      padding: 10px 16px;
+      border: none;
+      border-radius: 6px;
+      font-size: 13px;
+      font-weight: 500;
+      cursor: pointer;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      gap: 6px;
+      transition: all 0.15s ease;
+    }
+    
+    .btn-primary {
+      background: var(--vscode-button-background);
+      color: var(--vscode-button-foreground);
+    }
+    
+    .btn-primary:hover {
+      background: var(--vscode-button-hoverBackground);
+    }
+    
+    .btn-secondary {
+      background: var(--vscode-button-secondaryBackground);
+      color: var(--vscode-button-secondaryForeground);
+    }
+    
+    .btn-secondary:hover {
+      background: var(--vscode-button-secondaryHoverBackground);
+    }
+    
+    .btn:disabled {
+      opacity: 0.6;
+      cursor: not-allowed;
+    }
+    
+    .btn .icon {
+      font-size: 14px;
+    }
+    
+    .status {
+      margin-top: 12px;
+      padding: 10px;
+      border-radius: 6px;
+      font-size: 12px;
+      display: none;
+    }
+    
+    .status.visible {
+      display: block;
+    }
+    
+    .status.loading {
+      background: var(--vscode-inputValidation-infoBackground);
+      border: 1px solid var(--vscode-inputValidation-infoBorder);
+    }
+    
+    .status.success {
+      background: var(--vscode-inputValidation-infoBackground);
+      border: 1px solid var(--vscode-charts-green);
+    }
+    
+    .status.error {
+      background: var(--vscode-inputValidation-errorBackground);
+      border: 1px solid var(--vscode-inputValidation-errorBorder);
+    }
+    
+    .changes-list {
+      margin-top: 8px;
+      padding-left: 16px;
+    }
+    
+    .changes-list li {
+      margin: 4px 0;
+      font-size: 11px;
+      color: var(--vscode-descriptionForeground);
+    }
+    
+    .spinner {
+      display: inline-block;
+      width: 14px;
+      height: 14px;
+      border: 2px solid var(--vscode-button-foreground);
+      border-top-color: transparent;
+      border-radius: 50%;
+      animation: spin 0.8s linear infinite;
+    }
+    
+    @keyframes spin {
+      to { transform: rotate(360deg); }
+    }
+    
+    .char-count {
+      font-size: 11px;
+      color: var(--vscode-descriptionForeground);
+      text-align: right;
+      margin-top: 4px;
+    }
+    
+    .tip {
+      font-size: 11px;
+      color: var(--vscode-descriptionForeground);
+      margin-top: 8px;
+      padding: 8px;
+      background: var(--vscode-textBlockQuote-background);
+      border-radius: 4px;
+      border-left: 3px solid var(--vscode-textLink-foreground);
+    }
+    
+    .index-status {
+      font-size: 11px;
+      padding: 4px 8px;
+      border-radius: 12px;
+      cursor: pointer;
+    }
+    
+    .index-status.indexed {
+      background: var(--vscode-testing-iconPassed);
+      color: var(--vscode-editor-background);
+    }
+    
+    .index-status.not-indexed {
+      background: var(--vscode-inputValidation-warningBackground);
+      border: 1px solid var(--vscode-inputValidation-warningBorder);
+    }
+    
+    .index-status:hover {
+      opacity: 0.8;
+    }
+  </style>
+</head>
+<body>
+  <div class="header">
+    <span class="sparkle">✨</span>
+    <h1>Prompt Refiner</h1>
+    ${indexStatus}
+  </div>
+  
+  <div class="input-container">
+    <textarea 
+      class="prompt-input" 
+      id="promptInput" 
+      placeholder="Type or paste your prompt here...&#10;&#10;Then click 'Refine' to improve it before sending to your AI chat."
+    ></textarea>
+    <div class="char-count"><span id="charCount">0</span> characters</div>
+  </div>
+  
+  <div class="mode-selector">
+    <button class="mode-btn active" data-mode="clarity" title="Improve clarity and specificity">🎯 Clarity</button>
+    <button class="mode-btn" data-mode="detailed" title="Add more context and details">📝 Detailed</button>
+    <button class="mode-btn" data-mode="concise" title="Make more concise">✂️ Concise</button>
+    <button class="mode-btn" data-mode="technical" title="Add technical precision">⚙️ Technical</button>
+    <button class="mode-btn" data-mode="structured" title="Add structure and formatting">📋 Structured</button>
+  </div>
+  
+  <div class="actions">
+    <button class="btn btn-primary" id="refineBtn">
+      <span class="icon">✨</span>
+      <span class="btn-text">Refine</span>
+    </button>
+    <button class="btn btn-secondary" id="copyBtn">
+      <span class="icon">📋</span>
+      Copy
+    </button>
+    <button class="btn btn-secondary" id="sendBtn" title="Copy to clipboard and open chat">
+      <span class="icon">💬</span>
+      Send to Chat
+    </button>
+  </div>
+  
+  <div class="status" id="status"></div>
+  
+  <div class="tip">
+    💡 <strong>Tip:</strong> After refining, click "Send to Chat" to copy and open Copilot Chat, then paste with Ctrl+V.
+  </div>
+
+  <script>
+    const vscode = acquireVsCodeApi();
+    const input = document.getElementById('promptInput');
+    const charCount = document.getElementById('charCount');
+    const refineBtn = document.getElementById('refineBtn');
+    const copyBtn = document.getElementById('copyBtn');
+    const sendBtn = document.getElementById('sendBtn');
+    const status = document.getElementById('status');
+    const modeBtns = document.querySelectorAll('.mode-btn');
+    const indexStatus = document.querySelector('.index-status');
+    
+    let currentMode = 'clarity';
+    let isLoading = false;
+    
+    // Index status click handler
+    if (indexStatus) {
+      indexStatus.addEventListener('click', () => {
+        vscode.postMessage({ command: 'indexWorkspace' });
+      });
+    }
+    
+    // Update character count
+    input.addEventListener('input', () => {
+      charCount.textContent = input.value.length;
+    });
+    
+    // Mode selection
+    modeBtns.forEach(btn => {
+      btn.addEventListener('click', () => {
+        modeBtns.forEach(b => b.classList.remove('active'));
+        btn.classList.add('active');
+        currentMode = btn.dataset.mode;
+      });
+    });
+    
+    // Refine button
+    refineBtn.addEventListener('click', () => {
+      if (isLoading) return;
+      vscode.postMessage({
+        command: 'refine',
+        text: input.value,
+        mode: currentMode
+      });
+    });
+    
+    // Copy button
+    copyBtn.addEventListener('click', () => {
+      vscode.postMessage({
+        command: 'copyToClipboard',
+        text: input.value
+      });
+    });
+    
+    // Send to chat button
+    sendBtn.addEventListener('click', () => {
+      vscode.postMessage({
+        command: 'sendToChat',
+        text: input.value
+      });
+    });
+    
+    // Handle keyboard shortcuts
+    input.addEventListener('keydown', (e) => {
+      // Ctrl+Enter to refine
+      if (e.ctrlKey && e.key === 'Enter') {
+        e.preventDefault();
+        refineBtn.click();
+      }
+      // Ctrl+Shift+Enter to send to chat
+      if (e.ctrlKey && e.shiftKey && e.key === 'Enter') {
+        e.preventDefault();
+        sendBtn.click();
+      }
+    });
+    
+    // Handle messages from extension
+    window.addEventListener('message', event => {
+      const message = event.data;
+      
+      switch (message.command) {
+        case 'prefill':
+          input.value = message.text;
+          charCount.textContent = message.text.length;
+          input.focus();
+          break;
+          
+        case 'loading':
+          isLoading = message.loading;
+          refineBtn.disabled = message.loading;
+          if (message.loading) {
+            refineBtn.innerHTML = '<span class="spinner"></span><span class="btn-text">Refining...</span>';
+            status.className = 'status visible loading';
+            status.innerHTML = '⏳ Refining your prompt...';
+          } else {
+            refineBtn.innerHTML = '<span class="icon">✨</span><span class="btn-text">Refine</span>';
+          }
+          break;
+          
+        case 'refined':
+          input.value = message.text;
+          charCount.textContent = message.text.length;
+          status.className = 'status visible success';
+          let html = '✅ Prompt refined successfully!';
+          if (message.changes && message.changes.length > 0) {
+            html += '<ul class="changes-list">';
+            message.changes.forEach(change => {
+              html += '<li>' + change + '</li>';
+            });
+            html += '</ul>';
+          }
+          status.innerHTML = html;
+          // Auto-hide after 5 seconds
+          setTimeout(() => {
+            status.className = 'status';
+          }, 5000);
+          break;
+          
+        case 'error':
+          status.className = 'status visible error';
+          status.innerHTML = '❌ ' + message.message;
+          break;
+      }
+    });
+    
+    // Focus input on load
+    input.focus();
+  </script>
+</body>
+</html>
+`;
+  }
+
+  private dispose() {
+    RefinerPanel.currentPanel = undefined;
+    this.panel.dispose();
+    while (this.disposables.length) {
+      const disposable = this.disposables.pop();
+      if (disposable) {
+        disposable.dispose();
+      }
+    }
+  }
+}

package/src/templates.ts

@@ -0,0 +1,61 @@
+/**
+ * Template Quick Pick Provider
+ */
+
+import * as vscode from 'vscode';
+
+export interface TemplateItem extends vscode.QuickPickItem {
+  value: string;
+}
+
+export const TEMPLATES: TemplateItem[] = [
+  {
+    label: '$(code) Coding',
+    value: 'coding',
+    description: 'Programming & development',
+    detail: 'Structured prompts for coding tasks with context, requirements, and constraints',
+  },
+  {
+    label: '$(book) Writing',
+    value: 'writing',
+    description: 'Content creation',
+    detail: 'Prompts optimized for writing with tone, audience, and style guidance',
+  },
+  {
+    label: '$(search) Research',
+    value: 'research',
+    description: 'Investigation & discovery',
+    detail: 'Research prompts with sources, methodology, and output format',
+  },
+  {
+    label: '$(graph) Analysis',
+    value: 'analysis',
+    description: 'Data & business analysis',
+    detail: 'Analysis prompts with metrics, comparisons, and recommendations',
+  },
+  {
+    label: '$(verified) Fact Check',
+    value: 'factcheck',
+    description: 'Verification & validation',
+    detail: 'Fact-checking prompts with claims, sources, and confidence levels',
+  },
+  {
+    label: '$(globe) General',
+    value: 'general',
+    description: 'General-purpose',
+    detail: 'Versatile template for any task type',
+  },
+];
+
+export class TemplateQuickPick {
+  static async show(): Promise<string | undefined> {
+    const selected = await vscode.window.showQuickPick(TEMPLATES, {
+      placeHolder: 'Select a template',
+      title: 'PromptArchitect - Choose Template',
+      matchOnDescription: true,
+      matchOnDetail: true,
+    });
+
+    return selected?.value;
+  }
+}