lemmafit 0.0.1 → 0.2.0

package/cli/lemmafit.js

@@ -0,0 +1,385 @@
+#!/usr/bin/env node
+/**
+ * Lemmafit CLI - Verified vibe coding with Claude Code
+ *
+ * Commands:
+ *   lemmafit init [dir]                   - Initialize a new lemmafit project (blank)
+ *   lemmafit init --template <name> [dir] - Initialize from a named template
+ *   lemmafit init --server <url|none> [dir] - Use a custom server (default: none)
+ *   lemmafit add [Name]                   - Add a verified module (or just bootstrap infrastructure)
+ *   lemmafit add <Name> --null-options    - Add with Option<T> → T | null mapping
+ *   lemmafit add <Name> --no-json-api     - Add without JSON marshalling
+ *   lemmafit add <Name> --target <target> - Set compilation target (client|node|inline|deno|cloudflare)
+ *   lemmafit sync [dir]     - Sync system files from current package version
+ *   lemmafit daemon [dir]   - Run the verification daemon
+ *   lemmafit logs [dir]     - View the dev log
+ *   lemmafit logs --clear [dir] - Clear the dev log
+ *   lemmafit dashboard [dir] - Open the dashboard in a browser
+ */
+
+const path = require('path');
+const fs = require('fs');
+const crypto = require('crypto');
+
+const TEMPLATES_BASE = path.join(__dirname, '..');
+const DEFAULT_TEMPLATE = 'blank-template';
+const DEFAULT_SERVER = 'none';
+
+function resolveTemplate(name) {
+  const templateDir = path.join(TEMPLATES_BASE, name);
+  if (!fs.existsSync(templateDir)) {
+    const available = fs.readdirSync(TEMPLATES_BASE)
+      .filter(f => f.endsWith('-template') && fs.statSync(path.join(TEMPLATES_BASE, f)).isDirectory());
+    console.error(`Error: Unknown template '${name}'`);
+    console.error(`Available templates: ${available.join(', ')}`);
+    process.exit(1);
+  }
+  return templateDir;
+}
+
+function copyDir(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path.join(src, entry.name);
+    const destName = entry.name === 'template.gitignore' ? '.gitignore' : entry.name;
+    const destPath = path.join(dest, destName);
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+function syncProject(targetDir) {
+  const absTarget = path.resolve(targetDir);
+  const { syncProject: sync } = require('./sync');
+  sync(absTarget);
+}
+
+function initProject(targetDir, templateName, serverBase) {
+  const absTarget = path.resolve(targetDir);
+  const templateDir = resolveTemplate(templateName);
+
+  const ignorable = new Set(['.git', '.DS_Store']);
+  if (fs.existsSync(absTarget) && fs.readdirSync(absTarget).some(f => !ignorable.has(f))) {
+    console.error(`Error: Directory '${absTarget}' is not empty`);
+    process.exit(1);
+  }
+
+  console.log(`Creating lemmafit project at ${absTarget} (template: ${templateName})...`);
+
+  // Copy template (user-owned files only)
+  copyDir(templateDir, absTarget);
+
+  // Rewrite lemmafit dependency to point to local package
+  const pkgJsonPath = path.join(absTarget, 'package.json');
+  if (fs.existsSync(pkgJsonPath)) {
+    const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf8'));
+    if (pkg.dependencies && pkg.dependencies.lemmafit) {
+      const lemmaPackageDir = path.resolve(__dirname, '..');
+      const relPath = path.relative(absTarget, lemmaPackageDir);
+      pkg.dependencies.lemmafit = `file:${relPath}`;
+      fs.writeFileSync(pkgJsonPath, JSON.stringify(pkg, null, 2) + '\n');
+    }
+  }
+
+  // Sync system files (.claude/settings.json, .claude/CLAUDE.md)
+  syncProject(absTarget);
+
+  // Generate per-project secret and server URL, write into .vibe/config.json
+  const secret = 'lf_sk_' + crypto.randomBytes(32).toString('hex');
+  const projectName = path.basename(absTarget);
+  const vibeDir = path.join(absTarget, 'lemmafit', '.vibe');
+  const configPath = path.join(vibeDir, 'config.json');
+  fs.mkdirSync(vibeDir, { recursive: true });
+  let config = {};
+  if (fs.existsSync(configPath)) {
+    try { config = JSON.parse(fs.readFileSync(configPath, 'utf8')); } catch {}
+  }
+  config.secret = secret;
+  if (serverBase.toLowerCase() !== 'none') {
+    const serverWsUrl = `${serverBase}/ws?project=${encodeURIComponent(projectName)}`;
+    config.server = serverWsUrl;
+  }
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+
+  console.log('Done! Next steps:');
+  console.log('');
+  console.log(`  cd ${targetDir}`);
+  console.log('  npm install          # Downloads Dafny, installs deps, syncs hooks');
+  console.log('  npm run daemon       # In one terminal, start the verification daemon');
+  console.log('  npm run dev          # In another terminal, start the Vite dev server');
+  if (serverBase.toLowerCase() !== 'none') {
+    console.log('  lemmafit dashboard   # Open the dashboard');
+  }
+  console.log('');
+  if (serverBase.toLowerCase() !== 'none') {
+    console.log(`Server: ${serverBase}`);
+  }
+  console.log('Then open Claude Code in the project directory.');
+  console.log('');
+}
+
+function addModule(targetDir, moduleName, options = {}) {
+  const absTarget = path.resolve(targetDir);
+
+  const lemmafitDir = path.join(absTarget, 'lemmafit');
+  const vibeDir = path.join(lemmafitDir, '.vibe');
+  const dafnyDir = path.join(lemmafitDir, 'dafny');
+  const configPath = path.join(vibeDir, 'config.json');
+  const modulesPath = path.join(vibeDir, 'modules.json');
+  const isFirstRun = !fs.existsSync(lemmafitDir);
+
+  // First run: bootstrap lemmafit infrastructure
+  if (isFirstRun) {
+    console.log('First lemmafit module — bootstrapping infrastructure...');
+    fs.mkdirSync(dafnyDir, { recursive: true });
+    fs.mkdirSync(vibeDir, { recursive: true });
+
+    // Minimal config (no entry/appCore since we use modules.json)
+    fs.writeFileSync(configPath, JSON.stringify({}, null, 2) + '\n');
+
+    // Empty modules array
+    fs.writeFileSync(modulesPath, JSON.stringify([], null, 2) + '\n');
+
+    // Sync .claude/ system files
+    syncProject(absTarget);
+
+    // Add lemmafit as devDependency and daemon script to package.json
+    // Create a minimal package.json if one doesn't exist
+    const pkgJsonPath = path.join(absTarget, 'package.json');
+    if (!fs.existsSync(pkgJsonPath)) {
+      const dirName = path.basename(absTarget);
+      fs.writeFileSync(pkgJsonPath, JSON.stringify({
+        name: dirName,
+        private: true
+      }, null, 2) + '\n');
+      console.log('  Created package.json');
+    }
+    const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf8'));
+    if (!pkg.devDependencies) pkg.devDependencies = {};
+    if (!pkg.devDependencies.lemmafit && !(pkg.dependencies && pkg.dependencies.lemmafit)) {
+      const lemmaPackageDir = path.resolve(__dirname, '..');
+      const relPath = path.relative(absTarget, lemmaPackageDir);
+      pkg.devDependencies.lemmafit = `file:${relPath}`;
+    }
+    if (!pkg.scripts) pkg.scripts = {};
+    if (!pkg.scripts.daemon) {
+      pkg.scripts.daemon = 'lemmafit daemon';
+    }
+    fs.writeFileSync(pkgJsonPath, JSON.stringify(pkg, null, 2) + '\n');
+
+    console.log('  Created lemmafit/dafny/');
+    console.log('  Created lemmafit/.vibe/config.json');
+    console.log('  Created lemmafit/.vibe/modules.json');
+    console.log('  Synced .claude/ system files');
+    console.log('');
+  }
+
+  if (!moduleName) return;
+
+  // Load existing modules
+  let modules = [];
+  if (fs.existsSync(modulesPath)) {
+    try { modules = JSON.parse(fs.readFileSync(modulesPath, 'utf8')); } catch {}
+  }
+
+  // Check for duplicate
+  if (modules.some(m => m.outputName === moduleName)) {
+    console.error(`Error: Module '${moduleName}' already exists in modules.json`);
+    process.exit(1);
+  }
+
+  // Scaffold the Dafny file
+  const dafnyFile = path.join(dafnyDir, `${moduleName}.dfy`);
+  if (fs.existsSync(dafnyFile)) {
+    console.error(`Error: ${path.relative(absTarget, dafnyFile)} already exists`);
+    process.exit(1);
+  }
+
+  const dafnyContent = `module ${moduleName} {
+  // Your verified logic here
+}
+`;
+  fs.mkdirSync(dafnyDir, { recursive: true });
+  fs.writeFileSync(dafnyFile, dafnyContent);
+
+  // Add entry to modules.json
+  const moduleEntry = {
+    entry: `lemmafit/dafny/${moduleName}.dfy`,
+    appCore: moduleName,
+    outputName: moduleName,
+    jsonApi: options.jsonApi !== false,
+    nullOptions: options.nullOptions || false
+  };
+  if (options.target) moduleEntry.target = options.target;
+  modules.push(moduleEntry);
+  fs.writeFileSync(modulesPath, JSON.stringify(modules, null, 2) + '\n');
+
+  // Print results
+  console.log(`  Created lemmafit/dafny/${moduleName}.dfy`);
+  console.log(`  Added to lemmafit/.vibe/modules.json`);
+  console.log('');
+  console.log(`  Next: write your verified logic in ${moduleName}.dfy`);
+  console.log(`  The daemon will compile it to src/dafny/${moduleName}.ts`);
+  console.log(`  Import with: import ${moduleName} from './src/dafny/${moduleName}.ts'`);
+  console.log('');
+  if (modules.length > 1) {
+    console.log(`  Modules: ${modules.map(m => m.outputName).join(', ')}`);
+    console.log('');
+  }
+}
+
+function showLogs(targetDir, clear) {
+  const absTarget = path.resolve(targetDir);
+  const logPath = path.join(absTarget, 'lemmafit', 'logs', 'lemmafit.log');
+
+  if (clear) {
+    try {
+      fs.unlinkSync(logPath);
+      console.log('Cleared lemmafit/logs/lemmafit.log');
+    } catch {
+      console.log('No log file to clear.');
+    }
+    return;
+  }
+
+  try {
+    const contents = fs.readFileSync(logPath, 'utf8');
+    process.stdout.write(contents);
+  } catch {
+    console.log('No log file found. Logs will appear after hooks run.');
+  }
+}
+
+function openDashboard(targetDir) {
+  const absTarget = path.resolve(targetDir);
+  const configPath = path.join(absTarget, 'lemmafit', '.vibe', 'config.json');
+
+  if (!fs.existsSync(configPath)) {
+    console.error('Error: No lemmafit config found. Run "lemmafit init" first.');
+    process.exit(1);
+  }
+
+  let config;
+  try {
+    config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  } catch {
+    console.error('Error: Could not read lemmafit/.vibe/config.json');
+    process.exit(1);
+  }
+
+  if (!config.server) {
+    console.error('Error: No "server" field in config. Add a server URL to lemmafit/.vibe/config.json');
+    process.exit(1);
+  }
+
+  // Derive HTTP dashboard URL from the WS server URL
+  // e.g. ws://localhost:8787/ws?project=foo -> http://localhost:8787/
+  // No secret in URL — user authenticates via Supabase in the browser
+  const wsUrl = new URL(config.server);
+  const dashboardUrl = new URL(`${wsUrl.protocol === 'wss:' ? 'https' : 'http'}://${wsUrl.host}/`);
+
+  const project = wsUrl.searchParams.get('project') || 'default';
+  dashboardUrl.hash = `project=${encodeURIComponent(project)}`;
+
+  const url = dashboardUrl.toString();
+  console.log(`Opening dashboard: ${url}`);
+  console.log('');
+  console.log('To register this project, use these credentials:');
+  console.log(`  Project: ${project}`);
+  console.log(`  Secret:  ${config.secret}`);
+  console.log('');
+
+  // Open in default browser
+  const { spawn } = require('child_process');
+  const openCmd = process.platform === 'darwin' ? 'open'
+    : process.platform === 'win32' ? 'start'
+    : 'xdg-open';
+  spawn(openCmd, [url]);
+}
+
+function runDaemon(targetDir) {
+  const absTarget = path.resolve(targetDir);
+  const { Daemon } = require('../lib/daemon');
+  const daemon = new Daemon(absTarget);
+  daemon.watch();
+}
+
+// Parse arguments
+const args = process.argv.slice(2);
+const command = args[0];
+const clearFlag = args.includes('--clear');
+const nullOptionsFlag = args.includes('--null-options');
+const noJsonApiFlag = args.includes('--no-json-api');
+const targetIdx = args.indexOf('--target');
+const targetFlag = targetIdx !== -1 ? args[targetIdx + 1] : null;
+const templateIdx = args.indexOf('--template');
+const templateName = templateIdx !== -1 ? args[templateIdx + 1] : DEFAULT_TEMPLATE;
+const serverIdx = args.indexOf('--server');
+const serverBase = serverIdx !== -1 ? args[serverIdx + 1] : DEFAULT_SERVER;
+const positionalArgs = args.filter((a, i) =>
+  a !== '--clear' && a !== '--template' && a !== '--server' &&
+  a !== '--null-options' && a !== '--no-json-api' && a !== '--target' &&
+  (targetIdx === -1 || i !== targetIdx + 1) &&
+  (templateIdx === -1 || i !== templateIdx + 1) &&
+  (serverIdx === -1 || i !== serverIdx + 1)
+).slice(1);
+let addModuleName = null;
+let target;
+if (command === 'add') {
+  addModuleName = positionalArgs[0] || null;
+  target = '.';
+} else {
+  target = positionalArgs[0] || '.';
+}
+
+switch (command) {
+  case 'init':
+    initProject(target, templateName, serverBase);
+    break;
+  case 'add':
+    addModule(target, addModuleName, {
+      jsonApi: !noJsonApiFlag,
+      nullOptions: nullOptionsFlag,
+      target: targetFlag
+    });
+    break;
+  case 'sync':
+    syncProject(target);
+    break;
+  case 'daemon':
+    runDaemon(target);
+    break;
+  case 'dashboard':
+    openDashboard(target);
+    break;
+  case 'logs':
+    showLogs(target, clearFlag);
+    break;
+  case undefined:
+  case '--help':
+  case '-h':
+    console.log('Lemmafit - Verified vibe coding with Claude Code');
+    console.log('');
+    console.log('Usage:');
+    console.log('  lemmafit init [dir]                   - Create a new project (blank template)');
+    console.log('  lemmafit init --template <name> [dir] - Create from a named template');
+    console.log('  lemmafit init --server <url> [dir]    - Use a custom server (default: none)');
+    console.log('  lemmafit add [Name]                    - Add a verified module (or just bootstrap infrastructure)');
+    console.log('  lemmafit add <Name> --null-options     - Add with Option<T> → T | null mapping');
+    console.log('  lemmafit add <Name> --no-json-api      - Add without JSON marshalling');
+    console.log('  lemmafit add <Name> --target <target>  - Set compilation target (client|node|inline|deno|cloudflare)');
+    console.log('  lemmafit sync [dir]          - Sync system files from package');
+    console.log('  lemmafit daemon [dir]        - Run the verification daemon');
+    console.log('  lemmafit dashboard [dir]     - Open the dashboard in a browser');
+    console.log('  lemmafit logs [dir]          - View the dev log');
+    console.log('  lemmafit logs --clear [dir]  - Clear the dev log');
+    console.log('');
+    break;
+  default:
+    console.error(`Unknown command: ${command}`);
+    console.error('Run "lemmafit --help" for usage');
+    process.exit(1);
+}

package/cli/session-hook.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+/**
+ * Claude Code SessionStart hook for lemmafit.
+ *
+ * Fires once at the start of each session. Tells Claude to read
+ * the lemmafit instructions file from the installed package.
+ *
+ * Hook receives JSON on stdin with { "cwd": "..." }
+ */
+
+const path = require('path');
+const fs = require('fs');
+const { initLog, log } = require('../lib/log');
+
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString('utf8');
+}
+
+function findProjectRoot(dir) {
+  let current = dir;
+  while (current !== path.dirname(current)) {
+    if (fs.existsSync(path.join(current, 'lemmafit'))) {
+      return current;
+    }
+    current = path.dirname(current);
+  }
+  return null;
+}
+
+async function main() {
+  const input = await readStdin();
+
+  let hookData;
+  try {
+    hookData = JSON.parse(input);
+  } catch {
+    process.exit(0);
+  }
+
+  const cwd = hookData.cwd;
+  if (!cwd) {
+    process.exit(0);
+  }
+
+  const projectDir = findProjectRoot(cwd);
+  if (!projectDir) {
+    process.exit(0);
+  }
+
+  initLog(projectDir);
+  log('session', 'Session started');
+
+  const instructionsPath = path.join(projectDir, 'node_modules', 'lemmafit', 'docs', 'CLAUDE_INSTRUCTIONS.md');
+  if (fs.existsSync(instructionsPath)) {
+    log('session', `Injecting instructions from ${instructionsPath}`);
+    const context = `<lemmafit-instructions>\nRead and follow the project instructions at: ${instructionsPath}\n</lemmafit-instructions>`;
+    console.log(JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: 'SessionStart',
+        additionalContext: context
+      }
+    }));
+  } else {
+    log('session', 'Instructions file not found (node_modules/lemmafit not installed?)');
+  }
+}
+
+main().catch(() => {
+  process.exit(0);
+});

