@mrpatronz/nexusflow 0.2.7 → 0.2.11

package/gui/src/index.css

@@ -1 +1,17 @@
 @import "tailwindcss";
+
+@utility animate-slide-in {
+  animation: slide-in 0.2s cubic-bezier(0.16, 1, 0.3, 1) forwards;
+}
+
+@keyframes slide-in {
+  from {
+    transform: translateY(1rem);
+    opacity: 0;
+  }
+  to {
+    transform: translateY(0);
+    opacity: 1;
+  }
+}
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrpatronz/nexusflow",
-  "version": "0.2.7",
+  "version": "0.2.11",
   "description": "Combine multiple repos into a workspace with rich AI assistant context",
   "type": "module",
   "main": "dist/index.js",
@@ -11,8 +11,10 @@
     "build": "tsc && npm run build --prefix gui && npm run extension:compile",
     "dev": "tsc --watch",
     "start": "node dist/index.js",
+    "ui": "node dist/index.js ui",
     "test": "vitest run --passWithNoTests",
     "test:watch": "vitest",
+    "test:gui": "npm run test:e2e --prefix gui",
     "clean": "rimraf dist",
     "prepublishOnly": "npm run build",
     "extension:install": "npm install --prefix extension",

package/scripts/simulate-workspaces.ts

@@ -0,0 +1,55 @@
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { loadConfig } from '../src/core/config.js';
+import { createWorkspace } from '../src/core/workspace.js';
+import { analyzeAllRepos } from '../src/analyzers/index.js';
+import { generateContextFiles } from '../src/generators/index.js';
+
+async function main() {
+  const config = await loadConfig();
+  const repoPath = 'C:\\Users\\patro\\dev\\easyagent_container';
+  
+  console.log('Creating Workspace 1: feat/rate-limiting-standard (Local LLM DISABLED)');
+  const ws1Path = path.join(config.workspacesDir, 'feat/rate-limiting-standard');
+  const feature1 = {
+    id: 'feat/rate-limiting-standard',
+    branchName: 'feat/rate-limiting-standard',
+    description: 'Implement rate limiting and connection pooling',
+    repos: [repoPath],
+    assistants: ['claude'],
+    workspacePath: ws1Path,
+    createdAt: new Date().toISOString(),
+    localLlmEnabled: false,
+  };
+  const repos1 = [{ name: 'easyagent_container', path: path.join(ws1Path, 'easyagent_container'), isGitRepo: true, defaultBranch: 'master' }];
+  
+  await createWorkspace(feature1, [{ name: 'easyagent_container', path: repoPath, isGitRepo: true, defaultBranch: 'master' }]);
+  const analysis1 = await analyzeAllRepos(repos1);
+  const ctx1 = { feature: feature1, repos: repos1, analysis: analysis1 };
+  await generateContextFiles(ctx1, ['claude'], ws1Path);
+  console.log('✅ Workspace 1 created at:', ws1Path);
+
+  console.log('\nCreating Workspace 2: feat/rate-limiting-local-llm (Local LLM ENABLED)');
+  const ws2Path = path.join(config.workspacesDir, 'feat/rate-limiting-local-llm');
+  const feature2 = {
+    id: 'feat/rate-limiting-local-llm',
+    branchName: 'feat/rate-limiting-local-llm',
+    description: 'Implement rate limiting and connection pooling',
+    repos: [repoPath],
+    assistants: ['claude'],
+    workspacePath: ws2Path,
+    createdAt: new Date().toISOString(),
+    localLlmEnabled: true,
+  };
+  const repos2 = [{ name: 'easyagent_container', path: path.join(ws2Path, 'easyagent_container'), isGitRepo: true, defaultBranch: 'master' }];
+  
+  await createWorkspace(feature2, [{ name: 'easyagent_container', path: repoPath, isGitRepo: true, defaultBranch: 'master' }]);
+  const analysis2 = await analyzeAllRepos(repos2);
+  const ctx2 = { feature: feature2, repos: repos2, analysis: analysis2, localLlm: config.localLlm };
+  await generateContextFiles(ctx2, ['claude'], ws2Path);
+  console.log('✅ Workspace 2 created at:', ws2Path);
+  
+  console.log('\nBoth test workspaces are ready!');
+}
+
+main().catch(console.error);

