@feltdb/core 0.4.5 → 0.4.6

package/dist/create/cli-scripts-generator.js

@@ -0,0 +1,211 @@
+/**
+ * CLI lifecycle scripts for FeltDB applications
+ *
+ * Generates scripts for common operations:
+ * - feltdb:up - Start services
+ * - feltdb:down - Stop services
+ * - feltdb:logs - View logs
+ * - feltdb:status - Check health
+ * - feltdb:reset - Reset data
+ * - feltdb:ps - List running services
+ */
+export function generateUpScript() {
+    return `#!/bin/bash
+
+# Start FeltDB application stack
+# Usage: npm run feltdb:up
+
+set -e
+
+echo "🚀 Starting FeltDB application..."
+
+# Load environment
+if [ -f .env.local ]; then
+  export \$(cat .env.local | grep -v '^#' | xargs)
+fi
+
+# Build and start containers
+docker-compose up -d
+
+echo "⏳ Waiting for services to be healthy..."
+
+# Wait for FeltDB
+TIMEOUT=60
+ELAPSED=0
+while [ \$ELAPSED -lt \$TIMEOUT ]; do
+  if curl -s -f http://localhost:7700/health > /dev/null 2>&1; then
+    STATE=\$(curl -s http://localhost:7700/health | grep -o '"state":"[^"]*' | cut -d'"' -f4)
+    if [ "\$STATE" = "ready" ] || [ "\$STATE" = "recovering" ]; then
+      echo "✅ FeltDB is \$STATE"
+      break
+    fi
+  fi
+  sleep 2
+  ELAPSED=\$((ELAPSED + 2))
+done
+
+# Wait for application
+ELAPSED=0
+while [ \$ELAPSED -lt \$TIMEOUT ]; do
+  if curl -s -f http://localhost:3000/health > /dev/null 2>&1; then
+    echo "✅ Application is ready"
+    break
+  fi
+  sleep 2
+  ELAPSED=\$((ELAPSED + 2))
+done
+
+echo ""
+echo "✨ FeltDB stack is running!"
+echo ""
+echo "Services:"
+echo "  FeltDB:  http://localhost:7700"
+echo "  App:     http://localhost:3000"
+echo "  Studio:  http://localhost:8000"
+echo ""
+echo "Next: npm run feltdb:logs"
+`;
+}
+export function generateDownScript() {
+    return `#!/bin/bash
+
+# Stop FeltDB application stack
+# Usage: npm run feltdb:down
+
+echo "🛑 Stopping FeltDB application..."
+
+docker-compose down
+
+echo "✅ Services stopped"
+`;
+}
+export function generateLogsScript() {
+    return `#!/bin/bash
+
+# View logs from FeltDB stack
+# Usage: npm run feltdb:logs [service]
+#        npm run feltdb:logs feltdb
+#        npm run feltdb:logs app
+#        npm run feltdb:logs studio
+
+SERVICE=\$1
+
+if [ -z "\$SERVICE" ]; then
+  echo "📋 Logs from all services (Ctrl+C to exit):"
+  docker-compose logs -f
+else
+  echo "📋 Logs from \$SERVICE (Ctrl+C to exit):"
+  docker-compose logs -f \$SERVICE
+fi
+`;
+}
+export function generateStatusScript() {
+    return `#!/bin/bash
+
+# Check health and status of FeltDB stack
+# Usage: npm run feltdb:status
+
+echo "🔍 FeltDB Application Status"
+echo ""
+
+# Docker Compose status
+echo "Containers:"
+docker-compose ps
+
+echo ""
+
+# FeltDB health
+echo "FeltDB Health:"
+if RESPONSE=\$(curl -s -m 5 http://localhost:7700/health 2>/dev/null); then
+  STATE=\$(echo \$RESPONSE | grep -o '"state":"[^"]*' | cut -d'"' -f4)
+  VERSION=\$(echo \$RESPONSE | grep -o '"version":"[^"]*' | cut -d'"' -f4)
+  echo "  State:   \$STATE"
+  echo "  Version: \$VERSION"
+else
+  echo "  ❌ No response"
+fi
+
+# Application health
+echo ""
+echo "Application Health:"
+if RESPONSE=\$(curl -s -m 5 http://localhost:3000/health 2>/dev/null); then
+  echo "  ✅ Responding"
+else
+  echo "  ❌ No response"
+fi
+
+echo ""
+echo "Log tail: npm run feltdb:logs"
+`;
+}
+export function generateResetScript() {
+    return `#!/bin/bash
+
+# Reset FeltDB data (WARNING: destructive)
+# Usage: npm run feltdb:reset
+
+echo "⚠️  This will delete all FeltDB data!"
+read -p "Are you sure? (type 'yes' to confirm): " CONFIRM
+
+if [ "\$CONFIRM" != "yes" ]; then
+  echo "Cancelled."
+  exit 1
+fi
+
+echo "🧹 Resetting FeltDB data..."
+
+# Stop containers
+docker-compose down
+
+# Remove volumes
+docker volume rm \$(docker volume ls -q | grep feltdb_data) 2>/dev/null || true
+
+# Restart
+echo "🚀 Restarting services..."
+docker-compose up -d
+
+echo "✅ Data reset complete"
+`;
+}
+export function generatePsScript() {
+    return `#!/bin/bash
+
+# List running FeltDB services
+# Usage: npm run feltdb:ps
+
+docker-compose ps
+`;
+}
+export function generatePackageJsonScripts(runtime) {
+    const scripts = {
+        'feltdb:up': 'bash scripts/feltdb-up.sh',
+        'feltdb:down': 'bash scripts/feltdb-down.sh',
+        'feltdb:logs': 'bash scripts/feltdb-logs.sh',
+        'feltdb:status': 'bash scripts/feltdb-status.sh',
+        'feltdb:reset': 'bash scripts/feltdb-reset.sh',
+        'feltdb:ps': 'bash scripts/feltdb-ps.sh',
+    };
+    if (runtime === 'browser') {
+        // Browser doesn't need container scripts
+        return {
+            dev: 'vite',
+            build: 'tsc && vite build',
+        };
+    }
+    if (runtime === 'node') {
+        return {
+            dev: 'tsx src/index.ts',
+            build: 'tsc',
+            start: 'node dist/index.js',
+            ...scripts,
+        };
+    }
+    if (runtime === 'self-hosted') {
+        return {
+            dev: 'docker-compose up -d --build',
+            build: 'docker-compose build',
+            ...scripts,
+        };
+    }
+    return scripts;
+}

