@mrpatronz/nexusflow 0.2.13 → 0.2.18

package/src/server.ts

@@ -9,16 +9,20 @@ import { serveStatic } from '@hono/node-server/serve-static';
 import { cors } from 'hono/cors';
 import { streamSSE } from 'hono/streaming';
 import * as fs from 'node:fs/promises';
+import { createWriteStream, existsSync } from 'node:fs';
 import * as path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { execa } from 'execa';
+import * as os from 'node:os';
+import { pipeline } from 'node:stream/promises';
+import { spawn } from 'node:child_process';
 
 import { loadConfig, saveConfig, getConfigDir } from './core/config.js';
+import { listStorageProviders } from './core/adapters/registry.js';
 import { scanForRepos } from './core/scanner.js';
 import { createWorkspace, listWorkspaces, loadFeatureConfig, deleteWorkspace, addRepoToWorkspace } from './core/workspace.js';
 import { analyzeAllRepos } from './analyzers/index.js';
 import { generateContextFiles } from './generators/index.js';
-import { packWorkspace } from './core/packer.js';
 import { isOllamaModelAvailable, getOpenAiCompatibleUrl, callLocalLlm } from './utils/local-ai.js';
 import { detectAIAssistants } from './utils/detect-ai.js';
 import { detectEditors } from './utils/detect-editors.js';
@@ -33,7 +37,9 @@ import {
   loadRunningState,
 } from './orchestration/index.js';
 import { checkForUpdates, getCurrentVersion, getToolsStatus } from './utils/update-check.js';
+import { getWorkflowTemplates, saveWorkflowTemplate, deleteWorkflowTemplate } from './utils/workflows.js';
 import type { Feature, RepoInfo, WorkspaceContext } from './types.js';
+import { suggestWorkflow } from './utils/workflow-advisor.js';
 
 // Resolve static files directory
 const __filename = fileURLToPath(import.meta.url);
@@ -71,10 +77,24 @@ app.get('/api/config', async (c) => {
   }
 });
 
