@feltdb/core 0.4.4 → 0.4.6

package/dist/create/create.js

@@ -0,0 +1,638 @@
+/**
+ * Project creation logic
+ */
+import fs from 'fs';
+import path from 'path';
+import { feltdbPackageRange } from './package-versions.js';
+export async function createProject(options) {
+    const { projectName, templatesDir } = options;
+    const projectDir = path.resolve(process.cwd(), projectName);
+    const applicationName = path.basename(projectDir);
+    // Create project directory
+    if (!fs.existsSync(projectDir)) {
+        fs.mkdirSync(projectDir, { recursive: true });
+    }
+    // Create feltdb directory structure
+    const feltdbDir = path.join(projectDir, 'feltdb');
+    const srcDir = path.join(projectDir, 'src');
+    const publicDir = path.join(projectDir, 'public');
+    const feltdbConfigDir = path.join(projectDir, '.feltdb');
+    fs.mkdirSync(path.join(feltdbDir, 'capabilities'), { recursive: true });
+    fs.mkdirSync(path.join(feltdbDir, 'workflows'), { recursive: true });
+    fs.mkdirSync(path.join(feltdbDir, 'agents'), { recursive: true });
+    fs.mkdirSync(path.join(feltdbDir, 'schema'), { recursive: true });
+    fs.mkdirSync(srcDir, { recursive: true });
+    fs.mkdirSync(publicDir, { recursive: true });
+    fs.mkdirSync(feltdbConfigDir, { recursive: true });
+    const runtime = options.runtime || 'browser';
+    const framework = options.framework || 'react';
+    const distributed = options.distributed !== false;
+    const hasAgents = options.agents !== false;
+    const capabilities = options.capabilities || 'search';
+    // Create package.json
+    const packageJson = {
+        name: applicationName,
+        version: '0.1.0',
+        description: `A FeltDB application`,
+        main: 'src/index.ts',
+        type: 'module',
+        scripts: {
+            dev: 'feltdb dev',
+            build: 'feltdb build',
+            test: 'node --test',
+            feltdb: 'feltdb',
+            'feltdb:server': 'feltdb server',
+            'feltdb:connect': 'feltdb connect http://localhost:7700',
+            'feltdb:status': 'feltdb status',
+            'feltdb:studio': 'feltdb studio',
+            'feltdb:validate': 'feltdb validate',
+            'feltdb:diff': 'feltdb diff',
+            'feltdb:deploy': 'feltdb deploy',
+        },
+        dependencies: {
+            '@feltdb/core': feltdbPackageRange,
+        },
+        devDependencies: {
+            typescript: '^5.0.0',
+            '@types/node': '^20.0.0',
+            vite: '^8.2.1',
+        },
+    };
+    if (framework === 'react') {
+        packageJson.dependencies['react'] = '^18.0.0';
+        packageJson.dependencies['react-dom'] = '^18.0.0';
+        packageJson.devDependencies['@types/react'] = '^18.0.0';
+        packageJson.devDependencies['@types/react-dom'] = '^18.0.0';
+    }
+    if (hasAgents) {
+        packageJson.dependencies['@feltdb/webllm'] = feltdbPackageRange;
+    }
+    fs.writeFileSync(path.join(projectDir, 'package.json'), JSON.stringify(packageJson, null, 2));
+    // Create feltdb.config.json
+    const feltdbConfig = {
+        namespace: applicationName,
+        runtime,
+        storage: runtime === 'browser' ? 'opfs' : 'durable',
+        distributed,
+        agents: {
+            enabled: hasAgents,
+        },
+        capabilities: {},
+    };
+    if (capabilities.includes('search')) {
+        feltdbConfig.capabilities.search = true;
+    }
+    if (capabilities.includes('vector')) {
+        feltdbConfig.capabilities['vector-search'] = true;
+    }
+    fs.writeFileSync(path.join(projectDir, 'feltdb.config.json'), JSON.stringify(feltdbConfig, null, 2));
+    const appName = applicationName.replace(/[^A-Za-z0-9_]/g, '_').replace(/^[^A-Za-z_]/, 'App_');
+    const flowSpec = `app ${appName} {
+  collection Document {
+    title: text
+    content: text
+    createdAt: datetime
+    index search using fulltext(content)
+  }
+
+  collection Report {
+    title: text
+    content: text
+    document: ref Document
+  }
+
+  capability Research {
+    read Document
+    write Report
+  }
+
+  agent Researcher {
+    capability Research
+    workflow ResearchDocument
+  }
+
+  workflow ResearchDocument(document: Document) {
+    step search {
+      input document.content
+    }
+    step identity {
+      input search.output
+    }
+  }
+
+  trigger on Document.created {
+    workflow ResearchDocument(document)
+  }
+
+  policy Document {
+    read: authenticated
+    write: authenticated
+  }
+}
+`;
+    fs.writeFileSync(path.join(projectDir, 'feltdb.flow'), flowSpec);
+    // Create tsconfig.json
+    const tsconfig = {
+        compilerOptions: {
+            target: 'ES2020',
+            module: 'ESNext',
+            lib: ['ES2020', 'DOM'],
+            declaration: true,
+            outDir: './dist',
+            rootDir: './src',
+            strict: true,
+            esModuleInterop: true,
+            skipLibCheck: true,
+            forceConsistentCasingInFileNames: true,
+            moduleResolution: 'node',
+        },
+        include: ['src/**/*'],
+        exclude: ['node_modules'],
+    };
+    if (framework === 'react') {
+        tsconfig.compilerOptions.jsx = 'react-jsx';
+    }
+    fs.writeFileSync(path.join(projectDir, 'tsconfig.json'), JSON.stringify(tsconfig, null, 2));
+    // Create main application files
+    const runtimeOptions = runtime === 'browser'
+        ? "{ namespace: '" + applicationName + "', browser: true }"
+        : runtime === 'self-hosted'
+            ? "{ namespace: '" + applicationName + "', server: { url: import.meta.env.VITE_FELTDB_URL || 'http://localhost:7700', token: import.meta.env.VITE_FELTDB_API_KEY || '' } }"
+            : "{ namespace: '" + applicationName + "', memory: true }";
+    const feltdbTs = `import { createFeltDB } from '@feltdb/core';
+
+export const db = createFeltDB(${runtimeOptions});
+
+// Collections
+export const documents = db.collection('documents');
+export const reports = db.collection('reports');
+`;
+    fs.writeFileSync(path.join(srcDir, 'feltdb.ts'), feltdbTs);
+    // Create a real local-inference agent for browser projects.
+    if (hasAgents) {
+        const agentTs = `import { WebLLMProvider } from '@feltdb/webllm';
+import { db, reports } from '../../src/feltdb';
+
+/**
+ * Researcher metadata is registered in FeltDB; inference runs privately in
+ * the browser through WebLLM and its worker.
+ */
+export const researcher = db.defineAgent({
+  name: 'researcher',
+  version: 1,
+  description: 'Analyze documents with private, on-device inference',
+  capabilities: [
+    'document-read',
+    'report-write'
+  ],
+  goals: ['Summarize documents without sending prompts off-device'],
+  constraints: { maxIterations: 1 },
+});
+
+let provider: WebLLMProvider | undefined;
+
+export async function runResearcher(
+  prompt: string,
+  onProgress?: (message: string) => void,
+) {
+  provider ??= new WebLLMProvider({
+    onProgress: ({ progress, text }) =>
+      onProgress?.(\`${'${Math.round(progress * 100)}'}% ${'${text}'}\`),
+  });
+  const content = await provider.generate([
+    { role: 'system', content: 'You are a concise research assistant. Keep all reasoning local.' },
+    { role: 'user', content: prompt },
+  ]);
+  await reports.insert({
+    title: prompt.slice(0, 80) || 'Local research',
+    content,
+    createdAt: new Date(),
+  });
+  return content;
+}
+`;
+        fs.writeFileSync(path.join(feltdbDir, 'agents', 'researcher.ts'), agentTs);
+    }
+    // Create capabilities index
+    const capabilitiesTs = `/**
+ * Capabilities
+ *
+ * Define capabilities that can be executed by agents
+ * across distributed peers
+ */
+
+export const capabilities = {
+  'document-read': {
+    enabled: true,
+    scope: ['documents:read'],
+  },
+  'vector-search': {
+    enabled: ${capabilities.includes('vector')},
+    scope: ['documents:read', 'capabilities:execute'],
+  },
+  'report-write': {
+    enabled: true,
+    scope: ['reports:write'],
+  },
+};
+`;
+    fs.writeFileSync(path.join(feltdbDir, 'capabilities', 'index.ts'), capabilitiesTs);
+    // Create main application file based on framework
+    if (framework === 'react') {
+        const agentImport = hasAgents
+            ? "import { runResearcher } from '../feltdb/agents/researcher';"
+            : '';
+        const agentState = hasAgents
+            ? `  const [prompt, setPrompt] = useState('Summarize why local-first applications are useful.');
+  const [answer, setAnswer] = useState('');
+  const [modelStatus, setModelStatus] = useState('Model not loaded');
+  const [generating, setGenerating] = useState(false);`
+            : '';
+        const agentHandler = hasAgents
+            ? `
+  const handleResearch = async () => {
+    setGenerating(true);
+    setAnswer('');
+    try {
+      setAnswer(await runResearcher(prompt, setModelStatus));
+      setModelStatus('Ready — inference stayed in this browser');
+    } catch (error) {
+      setModelStatus(error instanceof Error ? error.message : String(error));
+    } finally {
+      setGenerating(false);
+    }
+  };
+`
+            : '';
+        const agentMarkup = hasAgents
+            ? `
+        <section className="researcher">
+          <h2>Private WebLLM Researcher</h2>
+          <p>{modelStatus}</p>
+          <textarea value={prompt} onChange={event => setPrompt(event.target.value)} rows={4} />
+          <button onClick={handleResearch} disabled={generating || !prompt.trim()}>
+            {generating ? 'Running locally…' : 'Run researcher'}
+          </button>
+          {answer && <article><h3>Result</h3><p>{answer}</p></article>}
+        </section>`
+            : '';
+        const appTsx = `import React, { useState, useEffect } from 'react';
+import { db, documents } from './feltdb';
+${agentImport}
+
+export function App() {
+  const [docs, setDocs] = useState<any[]>([]);
+  const [loading, setLoading] = useState(true);
+${agentState}
+
+  useEffect(() => {
+    const loadDocs = async () => {
+      try {
+        const allDocs = await documents.find({});
+        setDocs(allDocs);
+      } catch (err) {
+        console.error('Error loading documents:', err);
+      } finally {
+        setLoading(false);
+      }
+    };
+
+    loadDocs();
+  }, []);
+
+  const handleAddDocument = async () => {
+    try {
+      await documents.insert({
+        title: 'New Document',
+        content: 'Enter content here',
+        createdAt: new Date(),
+      });
+      // Reload documents
+      const allDocs = await documents.find({});
+      setDocs(allDocs);
+    } catch (err) {
+      console.error('Error adding document:', err);
+    }
+  };
+${agentHandler}
+
+  return (
+    <div className="app">
+      <header>
+        <h1>🌊 FeltDB Research App</h1>
+        <p>Distributed document management with agents and capabilities</p>
+      </header>
+
+      <main>
+        <section className="stats">
+          <div className="stat">
+            <span className="label">Documents:</span>
+            <span className="value">{docs.length}</span>
+          </div>
+          <div className="stat">
+            <span className="label">Runtime:</span>
+            <span className="value">${runtime}</span>
+          </div>
+          <div className="stat">
+            <span className="label">Distributed:</span>
+            <span className="value">${distributed ? '✓' : '✗'}</span>
+          </div>
+        </section>
+
+        <section className="documents">
+          <h2>Documents</h2>
+          {loading ? (
+            <p>Loading...</p>
+          ) : docs.length === 0 ? (
+            <p>No documents yet</p>
+          ) : (
+            <ul>
+              {docs.map((doc: any) => (
+                <li key={doc.id}>
+                  <h3>{doc.title}</h3>
+                  <p>{doc.content}</p>
+                </li>
+              ))}
+            </ul>
+          )}
+          <button onClick={handleAddDocument}>Add Document</button>
+        </section>
+${agentMarkup}
+      </main>
+
+      <style>{\`
+        body {
+          font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto;
+          margin: 0;
+          padding: 0;
+          background: #f5f5f5;
+        }
+
+        .app {
+          max-width: 1200px;
+          margin: 0 auto;
+          padding: 20px;
+        }
+
+        header {
+          background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+          color: white;
+          padding: 30px;
+          border-radius: 8px;
+          margin-bottom: 30px;
+        }
+
+        header h1 {
+          margin: 0 0 10px 0;
+          font-size: 28px;
+        }
+
+        header p {
+          margin: 0;
+          opacity: 0.9;
+        }
+
+        main {
+          background: white;
+          padding: 20px;
+          border-radius: 8px;
+          box-shadow: 0 2px 8px rgba(0,0,0,0.1);
+        }
+
+        .stats {
+          display: grid;
+          grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+          gap: 20px;
+          margin-bottom: 30px;
+        }
+
+        .stat {
+          padding: 15px;
+          background: #f9f9f9;
+          border-radius: 4px;
+          border-left: 3px solid #667eea;
+        }
+
+        .stat .label {
+          display: block;
+          color: #666;
+          font-size: 12px;
+          text-transform: uppercase;
+          margin-bottom: 5px;
+        }
+
+        .stat .value {
+          display: block;
+          font-size: 24px;
+          font-weight: bold;
+          color: #333;
+        }
+
+        .documents h2 {
+          margin-top: 0;
+        }
+
+        .documents ul {
+          list-style: none;
+          padding: 0;
+          margin: 0 0 20px 0;
+        }
+
+        .documents li {
+          padding: 15px;
+          background: #f9f9f9;
+          border-radius: 4px;
+          margin-bottom: 10px;
+        }
+
+        .documents h3 {
+          margin: 0 0 10px 0;
+          color: #333;
+        }
+
+        .documents p {
+          margin: 0;
+          color: #666;
+          font-size: 14px;
+        }
+
+        button {
+          background: #667eea;
+          color: white;
+          border: none;
+          padding: 10px 20px;
+          border-radius: 4px;
+          cursor: pointer;
+          font-size: 14px;
+          font-weight: 500;
+        }
+
+        button:hover {
+          background: #5568d3;
+        }
+
+        textarea {
+          box-sizing: border-box;
+          display: block;
+          margin: 12px 0;
+          padding: 10px;
+          width: 100%;
+        }
+
+        .researcher {
+          border-top: 1px solid #eee;
+          margin-top: 30px;
+          padding-top: 20px;
+        }
+      \`}</style>
+    </div>
+  );
+}
+`;
+        fs.writeFileSync(path.join(srcDir, 'App.tsx'), appTsx);
+        const indexTsx = `import React from 'react';
+import ReactDOM from 'react-dom/client';
+import { App } from './App';
+
+const root = ReactDOM.createRoot(document.getElementById('root')!);
+root.render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>
+);
+`;
+        fs.writeFileSync(path.join(srcDir, 'index.tsx'), indexTsx);
+    }
+    else {
+        // Create vanilla JS app
+        const indexJs = `import { db, documents } from './feltdb';
+
+async function main() {
+  console.log('🌊 FeltDB Research App');
+  console.log('Runtime: ${runtime}');
+  console.log('Distributed: ${distributed}');
+}
+
+main().catch(console.error);
+`;
+        fs.writeFileSync(path.join(srcDir, 'index.js'), indexJs);
+    }
+    // Create index.html
+    const indexHtml = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${applicationName}</title>
+</head>
+<body>
+  <div id="root"></div>
+  <script type="module" src="/src/index${framework === 'react' ? '.tsx' : '.js'}"></script>
+</body>
+</html>
+`;
+    fs.writeFileSync(path.join(projectDir, 'index.html'), indexHtml);
+    // Create .env.example
+    const envExample = `# FeltDB Configuration
+VITE_FELTDB_API_KEY=
+VITE_FELTDB_URL=http://localhost:7700
+# Override the versioned self-hosted container when needed:
+FELTDB_IMAGE=
+NODE_ENV=development
+`;
+    fs.writeFileSync(path.join(projectDir, '.env.example'), envExample);
+    // Create .gitignore
+    const gitignore = `node_modules/
+dist/
+build/
+.env
+.env.local
+.env.*.local
+*.log
+.DS_Store
+.feltdb/keys.json
+.feltdb/connection.json
+`;
+    fs.writeFileSync(path.join(projectDir, '.gitignore'), gitignore);
+    // Create README
+    const readme = `# ${applicationName}
+
+A FeltDB distributed application with agents and capabilities.
+
+## Quick Start
+
+\`\`\`bash
+npm install
+npm run dev
+\`\`\`
+
+## Project Structure
+
+\`\`\`
+${applicationName}/
+├── feltdb/
+│   ├── agents/            # Agent definitions
+│   ├── capabilities/      # Capability implementations
+│   ├── workflows/         # Workflow definitions
+│   └── schema/            # Data schemas
+├── src/
+│   ├── App.${framework === 'react' ? 'tsx' : 'js'}
+│   ├── feltdb.ts
+│   └── index.${framework === 'react' ? 'tsx' : 'js'}
+├── public/
+├── index.html
+├── .feltdb/               # Local FeltDB configuration
+├── feltdb.config.json
+├── .env.example
+├── package.json
+├── tsconfig.json
+└── README.md
+\`\`\`
+
+## Configuration
+
+Configuration is in \`feltdb.config.json\`:
+- \`runtime\`: ${runtime} (browser|node|self-hosted)
+- \`storage\`: ${runtime === 'browser' ? 'opfs' : 'durable'}
+- \`distributed\`: ${distributed}
+- \`agents.enabled\`: ${hasAgents}
+- \`capabilities\`: ${capabilities}
+
+## Development
+
+### Start Development Server
+\`\`\`bash
+npm run dev
+\`\`\`
+
+### Build for Production
+\`\`\`bash
+npm run build
+\`\`\`
+
+### Connect to Remote Server
+\`\`\`bash
+feltdb connect http://localhost:7700
+\`\`\`
+
+### Create API Key
+\`\`\`bash
+feltdb keys create --name development --scope '*'
+\`\`\`
+
+## Agents
+
+${hasAgents ? `The \`researcher\` agent runs real private inference with
+\`@feltdb/webllm\`. The model downloads on first use, runs in a Web Worker, and
+caches its artifacts in the browser. Generated reports are stored in FeltDB.` : 'No agents configured'}
+
+## Capabilities
+
+${capabilities}
+
+## Learn More
+
+Visit [FeltDB Documentation](https://github.com/rkendel1/feltdb) to learn more.
+`;
+    fs.writeFileSync(path.join(projectDir, 'README.md'), readme);
+}