k0ntext 3.2.0 → 3.3.0

package/src/cli/repl/update/checker.ts

@@ -0,0 +1,209 @@
+/**
+ * Update Checker
+ *
+ * Checks for new versions of k0ntext and notifies users
+ */
+
+import https from 'https';
+import chalk from 'chalk';
+import { K0NTEXT_THEME } from '../tui/theme.js';
+
+/**
+ * Version comparison result
+ */
+export interface VersionCheckResult {
+  current: string;
+  latest: string;
+  hasUpdate: boolean;
+  type: 'major' | 'minor' | 'patch' | 'none';
+}
+
+/**
+ * Update notification options
+ */
+export interface UpdateNotificationOptions {
+  showIfCurrent: boolean;
+  checkInterval: number; // milliseconds
+}
+
+/**
+ * Update Checker
+ */
+export class UpdateChecker {
+  private currentVersion: string;
+  private lastCheck: number = 0;
+  private cachedResult: VersionCheckResult | null = null;
+  private checkInterval: number;
+
+  constructor(currentVersion: string, checkInterval = 24 * 60 * 60 * 1000) {
+    this.currentVersion = currentVersion;
+    this.checkInterval = checkInterval;
+  }
+
+  /**
+   * Check for updates (with caching)
+   */
+  async check(force = false): Promise<VersionCheckResult> {
+    const now = Date.now();
+
+    // Return cached result if still valid
+    if (!force && this.cachedResult && (now - this.lastCheck) < this.checkInterval) {
+      return this.cachedResult;
+    }
+
+    try {
+      const latest = await this.fetchLatestVersion();
+      const hasUpdate = this.needsUpdate(this.currentVersion, latest);
+      const type = this.getUpdateType(this.currentVersion, latest);
+
+      const result: VersionCheckResult = {
+        current: this.currentVersion,
+        latest,
+        hasUpdate,
+        type
+      };
+
+      this.cachedResult = result;
+      this.lastCheck = now;
+
+      return result;
+    } catch (error) {
+      // Return current version if check fails
+      return {
+        current: this.currentVersion,
+        latest: this.currentVersion,
+        hasUpdate: false,
+        type: 'none'
+      };
+    }
+  }
+
+  /**
+   * Fetch latest version from npm registry
+   */
+  private async fetchLatestVersion(): Promise<string> {
+    return new Promise((resolve, reject) => {
+      const options = {
+        hostname: 'registry.npmjs.org',
+        path: '/k0ntext',
+        timeout: 5000
+      };
+
+      const req = https.get(options, (res) => {
+        let data = '';
+
+        res.on('data', (chunk) => {
+          data += chunk;
+        });
+
+        res.on('end', () => {
+          try {
+            const pkg = JSON.parse(data);
+            const latest = pkg['dist-tags'].latest;
+            resolve(latest);
+          } catch (e) {
+            reject(e);
+          }
+        });
+      });
+
+      req.on('timeout', () => {
+        req.destroy();
+        reject(new Error('Request timeout'));
+      });
+
+      req.on('error', reject);
+    });
+  }
+
+  /**
+   * Check if current version needs update
+   */
+  private needsUpdate(current: string, latest: string): boolean {
+    return current !== latest;
+  }
+
+  /**
+   * Get update type
+   */
+  private getUpdateType(current: string, latest: string): 'major' | 'minor' | 'patch' | 'none' {
+    if (current === latest) return 'none';
+
+    const [cMajor, cMinor, cPatch] = current.split('.').map(Number);
+    const [lMajor, lMinor, lPatch] = latest.split('.').map(Number);
+
+    if (lMajor > cMajor) return 'major';
+    if (lMinor > cMinor) return 'minor';
+    if (lPatch > cPatch) return 'patch';
+
+    return 'none';
+  }
+
+  /**
+   * Get type emoji
+   */
+  private getTypeEmoji(type: 'major' | 'minor' | 'patch' | 'none'): string {
+    const emojis = {
+      major: '🚨',
+      minor: '✨',
+      patch: '🔧',
+      none: '✓'
+    };
+    return emojis[type];
+  }
+
+  /**
+   * Format update notification
+   */
+  formatNotification(result: VersionCheckResult): string {
+    if (!result.hasUpdate) {
+      return K0NTEXT_THEME.success('✓ You are on the latest version');
+    }
+
+    const typeEmoji = this.getTypeEmoji(result.type);
+
+    const updateMessage = [
+      '',
+      `${typeEmoji} ${K0NTEXT_THEME.highlight('Update Available')}`,
+      '',
+      `  ${K0NTEXT_THEME.primary('Current:')}  ${result.current}`,
+      `  ${K0NTEXT_THEME.success('Latest:')}   ${result.latest}`,
+      '',
+      `  Run ${K0NTEXT_THEME.highlight('npm update -g k0ntext')} to update`,
+      ''
+    ];
+
+    return updateMessage.join('\n');
+  }
+
+  /**
+   * Show notification if update available
+   */
+  async showNotification(options: UpdateNotificationOptions = { showIfCurrent: false, checkInterval: 24 * 60 * 60 * 1000 }): Promise<void> {
+    const { showIfCurrent = false } = options;
+
+    const result = await this.check();
+
+    if (result.hasUpdate) {
+      console.log(this.formatNotification(result));
+    } else if (showIfCurrent) {
+      console.log(K0NTEXT_THEME.success('\n✓ K0ntext is up to date'));
+    }
+  }
+
+  /**
+   * Check and prompt for update
+   */
+  async checkAndPrompt(): Promise<boolean> {
+    const result = await this.check();
+
+    if (!result.hasUpdate) {
+      return false;
+    }
+
+    console.log('');
+    console.log(this.formatNotification(result));
+
+    return true;
+  }
+}

package/src/db/client.ts

@@ -859,31 +859,33 @@ export class DatabaseClient {
   /**
    * Get database statistics
    */
-  getStats(): { 
-    items: number; 
-    relations: number; 
-    commits: number; 
+  getStats(): {
+    items: number;
+    relations: number;
+    commits: number;
     embeddings: number;
     toolConfigs: number;
+    path: string;
   } {
     const itemCount = (this.db.prepare('SELECT COUNT(*) as count FROM context_items').get() as { count: number }).count;
     const relationCount = (this.db.prepare('SELECT COUNT(*) as count FROM knowledge_graph').get() as { count: number }).count;
     const commitCount = (this.db.prepare('SELECT COUNT(*) as count FROM git_commits').get() as { count: number }).count;
     const toolConfigCount = (this.db.prepare('SELECT COUNT(*) as count FROM ai_tool_configs').get() as { count: number }).count;
-    
+
     let embeddingCount = 0;
     try {
       embeddingCount = (this.db.prepare('SELECT COUNT(*) as count FROM embeddings').get() as { count: number }).count;
     } catch {
       // Vector table might not exist yet
     }
-    
+
     return {
       items: itemCount,
       relations: relationCount,
       commits: commitCount,
       embeddings: embeddingCount,
-      toolConfigs: toolConfigCount
+      toolConfigs: toolConfigCount,
+      path: this.dbPath
     };
   }