package/cli/sync.js

@@ -0,0 +1,168 @@
+#!/usr/bin/env node
+/**
+ * Lemmafit sync - writes system-owned files into a lemmafit project.
+ *
+ * Runs automatically as postinstall when lemmafit is installed/updated.
+ * Also available as `lemmafit sync [dir]`.
+ *
+ * System files written:
+ *   .claude/settings.json  - Claude Code hook configuration
+ *   .claude/CLAUDE.md      - Pointer to package instructions (append-safe)
+ */
+
+const path = require('path');
+const fs = require('fs');
+const { initLog, log } = require('../lib/log');
+
+const POINTER_LINE = 
+`============================== LEMMAFIT SYSTEM PROMPT - DO NOT EDIT ====================================
+This project uses lemmafit to formally verify logic. 
+You MUST read the lemmafit project instructions at node_modules/lemmafit/docs/CLAUDE_INSTRUCTIONS.md before writing any code. 
+===============================================================================================
+`;
+
+const SETTINGS = {
+  permissions: {
+    allow: [
+      // Lemmafit project files Claude needs to read/write without prompting
+      "Read(SPEC.yaml)",
+      "Read(lemmafit/**)",
+      "Read(src/dafny/**)",
+      "Read(node_modules/lemmafit/docs/**)",
+      "Edit(SPEC.yaml)",
+      "Edit(lemmafit/dafny/*.dfy)",
+      "Write(SPEC.yaml)",
+      "Write(lemmafit/dafny/*.dfy)",
+      // Common build/dev commands
+      "Bash(npm run build:*)",
+      "Bash(npm run dev:*)",
+      "Bash(npx tsc:*)"
+    ]
+  },
+  hooks: {
+    PostToolUse: [
+      {
+        matcher: "Write|Edit",
+        hooks: [
+          { type: "command", command: "lemmafit-verify-hook" }
+        ]
+      }
+    ],
+    UserPromptSubmit: [
+      {
+        hooks: [
+          { type: "command", command: "lemmafit-context-hook" }
+        ]
+      }
+    ],
+    SessionStart: [
+      {
+        hooks: [
+          { type: "command", command: "lemmafit-session-hook" }
+        ]
+      }
+    ]
+  }
+};
+
+function findProjectRoot() {
+  // When run as postinstall, CWD is inside node_modules/lemmafit.
+  // Walk up to find the project root (has package.json but is not this package).
+  let dir = process.cwd();
+  while (dir !== path.dirname(dir)) {
+    const pkgPath = path.join(dir, 'package.json');
+    if (fs.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+        if (pkg.name !== 'lemmafit') {
+          return dir;
+        }
+      } catch {}
+    }
+    dir = path.dirname(dir);
+  }
+  return null;
+}
+
+function syncProject(targetDir) {
+  const absTarget = path.resolve(targetDir);
+
+  initLog(absTarget);
+  log('sync', 'Starting sync');
+
+  // Write .claude/settings.json
+  const claudeDir = path.join(absTarget, '.claude');
+  fs.mkdirSync(claudeDir, { recursive: true });
+
+  fs.writeFileSync(
+    path.join(claudeDir, 'settings.json'),
+    JSON.stringify(SETTINGS, null, 2) + '\n'
+  );
+
+  // Write or append .claude/CLAUDE.md
+  const claudeMdPath = path.join(claudeDir, 'CLAUDE.md');
+  if (fs.existsSync(claudeMdPath)) {
+    const existing = fs.readFileSync(claudeMdPath, 'utf8');
+    if (!existing.includes(POINTER_LINE)) {
+      fs.appendFileSync(claudeMdPath, '\n' + POINTER_LINE + '\n');
+    }
+  } else {
+    fs.writeFileSync(claudeMdPath, POINTER_LINE + '\n');
+  }
+
+  // Sync .claude/commands/ from package
+  const srcCommands = path.join(__dirname, '..', 'commands');
+  if (fs.existsSync(srcCommands)) {
+    const commandsDir = path.join(claudeDir, 'commands');
+    fs.mkdirSync(commandsDir, { recursive: true });
+    for (const file of fs.readdirSync(srcCommands)) {
+      fs.copyFileSync(
+        path.join(srcCommands, file),
+        path.join(commandsDir, file)
+      );
+    }
+  }
+
+  // Sync .claude/skills/ from package
+  const srcSkills = path.join(__dirname, '..', 'skills');
+  if (fs.existsSync(srcSkills)) {
+    const skillsDir = path.join(claudeDir, 'skills');
+    fs.mkdirSync(skillsDir, { recursive: true });
+    for (const skillFolder of fs.readdirSync(srcSkills)) {
+      const srcSkillDir = path.join(srcSkills, skillFolder);
+      if (!fs.statSync(srcSkillDir).isDirectory()) continue;
+      const destSkillDir = path.join(skillsDir, skillFolder);
+      fs.mkdirSync(destSkillDir, { recursive: true });
+      for (const file of fs.readdirSync(srcSkillDir)) {
+        fs.copyFileSync(
+          path.join(srcSkillDir, file),
+          path.join(destSkillDir, file)
+        );
+      }
+    }
+  }
+
+  log('sync', 'Synced system files to .claude/');
+  console.log('lemmafit: synced system files to .claude/');
+}
+
+module.exports = { syncProject };
+
+// Run as script when invoked directly
+if (require.main === module) {
+
+// Determine target directory
+const explicitTarget = process.argv[2];
+
+if (explicitTarget) {
+  // Called as `lemmafit sync <dir>` or `node cli/sync.js <dir>`
+  syncProject(explicitTarget);
+} else {
+  // Called as postinstall or `lemmafit sync` (no arg)
+  const projectRoot = findProjectRoot();
+  if (projectRoot) {
+    syncProject(projectRoot);
+  }
+  // If no project root found (e.g. installing lemmafit globally), silently do nothing.
+}
+}