synapse-orch-ai 0.1.0

package/backend/tools/xlsx_parser.py

@@ -0,0 +1,79 @@
+
+from mcp.server import Server
+from mcp.server.stdio import stdio_server
+import mcp.types as types
+import asyncio
+import json
+import requests
+import pandas as pd
+import io
+
+# Initialize MCP Server
+app = Server("xlsx-parser-mcp-server")
+
+@app.list_tools()
+async def list_tools() -> list[types.Tool]:
+    return [
+        types.Tool(
+            name="parse_xlsx",
+            description="Parse an Excel file (XLSX) from a URL. Extracts sheets and converts them to Markdown tables.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "file_url": {
+                        "type": "string",
+                        "description": "URL of the Excel file to parse."
+                    }
+                },
+                "required": ["file_url"]
+            }
+        )
+    ]
+
+@app.call_tool()
+async def call_tool(name: str, arguments: dict) -> list[types.TextContent | types.ImageContent | types.EmbeddedResource]:
+    if name == "parse_xlsx":
+        file_url = arguments.get("file_url")
+        if not file_url:
+            raise ValueError("file_url is required")
+
+        try:
+            # Download XLSX
+            response = requests.get(file_url)
+            response.raise_for_status()
+            xlsx_bytes = io.BytesIO(response.content)
+
+            output_text = []
+
+            # Read all sheets
+            xlsx = pd.read_excel(xlsx_bytes, sheet_name=None)  # None reads all sheets as dict
+
+            for sheet_name, df in xlsx.items():
+                output_text.append(f"\n--- Sheet: {sheet_name} ---\n")
+                
+                if df.empty:
+                    output_text.append("[Empty Sheet]")
+                    continue
+
+                # Convert to Markdown
+                markdown = df.to_markdown(index=False)
+                output_text.append(markdown)
+                output_text.append("\n")
+
+            return [types.TextContent(type="text", text="".join(output_text))]
+
+        except Exception as e:
+            return [types.TextContent(type="text", text=f"Error parsing XLSX: {str(e)}")]
+
+    raise ValueError(f"Tool {name} not found")
+
+async def main():
+    async with stdio_server() as (read_stream, write_stream):
+        await app.run(
+            read_stream,
+            write_stream,
+            app.create_initialization_options()
+        )
+
+if __name__ == "__main__":
+    asyncio.run(main())

package/bin/synapse

@@ -0,0 +1,16 @@
+#!/bin/bash
+# Synapse AI CLI Wrapper — Activates venv and runs synapse command
+# Place this script in PATH or source it from your shell config
+
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+REPO_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
+VENV_DIR="$REPO_DIR/backend/venv"
+
+if [ ! -d "$VENV_DIR" ]; then
+    echo "Error: Virtual environment not found at $VENV_DIR"
+    echo "Run setup.sh first."
+    exit 1
+fi
+
+source "$VENV_DIR/bin/activate"
+python -m synapse "$@"

package/bin/synapse.bat

@@ -0,0 +1,36 @@
+@echo off
+REM Synapse AI CLI Wrapper — Activates venv, ensures Node.js is in PATH, runs synapse command
+REM Place this script in PATH or run it directly
+
+setlocal EnableDelayedExpansion
+
+set "SCRIPT_DIR=%~dp0"
+for %%I in ("%SCRIPT_DIR%..") do set "REPO_DIR=%%~fI"
+set "VENV_DIR=%REPO_DIR%\backend\venv"
+
+if not exist "%VENV_DIR%" (
+    echo Error: Virtual environment not found at %VENV_DIR%
+    echo Run setup.ps1 first.
+    exit /b 1
+)
+
+REM ---- Ensure Node.js (npm) is in PATH ----
+REM Probe known install locations so this works even when PATH is stale
+for %%N in (
+    "%ProgramFiles%\nodejs"
+    "%ProgramFiles(x86)%\nodejs"
+    "%LocalAppData%\Programs\nodejs"
+    "%LocalAppData%\nodejs"
+) do (
+    if exist "%%~N\npm.cmd" (
+        set "_NODE_DIR=%%~N"
+        goto :found_node
+    )
+)
+:found_node
+if defined _NODE_DIR (
+    set "PATH=%_NODE_DIR%;%PATH%"
+)
+
+call "%VENV_DIR%\Scripts\activate.bat"
+python -m synapse %*

