@mrpatronz/nexusflow 0.2.13 → 0.2.18

package/README.md

@@ -20,6 +20,7 @@ NexusFlow combines multiple Git repositories into a single feature workspace and
 - **AI context generation** — automatically writes `CLAUDE.md`, `AGENTS.md`, `.github/copilot-instructions.md`, and `.cursor/rules/nexusflow.mdc`
 - **Codebase context packing** — compress an entire multi-repo workspace into a single token-efficient XML file for web-based LLMs using Repomix
 - **Smart codebase analysis** — detects tech stacks, ports, API endpoints, dependencies, and existing AI configs across all projects
+- **Teamwork Strategy Workflows** — predefine coordination flows and subagent behaviors (e.g. plan-implement-review) and inspect them with local AI coding assistant harnesses
 - **Session history & resumption** — browse past conversation transcripts from Antigravity, Claude Code, OpenAI Codex, and GitHub Copilot, then resume where you left off
 - **Service orchestration** — start, stop, and tail logs for all services in a workspace with a single command
 - **Interactive Web Dashboard** — rich dark-themed GUI for managing workspaces, viewing sessions, and streaming logs
@@ -109,12 +110,18 @@ Open this folder in your editor → your AI assistant picks up the context → i
 | `nexusflow list` | List all existing workspaces (alias: `ls`) |
 | `nexusflow open` | Re-open a workspace in your editor |
 | `nexusflow init` | Configure NexusFlow settings |
+| `nexusflow adapter` | Manage storage adapters — list, switch, configure, or initialize custom plugins |
 | `nexusflow pack` | Pack the workspace codebase into a single token-efficient XML file |
 | `nexusflow start` | Start all services in a workspace (auto-detected) |
 | `nexusflow stop` | Stop all running services |
 | `nexusflow status` | Show running/stopped status and PIDs |
 | `nexusflow logs` | Tail aggregated logs from all services |
 | `nexusflow ui` | Launch the interactive Web Dashboard (port 3000) |
+| `nexusflow diff` | View changes across all sub-repositories in the active workspace |
+| `nexusflow commit` | Commit and push changes across all modified repositories |
+| `nexusflow sync` | Rebase all repositories in the workspace with default base branches |
+| `nexusflow refresh`| Regenerate codebase maps, plan, and AI context files without rebasing |
+| `nexusflow doctor` | Run health checks and diagnostics to verify workspace integrity |
 
 ## 🤖 Supported AI Assistants
 
