promptarchitect 0.6.0

package/src/extension.ts

@@ -0,0 +1,822 @@
+/**
+ * PromptArchitect VS Code Extension
+ * 
+ * AI-powered prompt engineering directly in your editor.
+ * Requires authentication for continued use.
+ */
+
+import * as vscode from 'vscode';
+import { PromptArchitectAPI } from './api';
+import { TemplateQuickPick } from './templates';
+import { RefinerPanel } from './refinerPanel';
+import { ChatPanel } from './chatPanel';
+import { WorkspaceIndexer } from './workspaceIndexer';
+import { AuthService } from './authService';
+import { AgentService } from './agentService';
+import {
+  ScriptsTreeProvider,
+  QuickAccessTreeProvider,
+  EnvironmentTreeProvider,
+  NotesTreeProvider,
+  AIChatViewProvider,
+} from './providers';
+
+let api: PromptArchitectAPI;
+let authService: AuthService;
+let agentService: AgentService;
+let statusBarItem: vscode.StatusBarItem;
+let authStatusBarItem: vscode.StatusBarItem;
+let workspaceIndexer: WorkspaceIndexer;
+let selectionDebounce: NodeJS.Timeout | undefined;
+
+// Tree providers
+let scriptsProvider: ScriptsTreeProvider;
+let quickAccessProvider: QuickAccessTreeProvider;
+let environmentProvider: EnvironmentTreeProvider;
+let notesProvider: NotesTreeProvider;
+let aiChatProvider: AIChatViewProvider;
+
+export function activate(context: vscode.ExtensionContext) {
+  console.log('PromptArchitect extension activated');
+
+  // Initialize API client
+  const config = vscode.workspace.getConfiguration('promptarchitect');
+  const endpoint = config.get<string>('apiEndpoint') || 'https://us-central1-prompt-architect-3df7a.cloudfunctions.net/api';
+  api = new PromptArchitectAPI(endpoint);
+
+  // Initialize auth service
+  authService = AuthService.getInstance(context, endpoint);
+  context.subscriptions.push(authService);
+
+  // Set up auth token on API when session changes
+  authService.onDidChangeAuth(async (isAuthenticated) => {
+    if (isAuthenticated) {
+      const token = await authService.getAccessToken();
+      api.setAccessToken(token);
+    } else {
+      api.setAccessToken(null);
+    }
+    updateAuthStatusBar(isAuthenticated);
+  });
+
+  // Check auth status on startup and set token
+  initializeAuth(context);
+
+  // Initialize workspace indexer
+  workspaceIndexer = new WorkspaceIndexer(context);
+  workspaceIndexer.showStatusBar();
+  context.subscriptions.push(workspaceIndexer);
+
+  // Initialize agent service
+  agentService = AgentService.getInstance(context, api, workspaceIndexer);
+
+  // Set up proactive selection monitoring
+  setupProactiveFeatures(context);
+
+  // Initialize tree providers
+  scriptsProvider = new ScriptsTreeProvider(context);
+  quickAccessProvider = new QuickAccessTreeProvider(context);
+  environmentProvider = new EnvironmentTreeProvider(context);
+  notesProvider = new NotesTreeProvider(context);
+  aiChatProvider = new AIChatViewProvider(context, api);
+
+  // Register tree views
+  context.subscriptions.push(
+    vscode.window.registerTreeDataProvider('promptarchitect.scripts', scriptsProvider),
+    vscode.window.registerTreeDataProvider('promptarchitect.quickAccess', quickAccessProvider),
+    vscode.window.registerTreeDataProvider('promptarchitect.environment', environmentProvider),
+    vscode.window.registerTreeDataProvider('promptarchitect.notes', notesProvider),
+    vscode.window.registerWebviewViewProvider(AIChatViewProvider.viewType, aiChatProvider)
+  );
+
+  // Create main status bar item
+  if (config.get<boolean>('showStatusBar')) {
+    statusBarItem = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right, 100);
+    statusBarItem.text = '$(rocket) PromptArchitect';
+    statusBarItem.tooltip = 'Click to open Project Command Center';
+    statusBarItem.command = 'promptarchitect.openProjectHub';
+    statusBarItem.show();
+    context.subscriptions.push(statusBarItem);
+  }
+
+  // Create auth status bar item
+  authStatusBarItem = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right, 99);
+  authStatusBarItem.command = 'promptarchitect.manageAccount';
+  context.subscriptions.push(authStatusBarItem);
+
+  // Register original commands
+  context.subscriptions.push(
+    vscode.commands.registerCommand('promptarchitect.generatePrompt', generatePromptCommand),
+    vscode.commands.registerCommand('promptarchitect.refinePrompt', refinePromptCommand),
+    vscode.commands.registerCommand('promptarchitect.analyzePrompt', analyzePromptCommand),
+    vscode.commands.registerCommand('promptarchitect.showTemplates', showTemplatesCommand),
+    vscode.commands.registerCommand('promptarchitect.refineForChat', refineForChatCommand),
+    vscode.commands.registerCommand('promptarchitect.quickRefine', quickRefineCommand),
+    vscode.commands.registerCommand('promptarchitect.openChat', openChatCommand),
+    vscode.commands.registerCommand('promptarchitect.indexWorkspace', indexWorkspaceCommand),
+    vscode.commands.registerCommand('promptarchitect.clearWorkspaceIndex', clearWorkspaceIndexCommand),
+    // Auth commands
+    vscode.commands.registerCommand('promptarchitect.signIn', signInCommand),
+    vscode.commands.registerCommand('promptarchitect.signOut', signOutCommand),
+    vscode.commands.registerCommand('promptarchitect.manageAccount', manageAccountCommand)
+  );
+
+  // Register Project Hub commands
+  context.subscriptions.push(
+    // Scripts commands
+    vscode.commands.registerCommand('promptarchitect.refreshScripts', () => scriptsProvider.refresh()),
+    vscode.commands.registerCommand('promptarchitect.addCustomScript', () => scriptsProvider.addCustomScript()),
+    vscode.commands.registerCommand('promptarchitect.runScript', (item) => scriptsProvider.runScript(item)),
+    vscode.commands.registerCommand('promptarchitect.stopScript', (item) => scriptsProvider.stopScript(item)),
+    
+    // Quick Access commands
+    vscode.commands.registerCommand('promptarchitect.pinCurrentFile', () => quickAccessProvider.pinCurrentFile()),
+    vscode.commands.registerCommand('promptarchitect.unpinFile', (item) => quickAccessProvider.unpinFile(item)),
+    vscode.commands.registerCommand('promptarchitect.openQuickAccessFile', (item) => quickAccessProvider.openFile(item)),
+    
+    // Environment commands
+    vscode.commands.registerCommand('promptarchitect.refreshEnv', () => environmentProvider.refresh()),
+    vscode.commands.registerCommand('promptarchitect.createEnvFile', () => environmentProvider.createEnvFile()),
+    vscode.commands.registerCommand('promptarchitect.copyEnvValue', (item) => environmentProvider.copyValue(item)),
+    vscode.commands.registerCommand('promptarchitect.openEnvFile', (item) => environmentProvider.openEnvFile(item)),
+    
+    // Notes commands
+    vscode.commands.registerCommand('promptarchitect.addNote', () => notesProvider.addNote()),
+    vscode.commands.registerCommand('promptarchitect.toggleNote', (item) => notesProvider.toggleNote(item)),
+    vscode.commands.registerCommand('promptarchitect.deleteNote', (item) => notesProvider.deleteNote(item)),
+    
+    // Project Hub command
+    vscode.commands.registerCommand('promptarchitect.openProjectHub', openProjectHubCommand)
+  );
+
+  // Show welcome message on first install
+  const hasShownWelcome = context.globalState.get('hasShownWelcome');
+  if (!hasShownWelcome) {
+    showWelcomeMessage();
+    context.globalState.update('hasShownWelcome', true);
+  }
+}
+
+/**
+ * Initialize authentication on startup
+ */
+async function initializeAuth(context: vscode.ExtensionContext) {
+  const isAuthenticated = await authService.isAuthenticated();
+  
+  if (isAuthenticated) {
+    // Set the access token for API requests
+    const token = await authService.getAccessToken();
+    api.setAccessToken(token);
+    updateAuthStatusBar(true);
+  } else {
+    updateAuthStatusBar(false);
+    // Prompt existing users to sign in
+    const hasUsedBefore = context.globalState.get('hasUsedBefore');
+    if (hasUsedBefore) {
+      // This is an existing user who needs to sign in
+      setTimeout(() => {
+        showAuthRequiredMessage();
+      }, 2000);
+    }
+  }
+  
+  // Mark that the extension has been used
+  await context.globalState.update('hasUsedBefore', true);
+}
+
+/**
+ * Update auth status bar
+ */
+function updateAuthStatusBar(isAuthenticated: boolean) {
+  if (!authStatusBarItem) return;
+  
+  if (isAuthenticated) {
+    authService.getCurrentUser().then((user) => {
+      if (user) {
+        authStatusBarItem.text = `$(account) ${user.displayName}`;
+        authStatusBarItem.tooltip = `Signed in as ${user.email}\nClick to manage account`;
+      } else {
+        authStatusBarItem.text = '$(account) Signed In';
+        authStatusBarItem.tooltip = 'Click to manage account';
+      }
+    });
+  } else {
+    authStatusBarItem.text = '$(sign-in) Sign In';
+    authStatusBarItem.tooltip = 'Sign in to use PromptArchitect';
+  }
+  authStatusBarItem.show();
+}
+
+/**
+ * Show auth required message for existing users
+ */
+async function showAuthRequiredMessage() {
+  const result = await vscode.window.showWarningMessage(
+    '🔐 PromptArchitect now requires sign-in. Please sign in or create an account to continue using the extension.',
+    { modal: false },
+    'Sign In',
+    'Create Account',
+    'Learn More'
+  );
+
+  if (result === 'Sign In' || result === 'Create Account') {
+    await authService.signIn();
+  } else if (result === 'Learn More') {
+    vscode.env.openExternal(vscode.Uri.parse('https://promptarchitectlabs.com/auth'));
+  }
+}
+
+/**
+ * Sign in command
+ */
+async function signInCommand() {
+  await authService.signIn();
+}
+
+/**
+ * Sign out command
+ */
+async function signOutCommand() {
+  await authService.signOut();
+}
+
+/**
+ * Manage account command
+ */
+async function manageAccountCommand() {
+  const isAuthenticated = await authService.isAuthenticated();
+  
+  if (!isAuthenticated) {
+    await authService.signIn();
+    return;
+  }
+
+  const user = await authService.getCurrentUser();
+  const choice = await vscode.window.showQuickPick(
+    [
+      { label: '$(account) ' + (user?.displayName || 'Account'), description: user?.email, kind: vscode.QuickPickItemKind.Default },
+      { label: '', kind: vscode.QuickPickItemKind.Separator },
+      { label: '$(gear) Account Settings', value: 'settings' },
+      { label: '$(history) Usage History', value: 'usage' },
+      { label: '$(sign-out) Sign Out', value: 'signout' },
+    ],
+    {
+      placeHolder: 'Manage your PromptArchitect account',
+    }
+  );
+
+  if ((choice as any)?.value === 'signout') {
+    await authService.signOut();
+  } else if ((choice as any)?.value === 'settings') {
+    vscode.env.openExternal(vscode.Uri.parse('https://promptarchitectlabs.com/settings'));
+  } else if ((choice as any)?.value === 'usage') {
+    vscode.env.openExternal(vscode.Uri.parse('https://promptarchitectlabs.com/usage'));
+  }
+}
+
+/**
+ * Check if user is authenticated, prompt if not
+ * Returns true if authenticated, false if user declined
+ */
+async function requireAuth(): Promise<boolean> {
+  return authService.requireAuth();
+}
+
+export function deactivate() {
+  console.log('PromptArchitect extension deactivated');
+}
+
+/**
+ * Generate a prompt from an idea
+ */
+async function generatePromptCommand() {
+  // Require authentication
+  if (!await requireAuth()) {
+    return;
+  }
+
+  const config = vscode.workspace.getConfiguration('promptarchitect');
+  const defaultTemplate = config.get<string>('defaultTemplate') || 'general';
+  const targetModel = config.get<string>('targetModel') || 'general';
+
+  // Get idea from user
+  const idea = await vscode.window.showInputBox({
+    prompt: 'Enter your idea or concept',
+    placeHolder: 'e.g., Write a function to parse JSON with error handling',
+    ignoreFocusOut: true,
+  });
+
+  if (!idea) {
+    return;
+  }
+
+  // Ask for template (quick pick)
+  const template = await vscode.window.showQuickPick(
+    [
+      { label: '$(code) Coding', value: 'coding', description: 'Programming & development' },
+      { label: '$(book) Writing', value: 'writing', description: 'Content creation' },
+      { label: '$(search) Research', value: 'research', description: 'Investigation & discovery' },
+      { label: '$(graph) Analysis', value: 'analysis', description: 'Data & business analysis' },
+      { label: '$(verified) Fact Check', value: 'factcheck', description: 'Verification & validation' },
+      { label: '$(globe) General', value: 'general', description: 'General-purpose' },
+    ],
+    {
+      placeHolder: 'Select a template (or press Enter for default)',
+      title: 'PromptArchitect - Choose Template',
+    }
+  );
+
+  const selectedTemplate = template?.value || defaultTemplate;
+
+  // Show progress
+  await vscode.window.withProgress(
+    {
+      location: vscode.ProgressLocation.Notification,
+      title: 'PromptArchitect',
+      cancellable: false,
+    },
+    async (progress) => {
+      progress.report({ message: 'Generating prompt...' });
+
+      try {
+        const result = await api.generatePrompt({
+          idea,
+          template: selectedTemplate,
+          targetModel,
+        });
+
+        // Show result in new document
+        const doc = await vscode.workspace.openTextDocument({
+          content: result.prompt,
+          language: 'markdown',
+        });
+        await vscode.window.showTextDocument(doc, { preview: false });
+
+        // Show success message with metadata
+        vscode.window.showInformationMessage(
+          `✨ Prompt generated! Template: ${selectedTemplate}, Target: ${targetModel}`
+        );
+      } catch (error) {
+        vscode.window.showErrorMessage(`Failed to generate prompt: ${error}`);
+      }
+    }
+  );
+}
+
+/**
+ * Refine a selected prompt
+ */
+async function refinePromptCommand() {
+  // Require authentication
+  if (!await requireAuth()) {
+    return;
+  }
+
+  const editor = vscode.window.activeTextEditor;
+  if (!editor) {
+    vscode.window.showWarningMessage('No active editor');
+    return;
+  }
+
+  const selection = editor.selection;
+  const selectedText = editor.document.getText(selection);
+
+  if (!selectedText) {
+    vscode.window.showWarningMessage('Please select some text to refine');
+    return;
+  }
+
+  // Get feedback from user
+  const feedback = await vscode.window.showInputBox({
+    prompt: 'How should this prompt be improved?',
+    placeHolder: 'e.g., Make it more specific, add error handling requirements',
+    ignoreFocusOut: true,
+  });
+
+  if (!feedback) {
+    return;
+  }
+
+  const config = vscode.workspace.getConfiguration('promptarchitect');
+  const targetModel = config.get<string>('targetModel') || 'general';
+
+  await vscode.window.withProgress(
+    {
+      location: vscode.ProgressLocation.Notification,
+      title: 'PromptArchitect',
+      cancellable: false,
+    },
+    async (progress) => {
+      progress.report({ message: 'Refining prompt...' });
+
+      try {
+        const result = await api.refinePrompt({
+          prompt: selectedText,
+          feedback,
+          targetModel,
+        });
+
+        // Replace selection with refined prompt
+        await editor.edit((editBuilder) => {
+          editBuilder.replace(selection, result.refinedPrompt);
+        });
+
+        vscode.window.showInformationMessage('✨ Prompt refined successfully!');
+      } catch (error) {
+        vscode.window.showErrorMessage(`Failed to refine prompt: ${error}`);
+      }
+    }
+  );
+}
+
+/**
+ * Analyze prompt quality
+ */
+async function analyzePromptCommand() {
+  // Require authentication
+  if (!await requireAuth()) {
+    return;
+  }
+
+  const editor = vscode.window.activeTextEditor;
+  let promptText = '';
+
+  if (editor && !editor.selection.isEmpty) {
+    promptText = editor.document.getText(editor.selection);
+  } else {
+    // Ask for prompt input
+    const input = await vscode.window.showInputBox({
+      prompt: 'Enter the prompt to analyze',
+      placeHolder: 'Paste your prompt here...',
+      ignoreFocusOut: true,
+    });
+    if (!input) return;
+    promptText = input;
+  }
+
+  await vscode.window.withProgress(
+    {
+      location: vscode.ProgressLocation.Notification,
+      title: 'PromptArchitect',
+      cancellable: false,
+    },
+    async (progress) => {
+      progress.report({ message: 'Analyzing prompt...' });
+
+      try {
+        const result = await api.analyzePrompt({ prompt: promptText });
+
+        // Format analysis as markdown
+        const analysis = `# Prompt Analysis
+
+## Scores
+| Metric | Score |
+|--------|-------|
+| Clarity | ${result.scores.clarity}/100 |
+| Specificity | ${result.scores.specificity}/100 |
+| Structure | ${result.scores.structure}/100 |
+| Actionability | ${result.scores.actionability}/100 |
+| **Overall** | **${result.overallScore}/100** |
+
+## Strengths
+${result.strengths.map((s: string) => `- ✅ ${s}`).join('\n')}
+
+## Suggestions
+${result.suggestions.map((s: string) => `- 💡 ${s}`).join('\n')}
+
+---
+*Analyzed by PromptArchitect*
+`;
+
+        // Show in new document
+        const doc = await vscode.workspace.openTextDocument({
+          content: analysis,
+          language: 'markdown',
+        });
+        await vscode.window.showTextDocument(doc, {
+          preview: true,
+          viewColumn: vscode.ViewColumn.Beside,
+        });
+      } catch (error) {
+        vscode.window.showErrorMessage(`Failed to analyze prompt: ${error}`);
+      }
+    }
+  );
+}
+
+/**
+ * Show template browser
+ */
+async function showTemplatesCommand() {
+  const templates = [
+    {
+      label: '$(code) Coding Template',
+      detail: 'Structured for programming tasks with context, requirements, and constraints',
+      value: 'coding',
+    },
+    {
+      label: '$(book) Writing Template',
+      detail: 'Optimized for content creation with tone, audience, and style guidance',
+      value: 'writing',
+    },
+    {
+      label: '$(search) Research Template',
+      detail: 'Designed for investigation with sources, methodology, and output format',
+      value: 'research',
+    },
+    {
+      label: '$(graph) Analysis Template',
+      detail: 'Structured for data analysis with metrics, comparisons, and recommendations',
+      value: 'analysis',
+    },
+    {
+      label: '$(verified) Fact Check Template',
+      detail: 'Optimized for verification with claims, sources, and confidence levels',
+      value: 'factcheck',
+    },
+    {
+      label: '$(globe) General Template',
+      detail: 'Versatile template for any task type',
+      value: 'general',
+    },
+  ];
+
+  const selected = await vscode.window.showQuickPick(templates, {
+    placeHolder: 'Select a template to use',
+    title: 'PromptArchitect Templates',
+  });
+
+  if (selected) {
+    // Update default template setting
+    const config = vscode.workspace.getConfiguration('promptarchitect');
+    await config.update('defaultTemplate', selected.value, vscode.ConfigurationTarget.Global);
+    
+    vscode.window.showInformationMessage(
+      `Default template set to: ${selected.label.replace(/\$\([^)]+\)\s*/, '')}`
+    );
+
+    // Optionally trigger generate with this template
+    const generate = await vscode.window.showQuickPick(['Yes', 'No'], {
+      placeHolder: 'Generate a prompt with this template now?',
+    });
+
+    if (generate === 'Yes') {
+      vscode.commands.executeCommand('promptarchitect.generatePrompt');
+    }
+  }
+}
+
+/**
+ * Open the Refiner Panel for interactive prompt refinement
+ * This allows users to refine prompts before sending to any AI chat
+ */
+async function refineForChatCommand() {
+  // Require authentication
+  if (!await requireAuth()) {
+    return;
+  }
+
+  // Open the refiner panel
+  RefinerPanel.createOrShow(api);
+
+  // If there's selected text, prefill it
+  const editor = vscode.window.activeTextEditor;
+  if (editor && !editor.selection.isEmpty) {
+    const selectedText = editor.document.getText(editor.selection);
+    // Small delay to ensure panel is ready
+    setTimeout(() => {
+      RefinerPanel.prefill(selectedText);
+    }, 100);
+  }
+}
+
+/**
+ * Quick refine - instantly refine selected text with default settings
+ */
+async function quickRefineCommand() {
+  // Require authentication
+  if (!await requireAuth()) {
+    return;
+  }
+
+  const editor = vscode.window.activeTextEditor;
+  if (!editor) {
+    vscode.window.showWarningMessage('No active editor');
+    return;
+  }
+
+  const selection = editor.selection;
+  const selectedText = editor.document.getText(selection);
+
+  if (!selectedText) {
+    vscode.window.showWarningMessage('Please select some text to refine');
+    return;
+  }
+
+  const config = vscode.workspace.getConfiguration('promptarchitect');
+  const targetModel = config.get<string>('targetModel') || 'general';
+
+  await vscode.window.withProgress(
+    {
+      location: vscode.ProgressLocation.Notification,
+      title: 'PromptArchitect',
+      cancellable: false,
+    },
+    async (progress) => {
+      progress.report({ message: 'Quick refining...' });
+
+      try {
+        const result = await api.refinePrompt({
+          prompt: selectedText,
+          feedback: 'Improve clarity, specificity, and structure. Make this prompt more effective for AI assistants.',
+          targetModel,
+        });
+
+        // Replace selection with refined prompt
+        await editor.edit((editBuilder) => {
+          editBuilder.replace(selection, result.refinedPrompt);
+        });
+
+        vscode.window.showInformationMessage('⚡ Quick refined!');
+      } catch (error) {
+        vscode.window.showErrorMessage(`Failed to refine: ${error}`);
+      }
+    }
+  );
+}
+
+/**
+ * Open the PromptArchitect Chat Panel
+ * Full AI chat interface with built-in prompt refinement
+ */
+async function openChatCommand() {
+  // Chat does not require authentication for basic usage
+  ChatPanel.createOrShow(api);
+
+  // If there's selected text, prefill it
+  const editor = vscode.window.activeTextEditor;
+  if (editor && !editor.selection.isEmpty) {
+    const selectedText = editor.document.getText(editor.selection);
+    setTimeout(() => {
+      ChatPanel.prefillPrompt(selectedText);
+    }, 100);
+  }
+}
+
+/**
+ * Open the Project Command Center in the Activity Bar
+ */
+async function openProjectHubCommand() {
+  // Focus on the Project Command Center view container
+  await vscode.commands.executeCommand('workbench.view.extension.promptarchitect-hub');
+}
+
+/**
+ * Index the workspace for better prompt context
+ */
+async function indexWorkspaceCommand() {
+  await workspaceIndexer.indexWorkspace();
+}
+
+/**
+ * Clear the workspace index
+ */
+async function clearWorkspaceIndexCommand() {
+  const confirm = await vscode.window.showWarningMessage(
+    'Clear the workspace index? You can re-index at any time.',
+    { modal: true },
+    'Clear Index'
+  );
+  
+  if (confirm === 'Clear Index') {
+    await workspaceIndexer.clearIndex();
+    vscode.window.showInformationMessage('Workspace index cleared');
+  }
+}
+
+/**
+ * Get workspace context for prompt refinement
+ */
+export function getWorkspaceContext(): string {
+  return workspaceIndexer?.getContextForPrompt() || '';
+}
+
+/**
+ * Check if workspace has been indexed
+ */
+export function hasWorkspaceIndex(): boolean {
+  return workspaceIndexer?.hasValidIndex() || false;
+}
+
+/**
+ * Prompt user to index workspace if not indexed
+ */
+export async function promptToIndexWorkspace(): Promise<boolean> {
+  if (!workspaceIndexer) return false;
+  return workspaceIndexer.promptToIndex();
+}
+
+/**
+ * Ensure workspace is indexed (automatic, no user interaction)
+ * This is used by the autonomous prompt contextualization module
+ */
+export async function ensureWorkspaceIndexed(): Promise<boolean> {
+  if (!workspaceIndexer) return false;
+  return workspaceIndexer.ensureIndexed();
+}
+
+/**
+ * Show welcome message
+ */
+function showWelcomeMessage() {
+  vscode.window
+    .showInformationMessage(
+      '🎉 Welcome to PromptArchitect! Generate, refine, and analyze AI prompts with no API key required.',
+      'Generate Prompt',
+      'Learn More'
+    )
+    .then((selection) => {
+      if (selection === 'Generate Prompt') {
+        vscode.commands.executeCommand('promptarchitect.generatePrompt');
+      } else if (selection === 'Learn More') {
+        vscode.env.openExternal(vscode.Uri.parse('https://promptarchitect.com'));
+      }
+    });
+}
+
+/**
+ * Set up proactive features like selection monitoring and auto-suggestions
+ */
+function setupProactiveFeatures(context: vscode.ExtensionContext) {
+  const config = vscode.workspace.getConfiguration('promptarchitect');
+  const proactiveEnabled = config.get<boolean>('proactiveRefine', false);
+
+  if (!proactiveEnabled) return;
+
+  // Monitor text selection changes
+  context.subscriptions.push(
+    vscode.window.onDidChangeTextEditorSelection(async (event) => {
+      // Clear previous debounce
+      if (selectionDebounce) {
+        clearTimeout(selectionDebounce);
+      }
+
+      // Only process if there's a selection
+      if (event.selections.length === 0 || event.selections[0].isEmpty) {
+        return;
+      }
+
+      // Debounce to avoid too many API calls
+      selectionDebounce = setTimeout(async () => {
+        try {
+          const editor = event.textEditor;
+          const selection = editor.selection;
+          const selectedText = editor.document.getText(selection);
+
+          // Only process if selection looks like a prompt (reasonable length)
+          if (selectedText.length < 20 || selectedText.length > 1000) {
+            return;
+          }
+
+          // Check if it might be a prompt worth refining
+          const suggestion = await agentService.getProactiveRefinement();
+
+          if (suggestion) {
+            // Show a subtle notification with the suggestion
+            const action = await vscode.window.showInformationMessage(
+              `💡 Prompt tip: ${suggestion}`,
+              'Refine Now',
+              'Dismiss'
+            );
+
+            if (action === 'Refine Now') {
+              vscode.commands.executeCommand('promptarchitect.quickRefine');
+            }
+          }
+        } catch {
+          // Silently ignore errors in proactive features
+        }
+      }, 1500); // Wait 1.5 seconds after selection stops
+    })
+  );
+
+  // Monitor file saves for auto-indexing
+  context.subscriptions.push(
+    vscode.workspace.onDidSaveTextDocument(async (document) => {
+      // Re-index on significant file saves
+      const significantFiles = ['package.json', 'tsconfig.json', '.env'];
+      const fileName = document.fileName.split(/[\\/]/).pop() || '';
+
+      if (significantFiles.includes(fileName)) {
+        await workspaceIndexer.ensureIndexed();
+      }
+    })
+  );
+}
+
+/**
+ * Get the agent service instance
+ */
+export function getAgentService(): AgentService {
+  return agentService;
+}