package/bin/synapse.js

@@ -0,0 +1,247 @@
+#!/usr/bin/env node
+'use strict';
+
+const { spawnSync, spawn, execFileSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const crypto = require('crypto');
+const http = require('http');
+const os = require('os');
+
+const PKG_DIR = path.resolve(__dirname, '..');
+const BACKEND_DIR = path.join(PKG_DIR, 'backend');
+const FRONTEND_BUILD = path.join(PKG_DIR, 'frontend-build');
+const REQUIREMENTS = path.join(BACKEND_DIR, 'requirements.txt');
+
+const SYNAPSE_HOME = path.join(os.homedir(), '.synapse');
+const VENV_DIR = path.join(SYNAPSE_HOME, 'venv');
+const DATA_DIR = process.env.SYNAPSE_DATA_DIR || path.join(SYNAPSE_HOME, 'data');
+const HASH_FILE = path.join(SYNAPSE_HOME, 'requirements.hash');
+
+const BACKEND_PORT = parseInt(process.env.SYNAPSE_BACKEND_PORT || '8765');
+const FRONTEND_PORT = parseInt(process.env.SYNAPSE_FRONTEND_PORT || '3000');
+
+// ── Prerequisite checks ───────────────────────────────────────────────────────
+
+function checkCmd(cmd) {
+  const result = spawnSync(cmd, ['--version'], { stdio: 'pipe' });
+  return result.status === 0;
+}
+
+function checkPrerequisites() {
+  if (!checkCmd('python3')) {
+    console.error('Error: python3 not found. Install Python 3.11+ from https://www.python.org/');
+    process.exit(1);
+  }
+  // Verify version >= 3.11
+  const result = spawnSync('python3', ['-c', 'import sys; print(sys.version_info[:2])'], { stdio: 'pipe' });
+  if (result.status === 0) {
+    const out = result.stdout.toString().trim();
+    const match = out.match(/\((\d+),\s*(\d+)\)/);
+    if (match) {
+      const [, major, minor] = match.map(Number);
+      if (major < 3 || (major === 3 && minor < 11)) {
+        console.error(`Error: Python 3.11+ required, found ${major}.${minor}. Install from https://www.python.org/`);
+        process.exit(1);
+      }
+    }
+  }
+  if (!checkCmd('npx')) {
+    console.error('Error: npx not found. Install Node.js from https://nodejs.org/');
+    process.exit(1);
+  }
+  if (!checkCmd('ollama')) {
+    console.warn('Warning: ollama not found. Local models won\'t work; cloud API models still work.');
+  }
+}
+
+// ── Python venv setup ─────────────────────────────────────────────────────────
+
+function getRequirementsHash() {
+  if (!fs.existsSync(REQUIREMENTS)) return null;
+  return crypto.createHash('md5').update(fs.readFileSync(REQUIREMENTS)).digest('hex');
+}
+
+function venvPython() {
+  return os.platform() === 'win32'
+    ? path.join(VENV_DIR, 'Scripts', 'python.exe')
+    : path.join(VENV_DIR, 'bin', 'python');
+}
+
+function venvPip() {
+  return os.platform() === 'win32'
+    ? path.join(VENV_DIR, 'Scripts', 'pip.exe')
+    : path.join(VENV_DIR, 'bin', 'pip');
+}
+
+function setupVenv() {
+  const currentHash = getRequirementsHash();
+  const savedHash = fs.existsSync(HASH_FILE) ? fs.readFileSync(HASH_FILE, 'utf8').trim() : null;
+
+  if (fs.existsSync(venvPython()) && currentHash === savedHash) {
+    return; // Already up to date
+  }
+
+  if (!fs.existsSync(VENV_DIR)) {
+    console.log('Creating Python virtual environment...');
+    const result = spawnSync('python3', ['-m', 'venv', VENV_DIR], { stdio: 'inherit' });
+    if (result.status !== 0) {
+      console.error('Failed to create virtual environment.');
+      process.exit(1);
+    }
+  }
+
+  console.log('Installing Python dependencies (first run, this may take a minute)...');
+  const result = spawnSync(venvPip(), ['install', '-r', REQUIREMENTS, '--quiet'], { stdio: 'inherit' });
+  if (result.status !== 0) {
+    console.error('Failed to install Python dependencies.');
+    process.exit(1);
+  }
+
+  if (currentHash) fs.writeFileSync(HASH_FILE, currentHash);
+}
+
+// ── Data directory ────────────────────────────────────────────────────────────
+
+const DEFAULT_JSON = {
+  'user_agents.json': '[]',
+  'orchestrations.json': '[]',
+  'repos.json': '[]',
+  'mcp_servers.json': '[]',
+  'custom_tools.json': '[]',
+};
+
+function ensureDataDir() {
+  fs.mkdirSync(DATA_DIR, { recursive: true });
+  for (const sub of ['vault', 'datasets', 'orchestration_runs', 'orchestration_logs']) {
+    fs.mkdirSync(path.join(DATA_DIR, sub), { recursive: true });
+  }
+  for (const [file, content] of Object.entries(DEFAULT_JSON)) {
+    const target = path.join(DATA_DIR, file);
+    if (!fs.existsSync(target)) fs.writeFileSync(target, content);
+  }
+}
+
+// ── Process management ────────────────────────────────────────────────────────
+
+function startBackend() {
+  const env = {
+    ...process.env,
+    SYNAPSE_DATA_DIR: DATA_DIR,
+    PYTHONPATH: BACKEND_DIR + (process.env.PYTHONPATH ? path.delimiter + process.env.PYTHONPATH : ''),
+  };
+  return spawn(venvPython(), [path.join(BACKEND_DIR, 'main.py')], {
+    cwd: BACKEND_DIR,
+    env,
+    stdio: 'inherit',
+  });
+}
+
+function startFrontend() {
+  if (!fs.existsSync(FRONTEND_BUILD)) {
+    console.error('Error: bundled frontend not found at', FRONTEND_BUILD);
+    console.error('The package may be corrupted. Try reinstalling: npm install -g synapse-ai');
+    process.exit(1);
+  }
+  const env = {
+    ...process.env,
+    PORT: String(FRONTEND_PORT),
+    HOSTNAME: '0.0.0.0',
+    BACKEND_URL: `http://127.0.0.1:${BACKEND_PORT}`,
+    NODE_ENV: 'production',
+  };
+  return spawn('node', [path.join(FRONTEND_BUILD, 'server.js')], {
+    cwd: FRONTEND_BUILD,
+    env,
+    stdio: 'inherit',
+  });
+}
+
+function waitForPort(port, name) {
+  return new Promise((resolve, reject) => {
+    let attempts = 0;
+    const max = 45;
+    const check = () => {
+      const req = http.get({ host: '127.0.0.1', port, path: '/' }, () => {
+        console.log(`  ${name} ready.`);
+        resolve();
+      });
+      req.setTimeout(2000);
+      req.on('error', () => {
+        if (++attempts < max) setTimeout(check, 2000);
+        else reject(new Error(`Timeout waiting for ${name} on port ${port}`));
+      });
+      req.end();
+    };
+    check();
+  });
+}
+
+function openBrowser(url) {
+  const platform = os.platform();
+  const cmd = platform === 'darwin' ? 'open' : platform === 'win32' ? 'cmd' : 'xdg-open';
+  const args = platform === 'win32' ? ['/c', 'start', url] : [url];
+  setTimeout(() => {
+    try { spawn(cmd, args, { detached: true, stdio: 'ignore' }).unref(); } catch {}
+  }, 1000);
+}
+
+// ── Main ──────────────────────────────────────────────────────────────────────
+
+async function main() {
+  console.log('Starting Synapse...');
+  checkPrerequisites();
+  fs.mkdirSync(SYNAPSE_HOME, { recursive: true });
+  setupVenv();
+  ensureDataDir();
+
+  console.log('Starting backend...');
+  const backend = startBackend();
+
+  try {
+    await waitForPort(BACKEND_PORT, 'Backend');
+  } catch (err) {
+    console.error(err.message);
+    backend.kill();
+    process.exit(1);
+  }
+
+  console.log('Starting frontend...');
+  const frontend = startFrontend();
+
+  try {
+    await waitForPort(FRONTEND_PORT, 'Frontend');
+  } catch (err) {
+    console.error(err.message);
+    backend.kill();
+    frontend.kill();
+    process.exit(1);
+  }
+
+  const url = `http://localhost:${FRONTEND_PORT}`;
+  openBrowser(url);
+  console.log(`\nSynapse is running at ${url}`);
+  console.log('Press Ctrl+C to stop.\n');
+
+  function shutdown() {
+    console.log('\nStopping Synapse...');
+    backend.kill();
+    frontend.kill();
+    process.exit(0);
+  }
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+  backend.on('exit', (code) => {
+    if (code !== null && code !== 0) {
+      console.error(`Backend exited with code ${code}`);
+      frontend.kill();
+      process.exit(code);
+    }
+  });
+}
+
+main().catch((err) => {
+  console.error('Fatal error:', err.message);
+  process.exit(1);
+});

package/frontend-build/.next/BUILD_ID

@@ -0,0 +1 @@
+2m6rYBnEW4xy8D-1wzwqJ

package/frontend-build/.next/app-path-routes-manifest.json

@@ -0,0 +1,22 @@
+{
+  "/_global-error/page": "/_global-error",
+  "/_not-found/page": "/_not-found",
+  "/api/agent-types/route": "/api/agent-types",
+  "/api/agents/generate-prompt/route": "/api/agents/generate-prompt",
+  "/api/builder/chat/route": "/api/builder/chat",
+  "/api/builder/resume/route": "/api/builder/resume",
+  "/api/chat/route": "/api/chat",
+  "/api/chat/stream/route": "/api/chat/stream",
+  "/api/logs/[type]/[run_id]/route": "/api/logs/[type]/[run_id]",
+  "/api/logs/[type]/route": "/api/logs/[type]",
+  "/api/models/route": "/api/models",
+  "/api/orchestrations/[orch_id]/run/route": "/api/orchestrations/[orch_id]/run",
+  "/api/orchestrations/runs/[run_id]/human-input/route": "/api/orchestrations/runs/[run_id]/human-input",
+  "/api/orchestrations/runs/[run_id]/resume/route": "/api/orchestrations/runs/[run_id]/resume",
+  "/api/schedules/[schedule_id]/route": "/api/schedules/[schedule_id]",
+  "/api/schedules/[schedule_id]/run/route": "/api/schedules/[schedule_id]/run",
+  "/api/schedules/route": "/api/schedules",
+  "/icon.svg/route": "/icon.svg",
+  "/page": "/",
+  "/settings/[tab]/page": "/settings/[tab]"
+}

package/frontend-build/.next/build-manifest.json

@@ -0,0 +1,21 @@
+{
+  "pages": {
+    "/_app": []
+  },
+  "devFiles": [],
+  "polyfillFiles": [
+    "static/chunks/03~yq9q893hmn.js"
+  ],
+  "lowPriorityFiles": [
+    "static/2m6rYBnEW4xy8D-1wzwqJ/_buildManifest.js",
+    "static/2m6rYBnEW4xy8D-1wzwqJ/_ssgManifest.js",
+    "static/2m6rYBnEW4xy8D-1wzwqJ/_clientMiddlewareManifest.js"
+  ],
+  "rootMainFiles": [
+    "static/chunks/0mim5z5~_34t1.js",
+    "static/chunks/02i7dfk78~t~2.js",
+    "static/chunks/05dz57h.5fg3-.js",
+    "static/chunks/0h4a4y-~puu.x.js",
+    "static/chunks/turbopack-1606efl0p3-k2.js"
+  ]
+}

package/frontend-build/.next/package.json

@@ -0,0 +1 @@
+{"type": "commonjs"}

package/frontend-build/.next/prerender-manifest.json

@@ -0,0 +1,114 @@
+{
+  "version": 4,
+  "routes": {
+    "/": {
+      "experimentalBypassFor": [
+        {
+          "type": "header",
+          "key": "next-action"
+        },
+        {
+          "type": "header",
+          "key": "content-type",
+          "value": "multipart/form-data;.*"
+        }
+      ],
+      "initialRevalidateSeconds": false,
+      "srcRoute": "/",
+      "dataRoute": "/index.rsc",
+      "allowHeader": [
+        "host",
+        "x-matched-path",
+        "x-prerender-revalidate",
+        "x-prerender-revalidate-if-generated",
+        "x-next-revalidated-tags",
+        "x-next-revalidate-tag-token"
+      ]
+    },
+    "/_global-error": {
+      "experimentalBypassFor": [
+        {
+          "type": "header",
+          "key": "next-action"
+        },
+        {
+          "type": "header",
+          "key": "content-type",
+          "value": "multipart/form-data;.*"
+        }
+      ],
+      "initialRevalidateSeconds": false,
+      "srcRoute": "/_global-error",
+      "dataRoute": "/_global-error.rsc",
+      "allowHeader": [
+        "host",
+        "x-matched-path",
+        "x-prerender-revalidate",
+        "x-prerender-revalidate-if-generated",
+        "x-next-revalidated-tags",
+        "x-next-revalidate-tag-token"
+      ]
+    },
+    "/_not-found": {
+      "initialStatus": 404,
+      "experimentalBypassFor": [
+        {
+          "type": "header",
+          "key": "next-action"
+        },
+        {
+          "type": "header",
+          "key": "content-type",
+          "value": "multipart/form-data;.*"
+        }
+      ],
+      "initialRevalidateSeconds": false,
+      "srcRoute": "/_not-found",
+      "dataRoute": "/_not-found.rsc",
+      "allowHeader": [
+        "host",
+        "x-matched-path",
+        "x-prerender-revalidate",
+        "x-prerender-revalidate-if-generated",
+        "x-next-revalidated-tags",
+        "x-next-revalidate-tag-token"
+      ]
+    },
+    "/icon.svg": {
+      "initialHeaders": {
+        "cache-control": "public, max-age=0, must-revalidate",
+        "content-type": "image/svg+xml",
+        "x-next-cache-tags": "_N_T_/layout,_N_T_/icon.svg/layout,_N_T_/icon.svg/route,_N_T_/icon.svg"
+      },
+      "experimentalBypassFor": [
+        {
+          "type": "header",
+          "key": "next-action"
+        },
+        {
+          "type": "header",
+          "key": "content-type",
+          "value": "multipart/form-data;.*"
+        }
+      ],
+      "initialRevalidateSeconds": false,
+      "srcRoute": "/icon.svg",
+      "dataRoute": null,
+      "allowHeader": [
+        "host",
+        "x-matched-path",
+        "x-prerender-revalidate",
+        "x-prerender-revalidate-if-generated",
+        "x-next-revalidated-tags",
+        "x-next-revalidate-tag-token"
+      ]
+    }
+  },
+  "dynamicRoutes": {},
+  "notFoundRoutes": [],
+  "preview": {
+    "previewModeId": "d0e3fa20dd48467f0eafde24aeaccb24",
+    "previewModeSigningKey": "626f5e40a84014264ea4438bef3a26aeaf3ffa30d2b3f6d19143f0093cf44ed3",
+    "previewModeEncryptionKey": "617775a53dc035b81af27132737658fb84980c55afab8b3fc85ee6f6bba440a7"
+  }
+}