@@ -151,6 +158,52 @@ GET /api/workspace/:id/sessions
 GET /api/session/:assistant/:sessionId/transcript
 ```
 
+## 🗄️ Pluggable Storage & Vault Adapters
+
+NexusFlow supports multiple storage backends to control where workspace context maps, plans, and persistent AI knowledge files are stored. This allows keeping your Git repository workspaces completely clean from AI file clutter.
+
+Available storage providers:
+- **Local (`local`)** — Stores files directly in the workspace directory (default).
+- **Central Vault (`central-vault`)** — Stores files in a centralized folder on your machine at `~/.nexusflow/vault/`.
+- **Obsidian Vault (`obsidian`)** — Stores files in a designated folder inside your Obsidian Vault, wrapped in a `nexusflow/` subdirectory (e.g. `vault/nexusflow/workspaces/<featureId>`). Auto-wraps files with YAML frontmatter metadata and tags for easy Obsidian indexing.
+
+### CLI Adapter Management
+
+Configure storage adapters from the command line:
+
+```bash
+# List all registered storage adapters and the active provider
+nexusflow adapter list
+
+# View configurations and fields for a specific adapter
+nexusflow adapter info obsidian
+
+# Switch to a different adapter (e.g. obsidian) and configure its settings
+nexusflow adapter use obsidian
+
+# Scaffolds a template for creating a new custom storage adapter plugin
+nexusflow adapter init my-custom-plugin
+```
+
+## 👥 Teamwork Strategy Workflows
+
+NexusFlow allows you to predefine orchestration workflows and cooperation rules that govern how multiple AI subagents coordinate when solving complex, multi-repo software engineering tasks.
+
+You can select a strategy workflow when creating a workspace (or define custom ones). Built-in templates include:
+- **Plan-Implement-Review** — A structured, multi-agent flow where an Orchestrator coordinates planning, implementation, review, and documentation.
+- **Research-Verify** — A fast iteration strategy centered on research, drafting code, and immediately running verification test suites.
+- **Solo Developer** — A simplified, lightweight direct-action workflow for minor tweaks and linear tasks.
+
+### Custom Strategies & AI Inspection
+
+You can create, edit, or delete custom strategies directly via the Web Dashboard's **Team Strategies** tab. Strategies are written in clean Markdown guidelines and stored in:
+`~/.nexusflow/workflows/`
+
+The dashboard integrates an **AI Strategy Analysis** inspector:
+1. Select an AI assistant harness installed on your machine (e.g. *Claude Code*, *Antigravity*).
+2. (Optional) Provide a comment or specific evaluation focus (e.g. *"Ensure subagent roles are distinct"*).
+3. Click **Inspect Strategy** to have the AI analyze the strategy rules, identify ambiguities/contradictions, rate its orchestration effectiveness, and generate an optimized rewritten guideline.
+
 ## 🌐 Web Dashboard
 
 Launch with `nexusflow ui` to get a full-featured dark-themed GUI:

package/desktop/build-installer.js

@@ -0,0 +1,228 @@
+import { execSync } from 'child_process';
+import fs from 'fs';
+import https from 'https';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Resolve parent project directory dynamically supporting both nested and sibling structures
+let parentDir = path.resolve(__dirname, '..');
+if (!fs.existsSync(path.join(parentDir, 'package.json')) || 
+    JSON.parse(fs.readFileSync(path.join(parentDir, 'package.json'), 'utf8')).name !== '@mrpatronz/nexusflow') {
+  parentDir = path.resolve(__dirname, '../NexusFlow');
+}
+
+const distInstallerDir = path.resolve(__dirname, 'dist-installer');
+const nodeStagingDir = path.resolve(distInstallerDir, 'node');
+const serverStagingDir = path.resolve(distInstallerDir, 'server');
+const outputDir = path.resolve(__dirname, 'dist-installer-output');
+
+const nodeExeUrl = 'https://nodejs.org/dist/v20.15.0/win-x64/node.exe';
+const nodeExePath = path.resolve(nodeStagingDir, 'node.exe');
+
+function copyDir(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+function downloadFile(url, destPath) {
+  return new Promise((resolve, reject) => {
+    console.log(`Downloading ${url} to ${destPath}...`);
+    const file = fs.createWriteStream(destPath);
+    https.get(url, (response) => {
+      if (response.statusCode !== 200) {
+        reject(new Error(`Failed to download: Status ${response.statusCode}`));
+        return;
+      }
+      response.pipe(file);
+      file.on('finish', () => {
+        file.close();
+        console.log('Download complete.');
+        resolve();
+      });
+    }).on('error', (err) => {
+      fs.unlink(destPath, () => {});
+      reject(err);
+    });
+  });
+}
+
+function sleepSync(ms) {
+  const start = Date.now();
+  while (Date.now() - start < ms) {}
+}
+
+function retryRmSync(dir, maxRetries = 5, delay = 150) {
+  for (let i = 0; i < maxRetries; i++) {
+    try {
+      if (fs.existsSync(dir)) {
+        fs.rmSync(dir, { recursive: true, force: true });
+      }
+      return;
+    } catch (err) {
+      if (i === maxRetries - 1) throw err;
+      console.log(`Directory ${path.basename(dir)} locked by OS, retrying deletion (${i + 1}/${maxRetries}) in ${delay}ms...`);
+      sleepSync(delay);
+    }
+  }
+}
+
+function pruneNodeModules(dir) {
+  if (!fs.existsSync(dir)) return;
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      const nameLower = entry.name.toLowerCase();
+      if (
+        nameLower === 'test' ||
+        nameLower === 'tests' ||
+        nameLower === 'examples' ||
+        nameLower === 'docs' ||
+        nameLower === '.github'
+      ) {
+        fs.rmSync(fullPath, { recursive: true, force: true });
+      } else {
+        pruneNodeModules(fullPath);
+      }
+    } else {
+      const ext = path.extname(entry.name).toLowerCase();
+      if (ext === '.map' || ext === '.ts' || ext === '.md') {
+        fs.unlinkSync(fullPath);
+      }
+    }
+  }
+}
+
+async function build() {
+  try {
+    console.log('--- Starting NexusFlow Installer Build ---');
+
+    // 1. Re-create clean staging directories with OS lock retry handling
+    console.log('Cleaning and creating staging directories...');
+    retryRmSync(distInstallerDir);
+    fs.mkdirSync(distInstallerDir, { recursive: true });
+    fs.mkdirSync(nodeStagingDir, { recursive: true });
+    fs.mkdirSync(serverStagingDir, { recursive: true });
+
+    try {
+      retryRmSync(outputDir);
+      fs.mkdirSync(outputDir, { recursive: true });
+    } catch (err) {
+      console.log('Output directory locked by shell, clearing files inside instead...');
+      if (fs.existsSync(outputDir)) {
+        const files = fs.readdirSync(outputDir);
+        for (const file of files) {
+          fs.rmSync(path.join(outputDir, file), { recursive: true, force: true });
+        }
+      } else {
+        fs.mkdirSync(outputDir, { recursive: true });
+      }
+    }
+
+    // 2. Copy Neutralino assets
+    console.log('Copying Neutralino assets...');
+    const winExeSrc = path.resolve(__dirname, 'dist/nexusflow-desktop/nexusflow-desktop-win_x64.exe');
+    const resourcesNeuSrc = path.resolve(__dirname, 'dist/nexusflow-desktop/resources.neu');
+
+    if (!fs.existsSync(winExeSrc) || !fs.existsSync(resourcesNeuSrc)) {
+      throw new Error('Neutralino build outputs not found. Please run "npm run build" first in the desktop folder.');
+    }
+
+    fs.copyFileSync(winExeSrc, path.resolve(distInstallerDir, 'nexusflow-desktop-win_x64.exe'));
+    fs.copyFileSync(resourcesNeuSrc, path.resolve(distInstallerDir, 'resources.neu'));
+
+    // 3. Copy Hono backend server files
+    console.log('Copying Hono server dist and package.json...');
+    const serverDistSrc = path.resolve(parentDir, 'dist');
+    const serverPackageJsonSrc = path.resolve(parentDir, 'package.json');
+
+    if (!fs.existsSync(serverDistSrc) || !fs.existsSync(serverPackageJsonSrc)) {
+      throw new Error('NexusFlow server build outputs not found. Please run "npm run build" first in NexusFlow.');
+    }
+
+    copyDir(serverDistSrc, path.resolve(serverStagingDir, 'dist'));
+    fs.copyFileSync(serverPackageJsonSrc, path.resolve(serverStagingDir, 'package.json'));
+
+    // Copy templates/resources
+    const serverResourcesSrc = path.resolve(parentDir, 'resources');
+    if (fs.existsSync(serverResourcesSrc)) {
+      copyDir(serverResourcesSrc, path.resolve(serverStagingDir, 'resources'));
+    }
+
+    // 4. Install server dependencies and prune unused assets
+    console.log('Installing production dependencies for staging server...');
+    execSync('npm install --omit=dev', { cwd: serverStagingDir, stdio: 'inherit', shell: true });
+    
+    console.log('Pruning non-runtime files from node_modules (maps, tests, docs)...');
+    pruneNodeModules(path.resolve(serverStagingDir, 'node_modules'));
+
+    // 5. Download embedded Node.js executable
+    await downloadFile(nodeExeUrl, nodeExePath);
+
+    // 6. Locate and run Inno Setup compiler (ISCC.exe)
+    console.log('Locating Inno Setup compiler...');
+    const userIsccPath = path.join(
+      process.env.USERPROFILE || 'C:\\Users\\default',
+      'AppData\\Local\\Programs\\Inno Setup 6\\ISCC.exe'
+    );
+    const globalIsccPath = 'C:\\Program Files (x86)\\Inno Setup 6\\ISCC.exe';
+
+    let isccPath = '';
+    if (fs.existsSync(userIsccPath)) {
+      isccPath = userIsccPath;
+    } else if (fs.existsSync(globalIsccPath)) {
+      isccPath = globalIsccPath;
+    } else {
+      // Try resolving from PATH
+      try {
+        execSync('iscc /?', { stdio: 'ignore', shell: true });
+        isccPath = 'iscc';
+      } catch {
+        throw new Error('Inno Setup compiler (ISCC.exe) not found. Please verify it is installed.');
+      }
+    }
+
+    console.log(`Using Inno Setup compiler: ${isccPath}`);
+    const issScriptPath = path.resolve(__dirname, 'installer/nexusflow.iss');
+    console.log(`Compiling installer script: ${issScriptPath}...`);
+    execSync(`"${isccPath}" "${issScriptPath}"`, { stdio: 'inherit', shell: true });
+
+    // 7. Check if file got redirected to VirtualStore due to Windows virtualization and move it back
+    const expectedOutputExe = path.resolve(outputDir, 'NexusFlowSetup.exe');
+    if (!fs.existsSync(expectedOutputExe)) {
+      console.log('Checking for Windows VirtualStore redirection...');
+      const localAppData = process.env.LOCALAPPDATA || path.join(process.env.USERPROFILE || 'C:\\Users\\default', 'AppData\\Local');
+      // VirtualStore mirrors the absolute path starting from the drive root
+      const relativePathFromDrive = __dirname.replace(/^[a-zA-Z]:/, '');
+      const virtualStorePath = path.join(localAppData, 'VirtualStore', relativePathFromDrive, 'dist-installer-output', 'NexusFlowSetup.exe');
+      
+      if (fs.existsSync(virtualStorePath)) {
+        console.log(`Detected VirtualStore redirection! Moving installer from ${virtualStorePath} to ${expectedOutputExe}...`);
+        fs.copyFileSync(virtualStorePath, expectedOutputExe);
+        fs.unlinkSync(virtualStorePath);
+      } else {
+        throw new Error('Installer compiled successfully but the output file could not be found anywhere.');
+      }
+    }
+
+    console.log('--- Installer Build Completed Successfully ---');
+    console.log(`Installer location: ${expectedOutputExe}`);
+  } catch (error) {
+    console.error('Installer build failed:', error.message);
+    process.exit(1);
+  }
+}
+
+build();

package/desktop/build.js

@@ -0,0 +1,118 @@
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Resolve parent project directory dynamically supporting both nested and sibling structures
+let parentDir = path.resolve(__dirname, '..');
+if (!fs.existsSync(path.join(parentDir, 'package.json')) || 
+    JSON.parse(fs.readFileSync(path.join(parentDir, 'package.json'), 'utf8')).name !== '@mrpatronz/nexusflow') {
+  parentDir = path.resolve(__dirname, '../NexusFlow');
+}
+
+const guiAssetsDir = path.resolve(parentDir, 'dist/gui');
+const resourcesDir = path.resolve(__dirname, 'resources');
+
+function copyDir(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+try {
+  const binDir = path.resolve(__dirname, 'bin');
+  const neutralinoJsPath = path.resolve(resourcesDir, 'neutralino.js');
+
+  // Check if bin directory or resources/neutralino.js is missing
+  if (!fs.existsSync(binDir) || !fs.existsSync(neutralinoJsPath)) {
+    console.log('Detected missing Neutralino binaries or client library. Running npx neu update...');
+    try {
+      execSync('npx --no-install neu update', { cwd: __dirname, stdio: 'inherit', shell: true });
+    } catch (err) {
+      console.log('npx failed, trying direct node execution of local neu CLI binary for update...');
+      const localNeuBin = path.join(__dirname, 'node_modules/@neutralinojs/neu/bin/neu');
+      if (fs.existsSync(localNeuBin)) {
+        execSync(`node "${localNeuBin}" update`, { cwd: __dirname, stdio: 'inherit', shell: true });
+      } else {
+        throw new Error('Local neutralino CLI binary not found. Please run npm install first in the desktop directory.');
+      }
+    }
+  }
+
+  // 1. Compile the parent project
+  if (!process.env.CI) {
+    console.log('Compiling parent project (NexusFlow)...');
+    execSync('npm run build', { cwd: parentDir, stdio: 'inherit', shell: true });
+  } else {
+    console.log('Running in CI environment. Skipping parent project compilation.');
+  }
+
+  // Read existing neutralino.js before purging resources folder
+  let neutralinoJsContent = '';
+  if (fs.existsSync(neutralinoJsPath)) {
+    console.log('Reading existing neutralino.js into memory...');
+    neutralinoJsContent = fs.readFileSync(neutralinoJsPath, 'utf8');
+  }
+
+  // 2. Clear and copy GUI assets to desktop/resources
+  console.log('Copying web assets to desktop/resources...');
+  if (fs.existsSync(resourcesDir)) {
+    fs.rmSync(resourcesDir, { recursive: true, force: true });
+  }
+  fs.mkdirSync(resourcesDir, { recursive: true });
+  copyDir(guiAssetsDir, resourcesDir);
+
+  // Write neutralino.js back to resources directory
+  if (neutralinoJsContent) {
+    console.log('Writing neutralino.js back to resources folder...');
+    fs.writeFileSync(neutralinoJsPath, neutralinoJsContent, 'utf8');
+  }
+
+  // 3. Inject neutralino.js client script tag
+  console.log('Injecting neutralino.js client script tag into index.html...');
+  const indexHtmlPath = path.join(resourcesDir, 'index.html');
+  if (fs.existsSync(indexHtmlPath)) {
+    let htmlContent = fs.readFileSync(indexHtmlPath, 'utf8');
+    if (!htmlContent.includes('neutralino.js')) {
+      // Inject before </head>
+      htmlContent = htmlContent.replace('</head>', '<script src="/neutralino.js"></script>\n</head>');
+      fs.writeFileSync(indexHtmlPath, htmlContent, 'utf8');
+      console.log('Successfully injected neutralino.js.');
+    } else {
+      console.log('neutralino.js already injected.');
+    }
+  } else {
+    console.error('Error: index.html not found in resources directory!');
+    process.exit(1);
+  }
+
+  // 4. Execute neu build using the locally installed CLI binary
+  console.log('Executing neu build using locally installed CLI binary...');
+  try {
+    execSync('npx --no-install neu build', { cwd: __dirname, stdio: 'inherit', shell: true });
+  } catch (err) {
+    console.log('npx failed, trying direct node execution of local neu CLI binary...');
+    const localNeuBin = path.join(__dirname, 'node_modules/@neutralinojs/neu/bin/neu');
+    if (fs.existsSync(localNeuBin)) {
+      execSync(`node "${localNeuBin}" build`, { cwd: __dirname, stdio: 'inherit', shell: true });
+    } else {
+      throw new Error('Local neutralino CLI binary not found. Please run npm install first in the desktop directory.');
+    }
+  }
+
+  console.log('Build completed successfully.');
+} catch (error) {
+  console.error('Build failed:', error.message);
+  process.exit(1);
+}

package/desktop/installer/nexusflow.iss

@@ -0,0 +1,35 @@
+; NexusFlow Desktop Installer Script for Inno Setup
+; Creates a user-level (no-admin-needed) installer.
+
+[Setup]
+AppName=NexusFlow
+AppVersion=0.2.17
+AppPublisher=Antigravity team
+AppPublisherURL=https://github.com/mrpatronz/nexusflow
+DefaultDirName={localappdata}\Programs\NexusFlow
+DefaultGroupName=NexusFlow
+DisableProgramGroupPage=yes
+UninstallDisplayIcon={app}\nexusflow-desktop-win_x64.exe
+Compression=lzma2
+SolidCompression=yes
+OutputDir=..\dist-installer-output
+OutputBaseFilename=NexusFlowSetup
+PrivilegesRequired=lowest
+WizardStyle=modern
+
+[Languages]
+Name: "english"; MessagesFile: "compiler:Default.isl"
+
+[Tasks]
+Name: "desktopicon"; Description: "{cm:CreateDesktopIcon}"; GroupDescription: "{cm:AdditionalIcons}"; Flags: unchecked
+
+[Files]
+Source: "..\dist-installer\*"; DestDir: "{app}"; Flags: recursesubdirs createallsubdirs ignoreversion
+
+[Icons]
+Name: "{group}\NexusFlow"; Filename: "{app}\nexusflow-desktop-win_x64.exe"
+Name: "{userdesktop}\NexusFlow"; Filename: "{app}\nexusflow-desktop-win_x64.exe"; Tasks: desktopicon
+
+[Run]
+Filename: "{app}\nexusflow-desktop-win_x64.exe"; Description: "{cm:LaunchProgram,NexusFlow}"; Flags: nowait postinstall skipifsilent
+Filename: "{app}\nexusflow-desktop-win_x64.exe"; Flags: nowait skipifnotsilent

package/desktop/neutralino.config.json

@@ -0,0 +1,39 @@
+{
+  "$schema": "https://raw.githubusercontent.com/neutralinojs/neutralinojs/main/schemas/neutralino.config.schema.json",
+  "applicationId": "js.neutralino.nexusflow",
+  "version": "1.0.0",
+  "applicationIcon": "resources/app_logo.png",
+  "defaultMode": "window",
+  "port": 0,
+  "documentRoot": "/resources/",
+  "url": "/",
+  "enableServer": true,
+  "enableNativeAPI": true,
+  "logging": {
+    "enabled": true,
+    "writeToLogFile": true
+  },
+  "modes": {
+    "window": {
+      "title": "NexusFlow Dashboard",
+      "icon": "/resources/app_logo.png",
+      "width": 1000,
+      "height": 700,
+      "minWidth": 400,
+      "minHeight": 300,
+      "center": true,
+      "fullScreen": false,
+      "alwaysOnTop": false,
+      "enableInspector": true,
+      "openInspectorOnStartup": false,
+      "resizable": true
+    }
+  },
+  "cli": {
+    "binaryName": "nexusflow-desktop",
+    "resourcesPath": "/resources/",
+    "clientLibrary": "/resources/neutralino.js",
+    "binaryVersion": "6.8.0",
+    "clientVersion": "6.8.0"
+  }
+}