package/src/commands/create.ts

@@ -82,6 +82,10 @@ export async function createCommand(): Promise<void> {
   const detectedAI = await detectAIAssistants();
   const selectedAI = await promptSelectAI(detectedAI);
 
+  const localLlmEnabled = config.localLlm?.enabled
+    ? await confirm({ message: 'Enable Local AI Co-processor in this workspace context?', default: true })
+    : false;
+
   // ── 6. Create workspace ─────────────────────────────────────────────
   const workspacePath = path.join(config.workspacesDir, branchName);
   const feature: Feature = {
@@ -93,6 +97,7 @@ export async function createCommand(): Promise<void> {
     assistants: selectedAI,
     workspacePath,
     createdAt: new Date().toISOString(),
+    localLlmEnabled,
   };
 
   const wsSpinner = ora('Creating workspace with git worktrees...').start();
@@ -115,7 +120,7 @@ export async function createCommand(): Promise<void> {
   const analysis = await analyzeAllRepos(workspaceRepos);
 
   // ── 8. Generate AI context files ────────────────────────────────────
-  const ctx: WorkspaceContext = { feature, repos: workspaceRepos, analysis };
+  const ctx: WorkspaceContext = { feature, repos: workspaceRepos, analysis, localLlm: config.localLlm };
   console.log(chalk.cyan('\nGenerating AI context files...'));
   await generateContextFiles(ctx, selectedAI, workspacePath);
 
@@ -160,6 +165,7 @@ export async function createCommand(): Promise<void> {
   console.log(`  ${chalk.dim('Branch:')} ${branchName}`);
   console.log(`  ${chalk.dim('Repos:')}  ${selectedRepos.map((r) => r.name).join(', ')}`);
   console.log(`  ${chalk.dim('AI:')}     ${selectedAI.join(', ')}`);
+  console.log(`  ${chalk.dim('Local AI:')} ${localLlmEnabled ? 'Enabled' : 'Disabled'}`);
   console.log(
     `\n  ${chalk.dim('To navigate:')} cd "${workspacePath}"`,
   );

package/src/commands/doctor.ts

@@ -9,6 +9,7 @@ import { listWorkspaces, loadFeatureConfig } from '../core/workspace.js';
 import { getRepoStatus } from '../utils/multi-git.js';
 import { analyzeAllRepos } from '../analyzers/index.js';
 import { globby } from 'globby';
+import { isOllamaModelAvailable, getOpenAiCompatibleUrl } from '../utils/local-ai.js';
 
 /**
  * Runs the doctor command to diagnose workspace state.
@@ -227,6 +228,61 @@ export async function doctorCommand(workspaceArg?: string): Promise<void> {
   }
   console.log();
 
+  // ── 7. Local AI Agent Connection Check ─────────────────────────────────
+  console.log(chalk.bold('🤖 Local AI Agent:'));
+  const config = await loadConfig();
+  if (config.localLlm?.enabled) {
+    const { provider, endpoint, model } = config.localLlm;
+    console.log(`  Provider: ${provider}`);
+    console.log(`  Endpoint: ${endpoint}`);
+    console.log(`  Model: ${model}`);
+
+    try {
+      const cleanEndpoint = endpoint.replace(/\/$/, '');
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 5000);
+
+      try {
+        if (provider === 'ollama') {
+          const res = await fetch(`${cleanEndpoint}/api/tags`, { signal: controller.signal });
+          if (!res.ok) {
+            throw new Error(`Ollama responded with status ${res.status}`);
+          }
+          const data: any = await res.json();
+          const models = data?.models || [];
+          const isModelLoaded = isOllamaModelAvailable(models, model);
+
+          if (isModelLoaded) {
+            console.log(`  ${chalk.green('✔')} Ollama service is active and model "${model}" is ready`);
+          } else {
+            const availableList = models.map((m: any) => m.name).join(', ') || 'none';
+            warnings.push(`Local model "${model}" is not pulled in Ollama. Available: [${availableList}]. Run "ollama pull ${model}" to install it.`);
+            console.log(`  ${chalk.yellow('⚠')} Ollama service is active, but model "${model}" is not pulled`);
+          }
+        } else {
+          // OpenAI-compatible endpoint ping
+          const testUrl = getOpenAiCompatibleUrl(cleanEndpoint, '/v1/models');
+          const res = await fetch(testUrl, { signal: controller.signal });
+          if (!res.ok) {
+            throw new Error(`OpenAI-compatible server responded with status ${res.status}`);
+          }
+          console.log(`  ${chalk.green('✔')} OpenAI-compatible server at "${endpoint}" is active`);
+        }
+      } catch (e: any) {
+        const errorMsg = e.name === 'AbortError' ? 'Request timed out after 5 seconds' : e.message;
+        throw new Error(errorMsg);
+      } finally {
+        clearTimeout(timeout);
+      }
+    } catch (e: any) {
+      warnings.push(`Local LLM server at "${endpoint}" is offline or unreachable: ${e.message}`);
+      console.log(`  ${chalk.yellow('⚠')} Local LLM server is offline or unreachable (${e.message})`);
+    }
+  } else {
+    console.log(`  ${chalk.dim('Local AI agent is disabled in config.')}`);
+  }
+  console.log();
+
   // ── Summary Report ────────────────────────────────────────────────────
   console.log(chalk.bold('📊 Diagnostic Summary:'));
   if (errors.length === 0 && warnings.length === 0) {

package/src/commands/init.ts

@@ -4,11 +4,12 @@
  */
 
 import chalk from 'chalk';
-import { input } from '@inquirer/prompts';
+import { input, confirm, select } from '@inquirer/prompts';
 import path from 'node:path';
 import os from 'node:os';
 
 import { loadConfig, saveConfig, ensureConfigDir } from '../core/config.js';
+import { scanSystemSpecs } from '../utils/system-scanner.js';
 
 /**
  * Initializes NexusFlow configuration interactively.
@@ -20,6 +21,7 @@ export async function initCommand(): Promise<void> {
   await ensureConfigDir();
   const existing = await loadConfig();
 
+  // ── 1. Basic Directories ──────────────────────────────────────────────
   const devDir = await input({
     message: 'Development directory (where your repos live):',
     default: existing.devDir || path.join(os.homedir(), 'dev'),
@@ -40,11 +42,84 @@ export async function initCommand(): Promise<void> {
     },
   });
 
+  // ── 2. Local AI Scanner & Config ──────────────────────────────────────
+  console.log(chalk.cyan('\nProbing system hardware for local AI capabilities...'));
+  let specs;
+  try {
+    specs = await scanSystemSpecs();
+  } catch (error) {
+    specs = {
+      totalRamGb: 8,
+      gpuName: 'Unknown/Integrated',
+      hasHardwareAcceleration: false,
+      recommendedModel: 'qwen2.5-coder:1.5b',
+    };
+  }
+  console.log(chalk.dim(`  RAM Detected: ${specs.totalRamGb} GB`));
+  console.log(chalk.dim(`  GPU Detected: ${specs.gpuName}`));
+  console.log(chalk.dim(`  Recommended model: ${chalk.bold(specs.recommendedModel)}`));
+
+  const enableLlm = await confirm({
+    message: 'Enable Local AI Co-processor (Ollama/LM Studio)?',
+    default: existing.localLlm?.enabled ?? false,
+  });
+
+  let localLlmConfig = existing.localLlm || {
+    enabled: false,
+    provider: 'ollama',
+    endpoint: 'http://localhost:11434',
+    model: specs.recommendedModel,
+  };
+
+  if (enableLlm) {
+    const provider = await select({
+      message: 'Local AI Provider:',
+      choices: [
+        { name: 'Ollama', value: 'ollama' as const },
+        { name: 'OpenAI-Compatible (e.g. LM Studio, Llama.cpp)', value: 'openai-compatible' as const },
+      ],
+      default: existing.localLlm?.provider || 'ollama',
+    });
+
+    const defaultEndpoint = provider === 'ollama' ? 'http://localhost:11434' : 'http://localhost:1234';
+    const endpoint = await input({
+      message: 'Local AI Endpoint URL:',
+      default: existing.localLlm?.endpoint || defaultEndpoint,
+      validate: (value: string) => {
+        const trimmed = value.trim();
+        if (!trimmed.startsWith('http://') && !trimmed.startsWith('https://')) {
+          return 'Endpoint must start with http:// or https://';
+        }
+        try {
+          new URL(trimmed);
+          return true;
+        } catch {
+          return 'Please enter a valid URL';
+        }
+      },
+    });
+
+    const model = await input({
+      message: `Local LLM Model Name (Recommended: ${specs.recommendedModel}):`,
+      default: existing.localLlm?.model || specs.recommendedModel,
+    });
+
+    localLlmConfig = {
+      enabled: true,
+      provider,
+      endpoint: endpoint.trim(),
+      model: model.trim(),
+    };
+  } else {
+    localLlmConfig.enabled = false;
+  }
+
   const config = {
     ...existing,
     devDir: devDir.trim(),
     workspacesDir: workspacesDir.trim(),
     scanDepth: parseInt(scanDepth, 10),
+    localLlm: localLlmConfig,
   };
 
   await saveConfig(config);
@@ -54,5 +129,6 @@ export async function initCommand(): Promise<void> {
   console.log(chalk.dim(`  Dev dir:     ${config.devDir}`));
   console.log(chalk.dim(`  Workspaces:  ${config.workspacesDir}`));
   console.log(chalk.dim(`  Scan depth:  ${config.scanDepth}`));
+  console.log(chalk.dim(`  Local AI:    ${config.localLlm.enabled ? `Enabled (${config.localLlm.provider}, model: ${config.localLlm.model})` : 'Disabled'}`));
   console.log(chalk.dim('\n  Run "nexusflow create" to create your first workspace.\n'));
 }

package/src/core/config.test.ts

@@ -0,0 +1,96 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import { getConfigDir, getDefaultConfig, ensureConfigDir, loadConfig, saveConfig } from './config.js';
+
+vi.mock('node:fs/promises');
+vi.mock('node:os', async () => {
+  const actual = await vi.importActual<typeof import('node:os')>('node:os');
+  return {
+    ...actual,
+    homedir: vi.fn(),
+  };
+});
+
+describe('config core module', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(os.homedir).mockReturnValue('/mock/home');
+  });
+
+  describe('getConfigDir', () => {
+    it('should return path based on home directory', () => {
+      const dir = getConfigDir();
+      expect(dir).toContain('.nexusflow');
+    });
+  });
+
+  describe('getDefaultConfig', () => {
+    it('should return config with defaults populated', () => {
+      const config = getDefaultConfig();
+      expect(config.version).toBe('1.0.0');
+      expect(config.scanDepth).toBe(2);
+      expect(config.localLlm?.enabled).toBe(false);
+    });
+  });
+
+  describe('ensureConfigDir', () => {
+    it('should invoke fs.mkdir with correct options', async () => {
+      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+
+      await ensureConfigDir();
+
+      expect(fs.mkdir).toHaveBeenCalledWith(expect.stringContaining('.nexusflow'), { recursive: true });
+    });
+  });
+
+  describe('loadConfig', () => {
+    it('should load config if file exists', async () => {
+      const savedConfig = {
+        devDir: '/custom/dev',
+        localLlm: {
+          enabled: true,
+          model: 'custom-model'
+        }
+      };
+
+      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(savedConfig));
+
+      const config = await loadConfig();
+
+      expect(config.devDir).toBe('/custom/dev');
+      expect(config.localLlm?.enabled).toBe(true);
+      expect(config.localLlm?.model).toBe('custom-model');
+      // Should merge with defaults
+      expect(config.scanDepth).toBe(2);
+    });
+
+    it('should return default config if read fails', async () => {
+      vi.mocked(fs.readFile).mockRejectedValue(new Error('ENOENT'));
+
+      const config = await loadConfig();
+
+      expect(config.version).toBe('1.0.0');
+      expect(config.localLlm?.enabled).toBe(false);
+    });
+  });
+
+  describe('saveConfig', () => {
+    it('should create directory and save configuration', async () => {
+      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+      vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+
+      const config = getDefaultConfig();
+      config.devDir = '/custom/saved/dev';
+
+      await saveConfig(config);
+
+      expect(fs.mkdir).toHaveBeenCalled();
+      expect(fs.writeFile).toHaveBeenCalledWith(
+        expect.stringContaining('config.json'),
+        expect.stringContaining('/custom/saved/dev'),
+        'utf-8'
+      );
+    });
+  });
+});

package/src/core/config.ts

@@ -58,6 +58,12 @@ export function getDefaultConfig(): NexusFlowConfig {
       '**/.vscode/**',
       '**/.idea/**',
     ],
+    localLlm: {
+      enabled: false,
+      provider: 'ollama',
+      endpoint: 'http://localhost:11434',
+      model: 'qwen2.5-coder:1.5b',
+    },
   };
 }
 
@@ -83,7 +89,11 @@ export async function loadConfig(): Promise<NexusFlowConfig> {
     const parsed = JSON.parse(raw) as Partial<NexusFlowConfig>;
 
     // Merge with defaults so newly-added keys are always present.
-    return { ...getDefaultConfig(), ...parsed };
+    const merged = { ...getDefaultConfig(), ...parsed };
+    if (parsed.localLlm) {
+      merged.localLlm = { ...getDefaultConfig().localLlm, ...parsed.localLlm };
+    }
+    return merged;
   } catch {
     // File doesn't exist or is unreadable — return defaults.
     return getDefaultConfig();

package/src/core/scanner.test.ts

@@ -0,0 +1,61 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { scanForRepos } from './scanner.js';
+import * as gitUtils from '../utils/git.js';
+
+vi.mock('node:fs/promises');
+vi.mock('../utils/git.js');
+
+describe('scanner core module', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should return repository info if the root dir is a git repo', async () => {
+    vi.mocked(gitUtils.isGitRepo).mockResolvedValue(true);
+    vi.mocked(gitUtils.detectDefaultBranch).mockResolvedValue('main');
+
+    const result = await scanForRepos('/mock/dev', 2);
+
+    expect(result).toEqual([
+      { name: 'dev', path: '/mock/dev', defaultBranch: 'main' }
+    ]);
+    expect(gitUtils.isGitRepo).toHaveBeenCalledWith('/mock/dev');
+  });
+
+  it('should recursively scan subdirectories up to limit and return repos found', async () => {
+    // Root is not a git repo
+    vi.mocked(gitUtils.isGitRepo).mockImplementation(async (dir) => {
+      const normalized = dir.replace(/\\/g, '/');
+      return normalized === '/mock/dev/repo1' || normalized === '/mock/dev/sub/repo2';
+    });
+    vi.mocked(gitUtils.detectDefaultBranch).mockResolvedValue('main');
+
+    // Root directory entries
+    vi.mocked(fs.readdir).mockImplementation(async (dir: any) => {
+      const normalized = dir.replace(/\\/g, '/');
+      if (normalized === '/mock/dev') {
+        return [
+          { name: 'repo1', isDirectory: () => true },
+          { name: 'sub', isDirectory: () => true },
+          { name: 'ignored_file.txt', isDirectory: () => false },
+          { name: 'node_modules', isDirectory: () => true },
+        ] as any[];
+      }
+      if (normalized === '/mock/dev/sub') {
+        return [
+          { name: 'repo2', isDirectory: () => true },
+        ] as any[];
+      }
+      return [];
+    });
+
+    const result = await scanForRepos('/mock/dev', 2);
+
+    expect(result).toEqual([
+      { name: 'repo1', path: path.join('/mock/dev', 'repo1'), defaultBranch: 'main' },
+      { name: 'repo2', path: path.join('/mock/dev', 'sub', 'repo2'), defaultBranch: 'main' }
+    ]);
+  });
+});

package/src/generators/base.ts

@@ -6,6 +6,7 @@
 
 import * as path from 'node:path';
 import * as fs from 'node:fs';
+import * as os from 'node:os';
 import type { WorkspaceContext, ProjectAnalysis } from '../types.js';
 
 /**
@@ -72,6 +73,7 @@ function formatProjectSection(analysis: ProjectAnalysis, workspacePath: string):
 export function buildContextContent(ctx: WorkspaceContext): string {
   const { feature, repos, analysis } = ctx;
   const workspacePath = feature.workspacePath;
+  const localLlmEnabled = feature.localLlmEnabled ?? false;
 
   // Build project sections — rich if analysis is available, simple if not
   let projectSections: string;
@@ -191,7 +193,7 @@ ${taskSection}
 
 ## Guidelines
 
-- **Multi-Repo Workspace Structure**: This workspace is a multi-repository developer environment where each project subdirectory (e.g. \`my-api\`, \`my-frontend\`) is a separate Git worktree checked out on the feature branch \`\${feature.branchName}\`.
+- **Multi-Repo Workspace Structure**: This workspace is a multi-repository developer environment where each project subdirectory (e.g. \`my-api\`, \`my-frontend\`) is a separate Git worktree checked out on the feature branch \`${feature.branchName}\`.
   - **All code changes** must be made within the appropriate project subdirectories.
   - **Worktree Isolation**: Under no circumstances should you edit files, read code, or run commands in the original/main repository directories outside of this workspace folder. All development must be strictly contained within the checked-out worktree subdirectories of this workspace.
   - **Git commands** (like \`git status\`, \`git add\`, \`git commit\`, \`git push\`) must be run inside the specific project subdirectories (e.g. \`cd my-api && git commit -m "..."\`), NOT in the workspace root.
@@ -204,7 +206,16 @@ ${taskSection}
     - \`nexusflow doctor\` — run diagnostics to verify workspace health.
 - **Workspace Knowledge**: Read \`nexusflow-knowledge.md\` at the start of every session. It serves as the persistent memory for this feature. Before ending your session, append significant architecture decisions, discovered gotchas, and checklist progress to \`nexusflow-knowledge.md\`. Never delete or overwrite existing knowledge/decisions — only append.
 - **Implementation Plan**: Refer to \`nexusflow-plan.md\` for the suggested implementation order based on dependency analysis. Follow the phased implementation order to avoid blocking yourself on cross-repo dependencies.
-- Read each project's existing \`README.md\` and any doc files before proposing changes.
+${localLlmEnabled ? `- **Local AI Agent Delegation (Token Optimizer)**: You have access to a local Small Language Model (SLM) on the developer's machine via the MCP tool \`delegate_to_local_agent\`.${
+  ctx.localLlm ? `\n  - **Model Capacity**: The local agent is running \`${ctx.localLlm.model}\`. ${
+    ctx.localLlm.model.match(/70b|72b|32b|14b/i)
+      ? 'This is a highly capable model; you can delegate complex reasoning and larger code generation tasks.'
+      : 'This is a smaller model; it is best suited for targeted search, log parsing, summarization, and simple boilerplate.'
+  }` : ''
+}
+  - **Usage rule**: Whenever you need to perform high-token tasks (like searching large chunks of code, analyzing raw service logs to debug, or generating repetitive boilerplate), **always use \`delegate_to_local_agent\`** first.
+  - The local model is free and fast. Pass the instruction and any logs/source files in \`filesToRead\` (relative paths). Use the distilled summary returned to formulate your final output, saving up to 90% in remote context tokens.
+` : ''}- Read each project's existing \`README.md\` and any doc files before proposing changes.
 - When modifying a shared library, check every downstream consumer for breakage.
 - Prefer small, focused commits that touch one repo at a time when possible.
 - If a change must span repos, describe the ordering and any migration steps.

package/src/generators/skills-generator.ts

@@ -4,7 +4,7 @@
  * dynamically based on workspace analysis.
  */
 
-import * as fse from 'fs-extra';
+import fse from 'fs-extra';
 import * as path from 'node:path';
 import type { AIAssistant, WorkspaceContext, ProjectAnalysis } from '../types.js';