stacks-ai 0.1.1

package/README.md

@@ -0,0 +1,93 @@
+# Stacks
+
+AI-powered infinite canvas workspace for notes, images, and creative organization.
+
+## Features
+
+- Infinite canvas with zoom and pan
+- Notes, sticky notes, and text items
+- Image support with EXIF metadata
+- AI-powered organization and analysis
+- Connect items with visual links
+- Auto-arrange with ELK layout engine
+- Auto-save to local storage
+- MCP server for AI integration
+
+## Installation
+
+### Run with npx (no installation)
+
+```bash
+npx stacks-ai
+```
+
+On first run, Electron will be downloaded automatically (~100MB). Subsequent runs are instant.
+
+### Install globally
+
+```bash
+npm install -g stacks-ai
+stacks-ai
+```
+
+### Install from source
+
+```bash
+git clone https://github.com/jasonkneen/stacks.git
+cd stacks
+npm install
+npm run build
+npm run electron
+```
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Run dev server (web only)
+npm run dev
+
+# Run Electron in dev mode
+npm run electron:dev
+
+# Build for production
+npm run build:prod
+
+# Run MCP server
+npm run mcp:dev
+```
+
+## Environment Variables
+
+Create a `.env` file in the root directory:
+
+```env
+GEMINI_API_KEY=your_gemini_api_key_here
+```
+
+## Package Structure
+
+- `bin/` - CLI launcher script
+- `electron/` - Electron main process
+- `dist/` - Built application assets
+- `mcp/` - Model Context Protocol server
+
+## How it works
+
+When you run `npx stacks-ai` or `stacks-ai`:
+
+1. The launcher script checks if Electron is installed
+2. If not, it downloads Electron (~100MB, cached in `~/.stacks/`)
+3. The MCP proxy starts for AI integration
+4. Electron loads the built app from `dist/`
+5. The app runs entirely locally - no internet required (except for AI features)
+
+## License
+
+MIT
+
+## Author
+
+Jason Kneen

package/bin/stacks.cjs

@@ -0,0 +1,215 @@
+#!/usr/bin/env node
+
+/**
+ * npx launcher for Stacks
+ * Downloads and caches Electron binary on first run, then launches the app
+ * Electron is cached in ~/.stacks/ for persistence across npx runs
+ */
+
+const { spawn, execFileSync } = require('child_process')
+const path = require('path')
+const fs = require('fs')
+const os = require('os')
+
+const APP_NAME = 'stacks'
+const APP_DIR = path.join(__dirname, '..')
+const CACHE_DIR = path.join(os.homedir(), '.stacks')
+const ELECTRON_CACHE = path.join(CACHE_DIR, 'electron')
+
+let proxyProcess = null
+
+function ensureCacheDir() {
+  if (!fs.existsSync(CACHE_DIR)) {
+    fs.mkdirSync(CACHE_DIR, { recursive: true })
+  }
+  if (!fs.existsSync(ELECTRON_CACHE)) {
+    fs.mkdirSync(ELECTRON_CACHE, { recursive: true })
+  }
+}
+
+function getElectronPath() {
+  const platform = os.platform()
+  const electronBin = platform === 'win32' ? 'electron.cmd' : 'electron'
+  return path.join(ELECTRON_CACHE, 'node_modules', '.bin', electronBin)
+}
+
+function getNpmCommand() {
+  return os.platform() === 'win32' ? 'npm.cmd' : 'npm'
+}
+
+function getNodeCommand() {
+  return process.execPath
+}
+
+async function ensureElectron() {
+  ensureCacheDir()
+
+  const electronPath = getElectronPath()
+
+  // Check if electron is already cached
+  if (fs.existsSync(electronPath)) {
+    return electronPath
+  }
+
+  console.log('☐ Installing Electron (first run only)...')
+  console.log(`  Cache location: ${ELECTRON_CACHE}`)
+
+  try {
+    // Create a minimal package.json for electron installation
+    const pkgPath = path.join(ELECTRON_CACHE, 'package.json')
+    fs.writeFileSync(pkgPath, JSON.stringify({
+      name: 'stacks-electron-cache',
+      version: '1.0.0',
+      private: true
+    }))
+
+    // Install electron to cache directory using execFileSync (safer than execSync)
+    const npm = getNpmCommand()
+    execFileSync(npm, ['install', 'electron@latest', '--no-save', '--no-audit', '--no-fund'], {
+      cwd: ELECTRON_CACHE,
+      stdio: 'inherit'
+    })
+
+    console.log('✓ Electron installed successfully!\n')
+    return electronPath
+  } catch (error) {
+    console.error('✗ Failed to install Electron:', error.message)
+    console.error('\nTry installing manually:')
+    console.error(`  cd ${ELECTRON_CACHE} && npm install electron`)
+    process.exit(1)
+  }
+}
+
+function checkBuilt() {
+  const distDir = path.join(APP_DIR, 'dist')
+  const indexHtml = path.join(distDir, 'index.html')
+
+  if (!fs.existsSync(indexHtml)) {
+    console.error('✗ App not built. dist/index.html not found.')
+    console.error('\nIf you cloned from source, run:')
+    console.error('  npm install && npm run build')
+    process.exit(1)
+  }
+}
+
+function startProxy() {
+  const proxyPath = path.join(APP_DIR, 'dist', 'mcp', 'proxy.js')
+
+  if (!fs.existsSync(proxyPath)) {
+    console.log('⚠ MCP proxy not found, skipping...')
+    return null
+  }
+
+  console.log('☐ Starting MCP proxy...')
+
+  const node = getNodeCommand()
+  proxyProcess = spawn(node, [proxyPath], {
+    cwd: APP_DIR,
+    stdio: ['ignore', 'pipe', 'pipe'],
+    env: {
+      ...process.env,
+      NODE_ENV: 'production'
+    },
+    detached: false
+  })
+
+  proxyProcess.stdout.on('data', () => {
+    // Proxy logs go to stderr by design, stdout is for JSON-RPC
+  })
+
+  proxyProcess.stderr.on('data', (data) => {
+    const msg = data.toString().trim()
+    if (msg.includes('ready')) {
+      console.log('✓ MCP proxy ready')
+    }
+  })
+
+  proxyProcess.on('error', (err) => {
+    console.error('⚠ Proxy error:', err.message)
+  })
+
+  return proxyProcess
+}
+
+function stopProxy() {
+  if (proxyProcess) {
+    proxyProcess.kill()
+    proxyProcess = null
+  }
+}
+
+async function launch() {
+  try {
+    console.log(`\n🚀 Starting Stacks...\n`)
+
+    checkBuilt()
+    startProxy()
+    const electronPath = await ensureElectron()
+
+    // Launch Electron with the app
+    const child = spawn(electronPath, [APP_DIR], {
+      stdio: 'inherit',
+      env: {
+        ...process.env,
+        NODE_ENV: 'production',
+        ELECTRON_DISABLE_SECURITY_WARNINGS: 'true'
+      }
+    })
+
+    child.on('exit', (code) => {
+      stopProxy()
+      process.exit(code || 0)
+    })
+
+    child.on('error', (err) => {
+      console.error('Failed to start Electron:', err.message)
+      stopProxy()
+      process.exit(1)
+    })
+
+    // Handle signals
+    process.on('SIGINT', () => {
+      stopProxy()
+      child.kill('SIGINT')
+    })
+    process.on('SIGTERM', () => {
+      stopProxy()
+      child.kill('SIGTERM')
+    })
+
+  } catch (error) {
+    console.error('Failed to launch Stacks:', error.message)
+    stopProxy()
+    process.exit(1)
+  }
+}
+
+// CLI arguments
+const args = process.argv.slice(2)
+
+if (args.includes('--help') || args.includes('-h')) {
+  console.log(`
+Stacks - AI-powered infinite canvas
+
+Usage:
+  npx stacks-ai          Launch the app
+  npx stacks-ai --clean  Clear cached Electron installation
+  npx stacks-ai --help   Show this help message
+
+Cache location: ${CACHE_DIR}
+`)
+  process.exit(0)
+}
+
+if (args.includes('--clean')) {
+  console.log('Cleaning Electron cache...')
+  if (fs.existsSync(ELECTRON_CACHE)) {
+    fs.rmSync(ELECTRON_CACHE, { recursive: true })
+    console.log('✓ Cache cleared')
+  } else {
+    console.log('Cache already empty')
+  }
+  process.exit(0)
+}
+
+launch()

package/dist/assets/aiProvider-DYAx3DVK.js

@@ -0,0 +1 @@
+import{s as g}from"./index-C1agmKFP.js";import{c as s,o as c,a as y}from"./index-C8w_QbzK.js";const t={},i=e=>{const r={anthropic:"anthropic-api-key",openai:"openai-api-key",google:"gemini-api-key"}[e],o=localStorage.getItem(r);return console.log(`[aiProvider] Getting API key for ${e}:`,{keyName:r,hasKey:!!o,keyLength:(o==null?void 0:o.length)||0,keyPreview:o?`${o.substring(0,10)}...`:"none"}),o||{anthropic:t==null?void 0:t.VITE_ANTHROPIC_API_KEY,openai:t==null?void 0:t.VITE_OPENAI_API_KEY,google:t==null?void 0:t.VITE_GEMINI_API_KEY}[e]||""},h=e=>{const a=e.apiKey||i(e.provider);if(console.log("[aiProvider] getLanguageModel called:",{provider:e.provider,model:e.model,hasApiKey:!!a,apiKeyLength:(a==null?void 0:a.length)||0,configApiKey:!!e.apiKey}),!a)throw new Error(`${e.provider} API key not configured. Please add your API key in Settings → Providers.`);switch(e.provider){case"anthropic":return y(e.model||"claude-sonnet-4-5-20250929",{apiKey:a});case"openai":return c(e.model||"gpt-4o",{apiKey:a});case"google":return s({apiKey:a})(e.model||"gemini-2.0-flash-exp");default:throw new Error(`Unknown provider: ${e.provider}`)}},I=async(e,a,r)=>{const o=(r==null?void 0:r.provider)||"google",l=h({provider:o,model:r==null?void 0:r.model}),n=await g({model:l,system:r==null?void 0:r.systemPrompt,prompt:e});for await(const d of n.textStream)a(d)};export{I as generateTextStream,h as getLanguageModel};