package/dist/create/cli.js

@@ -0,0 +1,202 @@
+#!/usr/bin/env node
+/**
+ * create-feltdb
+ *
+ * Interactive CLI for creating new FeltDB applications
+ */
+import path from 'path';
+import { fileURLToPath } from 'url';
+import readline from 'readline';
+import { spawn } from 'child_process';
+import { createProject } from './create.js';
+import { FELTDB_PACKAGE_VERSION } from './package-versions.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+function parseArgs(args) {
+    const options = {
+        runtime: 'browser',
+        framework: 'react',
+        distributed: true,
+        agents: true,
+        capabilities: 'search',
+    };
+    for (let i = 0; i < args.length; i++) {
+        switch (args[i]) {
+            case '--runtime':
+                options.runtime = args[++i];
+                break;
+            case '--framework':
+                options.framework = args[++i];
+                break;
+            case '--no-distributed':
+                options.distributed = false;
+                break;
+            case '--no-agents':
+                options.agents = false;
+                break;
+            case '--capabilities':
+                options.capabilities = args[++i];
+                break;
+        }
+    }
+    return options;
+}
+function run(command, args, cwd) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, { cwd, stdio: 'inherit' });
+        child.once('error', reject);
+        child.once('exit', code => code === 0
+            ? resolve()
+            : reject(new Error(`${command} exited with status ${code ?? 'unknown'}`)));
+    });
+}
+async function select(message, choices, initialValue) {
+    let selected = Math.max(0, choices.findIndex(choice => choice.value === initialValue));
+    const input = process.stdin;
+    const output = process.stdout;
+    const wasRaw = input.isRaw;
+    readline.emitKeypressEvents(input);
+    input.setRawMode(true);
+    input.resume();
+    const render = (moveUp) => {
+        if (moveUp)
+            output.write(`\x1b[${choices.length}A`);
+        for (let index = 0; index < choices.length; index++) {
+            const choice = choices[index];
+            const active = index === selected;
+            const detail = choice.description ? ` \x1b[2m— ${choice.description}\x1b[22m` : '';
+            output.write(`\x1b[2K\r  ${active ? '\x1b[36m❯' : ' '} ${choice.label}${active ? '\x1b[0m' : ''}${detail}\n`);
+        }
+    };
+    output.write(`${message}\n`);
+    render(false);
+    return new Promise(resolve => {
+        const finish = () => {
+            input.off('keypress', onKeypress);
+            input.setRawMode(Boolean(wasRaw));
+            input.pause();
+            resolve(choices[selected].value);
+        };
+        const onKeypress = (_value, key) => {
+            if (key.ctrl && key.name === 'c') {
+                output.write('\n');
+                input.setRawMode(Boolean(wasRaw));
+                process.exit(130);
+            }
+            if (key.name === 'up')
+                selected = (selected - 1 + choices.length) % choices.length;
+            else if (key.name === 'down')
+                selected = (selected + 1) % choices.length;
+            else if (key.name === 'return' || key.name === 'enter')
+                return finish();
+            else
+                return;
+            render(true);
+        };
+        input.on('keypress', onKeypress);
+    });
+}
+async function promptForOptions(defaults) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY)
+        return defaults;
+    console.log('Configure your application. Use ↑/↓ to move and Enter to select.\n');
+    const yesNo = [
+        { label: 'Yes', value: true },
+        { label: 'No', value: false },
+    ];
+    return {
+        runtime: await select('Where should FeltDB run?', [
+            { label: 'Browser', value: 'browser', description: 'local-first with durable browser storage' },
+            { label: 'Node.js', value: 'node', description: 'application server or worker' },
+            { label: 'Self-hosted', value: 'self-hosted', description: 'dedicated FeltDB server' },
+        ], defaults.runtime),
+        framework: await select('Choose an application framework:', [
+            { label: 'React', value: 'react' },
+            { label: 'Vanilla TypeScript', value: 'vanilla' },
+        ], defaults.framework),
+        distributed: await select('Enable distributed operation?', yesNo, defaults.distributed),
+        agents: await select('Include an autonomous agent example?', yesNo, defaults.agents),
+        capabilities: await select('Choose starter capabilities:', [
+            { label: 'Search', value: 'search' },
+            { label: 'Vector search', value: 'vector' },
+            { label: 'Search + vector search', value: 'search,vector' },
+        ], defaults.capabilities),
+    };
+}
+async function main() {
+    const args = process.argv.slice(2);
+    if (args.includes('--help') || args.includes('-h')) {
+        console.log(`create-feltdb ${FELTDB_PACKAGE_VERSION}\n\nUsage: create-feltdb [project-name] [options]\n\nOptions:\n  --runtime <browser|node|self-hosted>\n  --framework <react|vanilla>\n  --no-distributed\n  --no-agents\n  --capabilities <list>\n  --no-install\n  --no-start\n  -y, --yes\n  -h, --help\n  --version`);
+        return;
+    }
+    if (args.includes('--version')) {
+        console.log(FELTDB_PACKAGE_VERSION);
+        return;
+    }
+    // Find project name (first non-flag argument)
+    let projectName = 'feltdb-app';
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (!arg.startsWith('-')) {
+            projectName = arg;
+            break;
+        }
+        // Skip next arg if current arg is a flag that takes a value
+        if (arg === '--runtime' || arg === '--framework' || arg === '--capabilities') {
+            i++;
+        }
+    }
+    const shouldAutoYes = args.includes('--yes') || args.includes('-y');
+    const shouldInstall = !args.includes('--no-install');
+    const shouldStart = !args.includes('--no-start');
+    let options = parseArgs(args);
+    console.log('\n✨ Creating FeltDB Application\n');
+    if (!shouldAutoYes) {
+        options = await promptForOptions(options);
+        console.log('\nConfiguration:');
+        console.log(`  Runtime:       ${options.runtime}`);
+        console.log(`  Framework:     ${options.framework}`);
+        console.log(`  Distributed:   ${options.distributed ? 'yes' : 'no'}`);
+        console.log(`  Agents:        ${options.agents ? 'yes' : 'no'}`);
+        console.log(`  Capabilities:  ${options.capabilities}\n`);
+    }
+    try {
+        await createProject({
+            projectName,
+            autoYes: shouldAutoYes,
+            templatesDir: path.join(__dirname, '../templates'),
+            runtime: options.runtime,
+            framework: options.framework,
+            distributed: options.distributed,
+            agents: options.agents,
+            capabilities: options.capabilities,
+        });
+        console.log('\n✅ FeltDB application created successfully!\n');
+        const projectDir = path.resolve(process.cwd(), projectName);
+        const npm = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+        if (shouldInstall) {
+            console.log('📦 Installing application, Studio, and local AI dependencies...\n');
+            await run(npm, ['install'], projectDir);
+        }
+        if (shouldStart) {
+            if (!shouldInstall) {
+                console.log(`Start after installing dependencies:\n  cd ${projectName}\n  npm install\n  npm run dev\n`);
+            }
+            else {
+                console.log('\n🚀 Starting the application and FeltDB Studio...\n');
+                await run(npm, ['run', 'dev'], projectDir);
+            }
+        }
+        else {
+            console.log('Project is ready. Start everything with:');
+            console.log(`  cd ${projectName}`);
+            if (!shouldInstall)
+                console.log('  npm install');
+            console.log('  npm run dev');
+        }
+    }
+    catch (error) {
+        console.error('❌ Failed to create project:', error);
+        process.exit(1);
+    }
+}
+main();