+// Get all registered storage adapters
+app.get('/api/adapters', async (c) => {
+  try {
+    const adapters = listStorageProviders();
+    return c.json({ adapters });
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return c.json({ error: msg }, 500);
+  }
+});
+
 function isSafeLocalEndpoint(urlStr: string): boolean {
   try {
     const url = new URL(urlStr);
     const hostname = url.hostname.toLowerCase();
+    if (url.protocol === 'https:') {
+      return true;
+    }
     if (hostname === 'localhost' || hostname === '127.0.0.1' || hostname === '[::1]') {
       return true;
     }
@@ -94,7 +114,7 @@ app.post('/api/config', async (c) => {
     const newConfig = await c.req.json();
     if (newConfig?.localLlm?.enabled && newConfig.localLlm.endpoint) {
       if (!isSafeLocalEndpoint(newConfig.localLlm.endpoint)) {
-        return c.json({ error: 'Local AI endpoint must be localhost, 127.0.0.1, or a private LAN IP.' }, 400);
+        return c.json({ error: 'Local AI endpoint must be HTTPS, localhost, 127.0.0.1, or a private LAN IP.' }, 400);
       }
     }
     await saveConfig(newConfig);
@@ -154,15 +174,15 @@ app.get('/api/editor-detect', async (c) => {
 // 6.5. Local LLM test & recommendation
 app.post('/api/local-llm/test', async (c) => {
   try {
-    const { provider, endpoint, model, shoot } = await c.req.json();
+    const { provider, endpoint, model, apiKey, shoot } = await c.req.json();
     if (!endpoint || !isSafeLocalEndpoint(endpoint)) {
-      return c.json({ success: false, error: 'Local AI endpoint must be localhost, 127.0.0.1, or a private LAN IP.' }, 400);
+      return c.json({ success: false, error: 'Local AI endpoint must be HTTPS, localhost, 127.0.0.1, or a private LAN IP.' }, 400);
     }
     const cleanEndpoint = endpoint.replace(/\/$/, '');
     
     if (shoot) {
       const responseText = await callLocalLlm(
-        { enabled: true, provider, endpoint, model },
+        { enabled: true, provider, endpoint, model, apiKey },
         [{ role: 'user', content: 'Respond with the exact word "OK" and nothing else.' }]
       );
       const cleanResponse = responseText.trim();
@@ -298,6 +318,7 @@ async function runCreationJob(jobId: string, body: any, config: any) {
       createdAt: new Date().toISOString(),
       resumption: body.resumption,
       localLlmEnabled: body.localLlmEnabled,
+      teamworkInstructions: body.teamworkInstructions,
     };
     if (job) {
       job.feature = feature;
@@ -328,12 +349,7 @@ async function runCreationJob(jobId: string, body: any, config: any) {
     await generateContextFiles(ctx, body.assistants, workspacePath);
     updateJobStep(jobId, 'context', 'completed', 'AI context files generated.');
 
-    // Step 4: Pack codebase context
-    if (config.packContextXml) {
-      updateJobStep(jobId, 'pack', 'running', 'Packing codebase context with Repomix...');
-      const packResult = await packWorkspace(workspacePath);
-      updateJobStep(jobId, 'pack', 'completed', `Packed codebase context (${packResult.totalFiles} files, ${(packResult.fileSize / 1024).toFixed(2)} KB).`);
-    }
+    // XML context packing removed.
 
   } catch (error) {
     const msg = error instanceof Error ? error.message : String(error);
@@ -355,6 +371,7 @@ app.post('/api/workspace', async (c) => {
       repos: RepoInfo[];
       assistants: any[];
       localLlmEnabled?: boolean;
+      teamworkInstructions?: string;
       resumption?: {
         testCommand?: string;
         mockCommand?: string;
@@ -377,9 +394,7 @@ app.post('/api/workspace', async (c) => {
       { id: 'analysis', name: 'Analyze Repositories', status: 'pending', message: 'Waiting...' },
       { id: 'context', name: 'Generate AI Context Files', status: 'pending', message: 'Waiting...' },
     ];
-    if (config.packContextXml) {
-      steps.push({ id: 'pack', name: 'Pack Codebase Context', status: 'pending', message: 'Waiting...' });
-    }
+    // XML context packing removed.
 
     const job: CreationJob = {
       id: jobId,
@@ -484,6 +499,27 @@ app.post('/api/workspace/:id/repo', async (c) => {
   }
 });
 
+// 7.8. Suggest workflow strategy based on feature description & selected repos
+app.post('/api/workspace/suggest-workflow', async (c) => {
+  try {
+    const { description, repos } = await c.req.json() as {
+      description: string;
+      repos: RepoInfo[];
+    };
+
+    const config = await loadConfig();
+    const suggestion = await suggestWorkflow(description, repos, config.localLlm);
+
+    return c.json({
+      success: true,
+      ...suggestion
+    });
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return c.json({ error: msg }, 500);
+  }
+});
+
 // 8. Open workspace in editor
 app.post('/api/open-editor', async (c) => {
   try {
@@ -829,7 +865,7 @@ app.post('/api/workspace/:id/sync', async (c) => {
     const results = [];
 
     for (const repo of repos) {
-      const result = await rebaseRepo(repo.path, 'main');
+      const result = await rebaseRepo(repo.path, repo.defaultBranch || 'main');
       results.push({
         repoName: repo.name,
         success: result.success,
@@ -1025,7 +1061,6 @@ app.post('/api/updates/install', async (c) => {
     const { toolId } = await c.req.json() as { toolId: string };
     const tools = [
       { id: 'nexusflow', cmd: 'npm', args: ['install', '-g', '@mrpatronz/nexusflow'] },
-      { id: 'repomix', cmd: 'npm', args: ['install', '-g', 'repomix'] },
       { id: 'antigravity', cmd: 'agy', args: ['update'] },
       { id: 'claude', cmd: 'npm', args: ['install', '-g', '@anthropic-ai/claude-code'] },
     ];
@@ -1050,30 +1085,205 @@ app.post('/api/updates/install', async (c) => {
   }
 });
 
-// 18. Pack workspace codebase and download
-app.get('/api/workspace/:id/pack', async (c) => {
+let downloadedInstallerPath: string | null = null;
+
+// 17.7. Download matching GitHub Release installer to temporary folder
+app.post('/api/updates/download', async (c) => {
+  try {
+    const { downloadUrl } = await c.req.json() as { downloadUrl: string };
+    if (!downloadUrl) {
+      return c.json({ error: 'Download URL is required' }, 400);
+    }
+
+    const tempDir = os.tmpdir();
+    const fileName = 'NexusFlowSetup_Update.exe';
+    const targetPath = path.join(tempDir, fileName);
+
+    const response = await fetch(downloadUrl);
+    if (!response.ok) {
+      throw new Error(`HTTP error ${response.status}`);
+    }
+
+    // Node fetch body stream download
+    const fileStream = createWriteStream(targetPath);
+    if (!response.body) {
+      throw new Error('Response body is null');
+    }
+    
+    // Convert ReadableStream to Node stream
+    await pipeline(response.body as any, fileStream);
+
+    downloadedInstallerPath = targetPath;
+    return c.json({ success: true, path: targetPath });
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return c.json({ error: `Download failed: ${msg}` }, 500);
+  }
+});
+
+// 17.8. Launch the silent installer detached and exit server
+app.post('/api/updates/apply', async (c) => {
+  if (!downloadedInstallerPath || !existsSync(downloadedInstallerPath)) {
+    return c.json({ error: 'No downloaded installer found on disk' }, 400);
+  }
+
+  try {
+    const isWin = process.platform === 'win32';
+    if (isWin) {
+      // Inno Setup silent install flags
+      console.log(`Applying update: Spawning detached installer at: ${downloadedInstallerPath}`);
+      const child = spawn(downloadedInstallerPath, ['/VERYSILENT', '/SUPPRESSMSGBOXES', '/NORESTART'], {
+        detached: true,
+        stdio: 'ignore',
+      });
+      child.unref();
+    }
+
+    // Gracefully exit server process in 1 second to release file locks
+    setTimeout(() => {
+      console.log('Update installer successfully spawned. Exiting Hono server process...');
+      process.exit(0);
+    }, 1000);
+
+    return c.json({ success: true, message: 'Installer spawned, app shutting down...' });
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return c.json({ error: `Failed to execute update: ${msg}` }, 500);
+  }
+});
+
+// 17.9. Get available workflow templates
+app.get('/api/workflows/templates', async (c) => {
+  try {
+    const templates = await getWorkflowTemplates();
+    return c.json({ templates });
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return c.json({ error: msg }, 500);
+  }
+});
+
+// Save or update custom teamwork template
+app.post('/api/workflows/templates', async (c) => {
+  try {
+    const { id, name, content } = await c.req.json();
+    if (!name || !content) {
+      return c.json({ error: 'Name and content are required.' }, 400);
+    }
+    const template = await saveWorkflowTemplate(name, content, id);
+    return c.json({ success: true, template });
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return c.json({ error: msg }, 500);
+  }
+});
+
+// Delete custom teamwork template
+app.delete('/api/workflows/templates/:id', async (c) => {
   try {
     const id = decodeURIComponent(c.req.param('id'));
-    const config = await loadConfig();
-    const workspacePath = path.join(config.workspacesDir, id);
+    const templates = await getWorkflowTemplates();
+    const target = templates.find(t => t.id === id);
+    if (!target) {
+      return c.json({ error: 'Template not found.' }, 404);
+    }
+    if (!target.custom) {
+      return c.json({ error: 'Cannot delete built-in templates.' }, 403);
+    }
+    await deleteWorkflowTemplate(id);
+    return c.json({ success: true });
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return c.json({ error: msg }, 500);
+  }
+});
 
-    const feature = await loadFeatureConfig(workspacePath);
-    if (!feature) {
-      return c.json({ error: 'Workspace configuration not found.' }, 404);
+// Analyze teamwork template rules via selected AI coding assistant harness
+app.post('/api/workflows/templates/:id/analyze', async (c) => {
+  try {
+    const { content, assistant, comment } = await c.req.json();
+    if (!content) {
+      return c.json({ error: 'Content is required.' }, 400);
+    }
+
+    const selectedAssistant = assistant || 'antigravity';
+    let command = '';
+    let args: string[] = [];
+
+    let prompt = `You are an expert AI system engineering reviewer. Analyze the following Agent Teamwork Strategy guidelines.
+Evaluate its instructions, identify any ambiguities or contradictions, rate its expected effectiveness for orchestrating subagents, and provide specific recommendations or improvements. Format your analysis in clean Markdown with clear headings (e.g. Overview, Strengths, Weaknesses, Recommendations).
+
+After your analysis, provide a fully rewritten, optimized, and complete version of the strategy guidelines incorporating all your recommendations. This rewritten version must be suitable for production orchestration.
+You MUST prefix the rewritten version with the exact delimiter line:
+=== SUGGESTED IMPROVEMENT START ===
+and suffix it with:
+=== SUGGESTED IMPROVEMENT END ===`;
+
+    if (comment && comment.trim()) {
+      prompt += `\n\nIMPORTANT: The user has provided the following specific instruction/comment that you MUST consider and prioritize during your evaluation and when rewriting the guidelines:\n"${comment.trim()}"`;
+    }
+
+    prompt += `\n\n--- GUIDELINES START ---\n${content}\n--- GUIDELINES END ---`;
+
+    const assistants = await detectAIAssistants();
+    const target = assistants.find(ai => ai.name === selectedAssistant);
+    
+    if (!target || !target.detected || !target.command) {
+      return c.json({
+        error: `AI assistant harness '${selectedAssistant}' is not detected or does not support command-line execution.`
+      }, 400);
+    }
+
+    command = target.command;
+    if (command === 'claude') {
+      args = ['-p', prompt];
+    } else if (command === 'agy') {
+      args = [prompt];
+    } else {
+      args = [prompt];
+    }
+
+    const result = await execa(command, args, {
+      input: '',
+      shell: false,
+      reject: false
+    });
+
+    if (result.exitCode !== 0) {
+      return c.json({
+        error: `AI Assistant harness execution failed (exit code ${result.exitCode}): ${result.stderr || result.stdout || 'Unknown error'}`
+      }, 500);
     }
 
-    const result = await packWorkspace(workspacePath);
-    const content = await fs.readFile(result.outputPath, 'utf-8');
+    // Clean potential warning lines or stdout prefixes if present
+    let cleanText = result.stdout;
+    if (cleanText.includes('Warning: no stdin data received')) {
+      cleanText = cleanText.replace(/Warning: no stdin data received in \d+s, proceeding without it\. If piping from a slow command, redirect stdin explicitly: < \/dev\/null to skip, or wait longer\.\r?\n?/, '');
+    }
+
+    let analysis = cleanText.trim();
+    let suggestedImprovement = '';
+
+    const startDelimiter = '=== SUGGESTED IMPROVEMENT START ===';
+    const endDelimiter = '=== SUGGESTED IMPROVEMENT END ===';
+
+    const startIdx = cleanText.indexOf(startDelimiter);
+    const endIdx = cleanText.indexOf(endDelimiter);
 
-    c.header('Content-Disposition', `attachment; filename="nexusflow-context-${id.replace(/[\/\\ ]/g, '-')}.xml"`);
-    c.header('Content-Type', 'application/xml');
-    return c.text(content);
+    if (startIdx !== -1 && endIdx !== -1) {
+      analysis = cleanText.substring(0, startIdx).trim();
+      suggestedImprovement = cleanText.substring(startIdx + startDelimiter.length, endIdx).trim();
+    }
+
+    return c.json({ analysis, suggestedImprovement });
   } catch (error) {
     const msg = error instanceof Error ? error.message : String(error);
     return c.json({ error: msg }, 500);
   }
 });
 
+// Legacy pack endpoint removed.
+
 // Serve index.html explicitly on root endpoint
 app.get('/', async (c) => {
   try {

package/src/types.ts

@@ -11,6 +11,7 @@ export interface LocalLlmConfig {
   provider: 'ollama' | 'openai-compatible';
   endpoint: string;
   model: string;
+  apiKey?: string;
 }
 
 /** Top-level NexusFlow configuration stored in ~/.nexusflow/config.json. */
@@ -36,14 +37,22 @@ export interface NexusFlowConfig {
   /** Global patterns to exclude when packing/analyzing repositories. */
   excludePatterns?: string[];
 
-  /** Whether to pack codebase context into XML format. Default: true */
-  packContextXml?: boolean;
+  /** Active storage provider name. Default: 'local' */
+  storageProvider?: string;
+
+  /** Per-adapter settings keyed by adapter name. */
+  adapterConfig?: Record<string, Record<string, unknown>>;
+
+  /** List of plugin paths or npm packages to load. */
+  plugins?: string[];
 
   /** ISO timestamp of the last update check. */
   lastUpdateCheck?: string;
 
   /** The last checked latest version from NPM. */
   latestVersion?: string;
+  latestDownloadUrl?: string | null;
+  latestReleaseNotes?: string;
 
   /** Local LLM settings for delegating simple tasks. */
   localLlm?: LocalLlmConfig;
@@ -148,6 +157,9 @@ export interface Feature {
 
   /** Whether the Local LLM Co-processor is active for this workspace. */
   localLlmEnabled?: boolean;
+
+  /** Custom teamwork coordination instructions for the agent team. */
+  teamworkInstructions?: string;
 }
 
 /** Runtime context for an active workspace — now includes analysis data. */

package/src/utils/git.ts

@@ -59,3 +59,59 @@ export async function detectDefaultBranch(repoPath: string): Promise<string> {
     return 'main';
   }
 }
+
+/**
+ * Checks if the given branch name matches Git branch conventions (based on git-check-ref-format):
+ * - No spaces, backslashes, or control characters.
+ * - At least 1 character long.
+ * - Is not exactly '@'.
+ * - Does not start with a dash.
+ * - Does not start or end with a forward slash.
+ * - Does not contain consecutive dots, consecutive slashes, or '@{'.
+ * - Does not end with '.'.
+ * - Does not contain forbidden characters: ~, ^, :, ?, *, [
+ * - No component starts with a dot, ends with '.lock', or is exactly 'HEAD'.
+ *
+ * @param name - The branch name to validate.
+ * @returns `true` if the branch name is valid.
+ */
+export function isValidBranchName(name: string): boolean {
+  if (!name || name.length === 0) {
+    return false;
+  }
+  if (name === '@') {
+    return false;
+  }
+  if (name.startsWith('-')) {
+    return false;
+  }
+  const forbiddenCharsOrSpaces = /[\x00-\x20\x7F~^:?*[\\]/;
+  if (forbiddenCharsOrSpaces.test(name)) {
+    return false;
+  }
+  if (name.includes('..') || name.includes('@{') || name.includes('//')) {
+    return false;
+  }
+  if (name.startsWith('/') || name.endsWith('/')) {
+    return false;
+  }
+  if (name.endsWith('.')) {
+    return false;
+  }
+  
+  const components = name.split('/');
+  for (const component of components) {
+    if (component.startsWith('.')) {
+      return false;
+    }
+    if (component.endsWith('.lock')) {
+      return false;
+    }
+    if (component === 'HEAD') {
+      return false;
+    }
+  }
+
+  return true;
+}
+

package/src/utils/local-ai.ts

@@ -53,11 +53,16 @@ export async function callLocalLlm(
       // OpenAI-compatible provider
       const url = getOpenAiCompatibleUrl(cleanEndpoint, '/v1/chat/completions');
 
+      const headers: Record<string, string> = {
+        'Content-Type': 'application/json',
+      };
+      if (config.apiKey) {
+        headers['Authorization'] = `Bearer ${config.apiKey}`;
+      }
+
       const response = await fetch(url, {
         method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-        },
+        headers,
         body: JSON.stringify({
           model,
           messages,

package/src/utils/multi-git.ts

@@ -11,6 +11,7 @@ import * as path from 'node:path';
 import { execa } from 'execa';
 
 import type { Feature } from '../types.js';
+import { detectDefaultBranch } from './git.js';
 
 // ─── Types ────────────────────────────────────────────────────────────────────
 
@@ -22,6 +23,8 @@ export interface WorkspaceRepo {
   path: string;
   /** Feature branch name shared across the workspace. */
   branchName: string;
+  /** Default branch of the repo (e.g. 'main' or 'master'). */
+  defaultBranch: string;
 }
 
 /** Result of inspecting the working-tree status of a repo. */
@@ -109,15 +112,19 @@ export async function getWorkspaceRepos(
   const raw = await fs.readFile(manifestPath, 'utf-8');
   const feature = JSON.parse(raw) as Feature;
 
-  return feature.repos.map((repoPath) => {
-    const name = path.basename(repoPath);
-    const absolutePath = path.resolve(workspacePath, name);
-    return {
-      name,
-      path: absolutePath,
-      branchName: feature.branchName,
-    };
-  });
+  return Promise.all(
+    feature.repos.map(async (repoPath) => {
+      const name = path.basename(repoPath);
+      const absolutePath = path.resolve(workspacePath, name);
+      const defaultBranch = await detectDefaultBranch(absolutePath);
+      return {
+        name,
+        path: absolutePath,
+        branchName: feature.branchName,
+        defaultBranch,
+      };
+    })
+  );
 }
 
 /**

package/src/utils/update-check.ts

@@ -14,6 +14,21 @@ export interface UpdateStatus {
   currentVersion: string;
   latestVersion: string;
   updateAvailable: boolean;
+  downloadUrl?: string | null;
+  releaseNotes?: string;
+}
+
+interface GitHubAsset {
+  name: string;
+  browser_download_url: string;
+  size: number;
+}
+
+interface GitHubRelease {
+  tag_name: string;
+  html_url: string;
+  body: string;
+  assets: GitHubAsset[];
 }
 
 /**
@@ -43,7 +58,7 @@ export function getCurrentVersion(): string {
 }
 
 /**
- * Checks for updates from the NPM registry.
+ * Checks for updates from the GitHub Releases API (antan87/NexusFlow).
  * Employs a 24-hour cache unless forced.
  *
  * @param force - If true, ignores the 24-hour cache and fetches immediately.
@@ -63,31 +78,48 @@ export async function checkForUpdates(force = false): Promise<UpdateStatus | nul
       currentVersion,
       latestVersion: config.latestVersion,
       updateAvailable: isNewerVersion(currentVersion, config.latestVersion),
+      downloadUrl: config.latestDownloadUrl,
+      releaseNotes: config.latestReleaseNotes,
     };
   }
 
   try {
-    // Query NPM registry latest endpoint
-    const response = await fetch('https://registry.npmjs.org/@mrpatronz/nexusflow/latest', {
-      signal: AbortSignal.timeout(3000), // 3-second timeout to prevent blocking CLI/server
+    const response = await fetch('https://api.github.com/repos/antan87/NexusFlow/releases/latest', {
+      headers: { 'User-Agent': 'NexusFlow-Updater' },
+      signal: AbortSignal.timeout(4000),
     });
 
     if (!response.ok) {
-      throw new Error(`NPM registry returned status ${response.status}`);
+      throw new Error(`GitHub API returned status ${response.status}`);
+    }
+
+    const data = await response.json() as GitHubRelease;
+    const latestVersion = data.tag_name.replace(/^v/, '');
+    
+    // Resolve platform-matching asset (e.g. Setup.exe for Windows)
+    let downloadUrl: string | null = null;
+    const targetAsset = data.assets.find(asset => {
+      return asset.name.endsWith('.exe') && asset.name.toLowerCase().includes('setup');
+    });
+    if (targetAsset) {
+      downloadUrl = targetAsset.browser_download_url;
     }
 
-    const data = await response.json() as { version: string };
-    const latestVersion = data.version;
+    const releaseNotes = data.body || '';
 
     // Cache results
     config.lastUpdateCheck = new Date().toISOString();
     config.latestVersion = latestVersion;
+    config.latestDownloadUrl = downloadUrl;
+    config.latestReleaseNotes = releaseNotes;
     await saveConfig(config);
 
     return {
       currentVersion,
       latestVersion,
       updateAvailable: isNewerVersion(currentVersion, latestVersion),
+      downloadUrl,
+      releaseNotes,
     };
   } catch {
     // Fallback: If offline or check fails, return cached version status if available
@@ -96,6 +128,8 @@ export async function checkForUpdates(force = false): Promise<UpdateStatus | nul
         currentVersion,
         latestVersion: config.latestVersion,
         updateAvailable: isNewerVersion(currentVersion, config.latestVersion),
+        downloadUrl: config.latestDownloadUrl,
+        releaseNotes: config.latestReleaseNotes,
       };
     }
     return null;
@@ -170,30 +204,7 @@ export async function getToolsStatus(force = false): Promise<ToolUpdateStatus[]>
       updateCmd: 'npm install -g @mrpatronz/nexusflow',
       getCurrent: async () => currentVersion,
     },
-    {
-      id: 'repomix',
-      name: 'Repomix (Codebase Packer)',
-      command: 'repomix',
-      npmPackage: 'repomix',
-      updateCmd: 'npm install -g repomix',
-      getCurrent: async () => {
-        try {
-          const res = await execa('repomix', ['--version'], {
-            reject: false,
-            shell: process.platform === 'win32',
-          });
-          if (res.exitCode === 0) return res.stdout.trim();
-        } catch {}
-        try {
-          const res = await execa('npx', ['repomix', '--version'], {
-            reject: false,
-            shell: process.platform === 'win32',
-          });
-          if (res.exitCode === 0) return res.stdout.trim();
-        } catch {}
-        return '';
-      }
-    },
+
     {
       id: 'antigravity',
       name: 'Antigravity CLI',