@grainulation/wheat 1.0.0

package/lib/compiler.js

@@ -0,0 +1,35 @@
+/**
+ * wheat compile — delegates to wheat-compiler.js with --dir
+ *
+ * Instead of duplicating the compiler, we ship the real one and shell out.
+ * This ensures the npm package always produces identical output to the
+ * standalone compiler.
+ *
+ * Zero npm dependencies.
+ */
+
+import path from 'path';
+import { execFileSync } from 'child_process';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const COMPILER_PATH = path.join(__dirname, '..', 'compiler', 'wheat-compiler.js');
+
+export async function run(dir, args) {
+  // Build argv for the real compiler: --dir <targetDir> + passthrough flags
+  const compilerArgs = [COMPILER_PATH, '--dir', dir, ...args];
+
+  try {
+    const result = execFileSync(process.execPath, compilerArgs, {
+      cwd: dir,
+      timeout: 30_000,
+      stdio: ['inherit', 'inherit', 'inherit'],
+    });
+  } catch (err) {
+    // execFileSync throws on non-zero exit — let it propagate
+    if (err.status) process.exit(err.status);
+    throw err;
+  }
+}

package/lib/connect.js

@@ -0,0 +1,418 @@
+/**
+ * wheat connect farmer — Auto-configure Claude Code hooks for Farmer
+ *
+ * Detects farmer on localhost, writes hooks to project-level
+ * .claude/settings.local.json. Atomic writes with lockfile.
+ * Zero npm dependencies.
+ */
+
+import http from 'node:http';
+import https from 'node:https';
+import fs from 'node:fs';
+import path from 'node:path';
+
+// ─── Constants ─────────────────────────────────────────────────────────────
+
+const DEFAULT_PORTS = [9090, 9091];
+const DETECT_TIMEOUT_MS = 2000;
+const VERIFY_TIMEOUT_MS = 5000;
+const LOCK_RETRY_MS = 200;
+const LOCK_MAX_RETRIES = 10;
+const SETTINGS_FILENAME = '.claude/settings.local.json';
+
+const HOOK_ENDPOINTS = {
+  permission:   '/hooks/permission',
+  activity:     '/hooks/activity',
+  notification: '/hooks/notification',
+};
+
+// ─── Argument parsing ──────────────────────────────────────────────────────
+
+function parseArgs(args) {
+  const flags = {};
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--url' && args[i + 1]) {
+      flags.url = args[i + 1]; i++;
+    } else if (args[i] === '--port' && args[i + 1]) {
+      flags.port = parseInt(args[i + 1], 10); i++;
+    } else if (args[i] === '--dry-run') {
+      flags.dryRun = true;
+    } else if (args[i] === '--force') {
+      flags.force = true;
+    } else if (args[i] === '--json') {
+      flags.json = true;
+    } else if (args[i] === '--help' || args[i] === '-h') {
+      flags.help = true;
+    }
+  }
+  return flags;
+}
+
+// ─── HTTP helpers (zero-dep) ───────────────────────────────────────────────
+
+function httpRequest(url, options = {}) {
+  return new Promise(resolve => {
+    const parsed = new URL(url);
+    const client = parsed.protocol === 'https:' ? https : http;
+    const timeout = options.timeout || DETECT_TIMEOUT_MS;
+
+    const req = client.request(parsed, {
+      method: options.method || 'GET',
+      headers: options.headers || {},
+      timeout,
+    }, res => {
+      let body = '';
+      res.on('data', chunk => { body += chunk; });
+      res.on('end', () => {
+        resolve({ status: res.statusCode, body, error: null });
+      });
+    });
+
+    req.on('error', err => resolve({ status: 0, body: '', error: err.message }));
+    req.on('timeout', () => { req.destroy(); resolve({ status: 0, body: '', error: 'timeout' }); });
+
+    if (options.body) {
+      req.write(typeof options.body === 'string' ? options.body : JSON.stringify(options.body));
+    }
+    req.end();
+  });
+}
+
+// ─── Farmer detection ──────────────────────────────────────────────────────
+
+async function probeFarmer(baseUrl) {
+  // Primary detection: hit /api/state which is the canonical farmer endpoint
+  const stateResp = await httpRequest(baseUrl + '/api/state', { timeout: DETECT_TIMEOUT_MS });
+  if (stateResp.error) return { found: false, error: stateResp.error };
+
+  if (stateResp.status !== 200) {
+    // Fallback: try root to see if it's farmer at all
+    const rootResp = await httpRequest(baseUrl + '/', { timeout: DETECT_TIMEOUT_MS });
+    if (rootResp.error || rootResp.status !== 200) {
+      return { found: false, error: `Port responds (HTTP ${stateResp.status}) but /api/state not available` };
+    }
+    const looksLikeFarmer = rootResp.body.includes('farmer') || rootResp.body.includes('Farmer');
+    if (!looksLikeFarmer) {
+      return { found: false, error: `Port responds but does not look like Farmer` };
+    }
+  }
+
+  // Hook probe: verify the permission endpoint accepts POSTs
+  const probePayload = {
+    hook_event_name: 'PreToolUse',
+    tool_name: '__wheat_connect_probe__',
+    tool_input: '{}',
+    session_id: 'wheat-connect-probe',
+  };
+
+  const hookResp = await httpRequest(baseUrl + HOOK_ENDPOINTS.permission, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: probePayload,
+    timeout: VERIFY_TIMEOUT_MS,
+  });
+
+  if (hookResp.error) {
+    return { found: true, verified: false, error: `Farmer found but hook probe failed: ${hookResp.error}` };
+  }
+
+  let isVerified = false;
+  try {
+    isVerified = !!JSON.parse(hookResp.body).hookSpecificOutput;
+  } catch {}
+
+  return {
+    found: true,
+    verified: isVerified,
+    status: hookResp.status,
+    error: isVerified ? null : `Hook endpoint returned unexpected response (HTTP ${hookResp.status})`,
+  };
+}
+
+async function verifySse(baseUrl) {
+  return new Promise(resolve => {
+    const parsed = new URL(baseUrl + '/events');
+    const req = http.request(parsed, { method: 'GET', timeout: VERIFY_TIMEOUT_MS }, res => {
+      const isSSE = res.headers['content-type']?.includes('text/event-stream');
+      res.destroy(); // We only need to confirm it opens
+      resolve({ ok: isSSE, status: res.statusCode });
+    });
+    req.on('error', err => resolve({ ok: false, error: err.message }));
+    req.on('timeout', () => { req.destroy(); resolve({ ok: false, error: 'timeout' }); });
+    req.end();
+  });
+}
+
+async function detectFarmer(preferredPort) {
+  const ports = preferredPort ? [preferredPort] : DEFAULT_PORTS;
+  for (const port of ports) {
+    const baseUrl = `http://127.0.0.1:${port}`;
+    const result = await probeFarmer(baseUrl);
+    if (result.found) return { ...result, url: baseUrl, port };
+  }
+  return { found: false, url: null, port: null, error: 'No farmer server found on default ports' };
+}
+
+// ─── Settings file management ──────────────────────────────────────────────
+
+function hookCommand(farmerUrl, endpoint) {
+  return `cat | curl -s -X POST ${farmerUrl}${endpoint} -H 'Content-Type: application/json' --data-binary @- 2>/dev/null || true`;
+}
+
+function buildHooksConfig(farmerUrl) {
+  return {
+    PreToolUse: [{
+      matcher: '',
+      hooks: [{ type: 'command', command: hookCommand(farmerUrl, HOOK_ENDPOINTS.permission) }],
+    }],
+    PostToolUse: [{
+      matcher: '',
+      hooks: [{ type: 'command', command: hookCommand(farmerUrl, HOOK_ENDPOINTS.activity) }],
+    }],
+    Notification: [{
+      matcher: '',
+      hooks: [{ type: 'command', command: hookCommand(farmerUrl, HOOK_ENDPOINTS.notification) }],
+    }],
+  };
+}
+
+function readSettings(settingsPath) {
+  try {
+    return JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+  } catch (err) {
+    if (err.code === 'ENOENT') return {};
+    throw new Error(`Cannot parse ${settingsPath}: ${err.message}`);
+  }
+}
+
+function isFarmerHookEntry(entry) {
+  if (!entry.hooks || !Array.isArray(entry.hooks)) return false;
+  return entry.hooks.some(h =>
+    (h.type === 'command' && h.command && h.command.includes('/hooks/'))
+    || (h.type === 'url' && h.url && h.url.includes('/hooks/'))
+  );
+}
+
+function mergeHooks(existing, farmerHooks) {
+  const merged = JSON.parse(JSON.stringify(existing));
+  if (!merged.hooks) merged.hooks = {};
+
+  for (const hookType of Object.keys(farmerHooks)) {
+    const existingHooks = merged.hooks[hookType] || [];
+    const nonFarmerHooks = existingHooks.filter(entry => !isFarmerHookEntry(entry));
+    merged.hooks[hookType] = [...nonFarmerHooks, ...farmerHooks[hookType]];
+  }
+  return merged;
+}
+
+async function writeSettingsAtomic(settingsPath, settings) {
+  const lockPath = settingsPath + '.lock';
+  const backupPath = settingsPath + '.backup';
+  const tmpPath = settingsPath + '.tmp';
+
+  let lockAcquired = false;
+  for (let i = 0; i < LOCK_MAX_RETRIES; i++) {
+    try {
+      const fd = fs.openSync(lockPath, 'wx');
+      fs.writeSync(fd, String(process.pid));
+      fs.closeSync(fd);
+      lockAcquired = true;
+      break;
+    } catch (err) {
+      if (err.code === 'EEXIST') {
+        try {
+          const holderPid = parseInt(fs.readFileSync(lockPath, 'utf8').trim(), 10);
+          process.kill(holderPid, 0);
+          await new Promise(r => setTimeout(r, LOCK_RETRY_MS));
+        } catch {
+          try { fs.unlinkSync(lockPath); } catch {}
+        }
+      } else {
+        throw err;
+      }
+    }
+  }
+
+  if (!lockAcquired) {
+    throw new Error('Cannot acquire file lock — another process is writing to settings');
+  }
+
+  try {
+    if (fs.existsSync(settingsPath)) {
+      fs.copyFileSync(settingsPath, backupPath);
+    }
+    fs.writeFileSync(tmpPath, JSON.stringify(settings, null, 2) + '\n');
+    fs.renameSync(tmpPath, settingsPath);
+  } finally {
+    try { fs.unlinkSync(lockPath); } catch {}
+  }
+}
+
+// ─── Output formatting ────────────────────────────────────────────────────
+
+function printSuccess(farmerUrl, settingsPath, dryRun) {
+  console.log();
+  console.log('  \x1b[32m\u2713\x1b[0m \x1b[1mFarmer connected\x1b[0m');
+  console.log('  \u2500'.repeat(40));
+  console.log(`  Server:   ${farmerUrl}`);
+  console.log(`  Settings: ${settingsPath}`);
+  console.log();
+  console.log('  Hooks configured:');
+  console.log(`    PreToolUse   \u2192 ${farmerUrl}/hooks/permission`);
+  console.log(`    PostToolUse  \u2192 ${farmerUrl}/hooks/activity`);
+  console.log(`    Notification \u2192 ${farmerUrl}/hooks/notification`);
+  console.log();
+  if (dryRun) {
+    console.log('  \x1b[33m(dry run \u2014 no files were modified)\x1b[0m');
+    console.log();
+  }
+  console.log('  What this means:');
+  console.log('    Every Claude Code tool call in this project now routes');
+  console.log('    through Farmer. You can approve, deny, or monitor');
+  console.log('    from your phone or desktop.');
+  console.log();
+  console.log('  What was verified:');
+  console.log('    - Farmer is running and responding to hook probes');
+  console.log('    - SSE event stream is available for live monitoring');
+  console.log('    - Hooks were merged without overwriting existing settings');
+  console.log();
+  console.log('  What to do next:');
+  console.log('    Open Claude Code in this directory. If Farmer goes down,');
+  console.log('    hooks fail silently (|| true) so your workflow is never blocked.');
+  console.log();
+}
+
+function printNotFound(triedPorts) {
+  console.log();
+  console.log('  \x1b[31m\u2717\x1b[0m \x1b[1mFarmer not detected\x1b[0m');
+  console.log('  \u2500'.repeat(40));
+  console.log(`  Tried ports: ${triedPorts.join(', ')}`);
+  console.log();
+  console.log('  To start Farmer:');
+  console.log('    npx @grainulation/farmer start');
+  console.log();
+  console.log('  Or connect to a remote Farmer:');
+  console.log('    wheat connect farmer --url https://your-tunnel.trycloudflare.com');
+  console.log();
+}
+
+// ─── Main ──────────────────────────────────────────────────────────────────
+
+export async function run(dir, args) {
+  const flags = parseArgs(args || []);
+
+  if (flags.help) {
+    console.log(`
+  wheat connect farmer — Auto-configure Claude Code hooks for Farmer
+
+  Usage:
+    wheat connect farmer [options]
+
+  Options:
+    --url <url>     Connect to a specific Farmer URL (remote/tunnel)
+    --port <port>   Try a specific port instead of defaults (9090, 9091)
+    --dry-run       Show what would be configured without writing
+    --force         Overwrite existing farmer hooks
+    --json          Output result as JSON (for scripting)
+    --help          Show this help
+`);
+    return;
+  }
+
+  const targetDir = dir || process.cwd();
+  const settingsPath = path.join(targetDir, SETTINGS_FILENAME);
+  const settingsDir = path.dirname(settingsPath);
+
+  if (!fs.existsSync(settingsDir)) {
+    fs.mkdirSync(settingsDir, { recursive: true });
+  }
+
+  // Step 1: Detect or connect to farmer
+  let farmerUrl;
+  let detection;
+
+  if (flags.url) {
+    farmerUrl = flags.url.replace(/\/+$/, '');
+    console.log(`\n  Connecting to ${farmerUrl}...`);
+    detection = await probeFarmer(farmerUrl);
+    if (!detection.found) {
+      if (flags.json) {
+        console.log(JSON.stringify({ success: false, error: detection.error }));
+      } else {
+        console.log(`\n  \x1b[31m\u2717\x1b[0m Cannot reach Farmer at ${farmerUrl}: ${detection.error}\n`);
+      }
+      process.exit(1);
+    }
+  } else {
+    const ports = flags.port ? [flags.port] : DEFAULT_PORTS;
+    console.log(`\n  Detecting Farmer on localhost (ports: ${ports.join(', ')})...`);
+    detection = await detectFarmer(flags.port);
+    if (!detection.found) {
+      if (flags.json) {
+        console.log(JSON.stringify({ success: false, error: detection.error }));
+      } else {
+        printNotFound(ports);
+      }
+      process.exit(1);
+    }
+    farmerUrl = detection.url;
+  }
+
+  if (!detection.verified) {
+    console.log(`  \x1b[33m!\x1b[0m Farmer found but hook verification failed.`);
+    console.log(`    ${detection.error || 'Unknown verification error'}`);
+    console.log(`    Proceeding with configuration anyway...`);
+  } else {
+    console.log(`  \x1b[32m\u2713\x1b[0m Farmer detected at ${farmerUrl}`);
+  }
+
+  // Verify SSE endpoint is available
+  const sseResult = await verifySse(farmerUrl);
+  if (sseResult.ok) {
+    console.log(`  \x1b[32m\u2713\x1b[0m SSE event stream verified at ${farmerUrl}/events`);
+  } else {
+    console.log(`  \x1b[33m!\x1b[0m SSE endpoint not confirmed (${sseResult.error || 'unexpected response'})`);
+    console.log(`    Live monitoring may not work until Farmer restarts.`);
+  }
+
+  // Step 2: Read existing settings, merge, write
+  const existing = readSettings(settingsPath);
+
+  const hasExistingFarmerHooks = existing.hooks && Object.values(existing.hooks).some(
+    entries => Array.isArray(entries) && entries.some(entry => isFarmerHookEntry(entry))
+  );
+
+  if (hasExistingFarmerHooks && !flags.force) {
+    if (flags.json) {
+      console.log(JSON.stringify({ success: true, alreadyConfigured: true, url: farmerUrl }));
+    } else {
+      console.log(`  \x1b[33m!\x1b[0m Farmer hooks already configured in ${SETTINGS_FILENAME}`);
+      console.log('    Use --force to overwrite.');
+    }
+    return;
+  }
+
+  const farmerHooks = buildHooksConfig(farmerUrl);
+  const merged = mergeHooks(existing, farmerHooks);
+
+  if (flags.dryRun) {
+    if (flags.json) {
+      console.log(JSON.stringify({ success: true, dryRun: true, url: farmerUrl, settings: merged }));
+    } else {
+      console.log('\n  Would write to: ' + settingsPath);
+      console.log();
+      console.log(JSON.stringify(merged, null, 2));
+      printSuccess(farmerUrl, settingsPath, true);
+    }
+    return;
+  }
+
+  // Step 3: Write settings atomically
+  await writeSettingsAtomic(settingsPath, merged);
+
+  if (flags.json) {
+    console.log(JSON.stringify({ success: true, url: farmerUrl, settingsPath, verified: detection.verified }));
+  } else {
+    printSuccess(farmerUrl, settingsPath, false);
+  }
+}

package/lib/disconnect.js

@@ -0,0 +1,188 @@
+/**
+ * wheat disconnect farmer — Remove Farmer hooks from Claude Code settings
+ *
+ * Reads .claude/settings.local.json, strips any hook entries whose
+ * command or URL contains "/hooks/", writes back atomically (tmp + rename).
+ * Zero npm dependencies.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+// ─── Constants ─────────────────────────────────────────────────────────────
+
+const SETTINGS_FILENAME = '.claude/settings.local.json';
+
+// ─── Argument parsing ──────────────────────────────────────────────────────
+
+function parseArgs(args) {
+  const flags = {};
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--dry-run') {
+      flags.dryRun = true;
+    } else if (args[i] === '--json') {
+      flags.json = true;
+    } else if (args[i] === '--help' || args[i] === '-h') {
+      flags.help = true;
+    }
+  }
+  return flags;
+}
+
+// ─── Hook detection (matches connect.js logic) ────────────────────────────
+
+function isFarmerHookEntry(entry) {
+  if (!entry.hooks || !Array.isArray(entry.hooks)) return false;
+  return entry.hooks.some(h =>
+    (h.type === 'command' && h.command && h.command.includes('/hooks/'))
+    || (h.type === 'url' && h.url && h.url.includes('/hooks/'))
+  );
+}
+
+// ─── Settings I/O ─────────────────────────────────────────────────────────
+
+function readSettings(settingsPath) {
+  try {
+    return JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+  } catch (err) {
+    if (err.code === 'ENOENT') return null;
+    throw new Error(`Cannot parse ${settingsPath}: ${err.message}`);
+  }
+}
+
+function writeSettingsAtomic(settingsPath, settings) {
+  const tmpPath = settingsPath + '.tmp';
+  fs.writeFileSync(tmpPath, JSON.stringify(settings, null, 2) + '\n');
+  fs.renameSync(tmpPath, settingsPath);
+}
+
+// ─── Core logic ───────────────────────────────────────────────────────────
+
+function findFarmerHooks(settings) {
+  const found = [];
+  if (!settings || !settings.hooks) return found;
+  for (const [hookType, entries] of Object.entries(settings.hooks)) {
+    if (!Array.isArray(entries)) continue;
+    for (const entry of entries) {
+      if (isFarmerHookEntry(entry)) {
+        found.push({ hookType, entry });
+      }
+    }
+  }
+  return found;
+}
+
+function removeFarmerHooks(settings) {
+  const cleaned = JSON.parse(JSON.stringify(settings));
+  if (!cleaned.hooks) return cleaned;
+  for (const hookType of Object.keys(cleaned.hooks)) {
+    if (!Array.isArray(cleaned.hooks[hookType])) continue;
+    cleaned.hooks[hookType] = cleaned.hooks[hookType].filter(
+      entry => !isFarmerHookEntry(entry)
+    );
+    // Remove empty arrays to keep the file clean
+    if (cleaned.hooks[hookType].length === 0) {
+      delete cleaned.hooks[hookType];
+    }
+  }
+  // Remove empty hooks object
+  if (Object.keys(cleaned.hooks).length === 0) {
+    delete cleaned.hooks;
+  }
+  return cleaned;
+}
+
+// ─── Main ──────────────────────────────────────────────────────────────────
+
+export async function run(dir, args) {
+  const flags = parseArgs(args || []);
+
+  if (flags.help) {
+    console.log(`
+  wheat disconnect farmer -- Remove Farmer hooks from Claude Code settings
+
+  Usage:
+    wheat disconnect farmer [options]
+
+  Options:
+    --dry-run       Show what would be removed without writing
+    --json          Output result as JSON (for scripting)
+    --help          Show this help
+
+  This removes all hook entries in .claude/settings.local.json whose
+  command or URL contains "/hooks/". Other settings are preserved.
+`);
+    return;
+  }
+
+  const targetDir = dir || process.cwd();
+  const settingsPath = path.join(targetDir, SETTINGS_FILENAME);
+
+  const settings = readSettings(settingsPath);
+
+  if (!settings) {
+    if (flags.json) {
+      console.log(JSON.stringify({ success: true, removed: 0, message: 'No settings file found' }));
+    } else {
+      console.log('\n  No farmer hooks found (settings file does not exist).\n');
+    }
+    return;
+  }
+
+  const farmerHooks = findFarmerHooks(settings);
+
+  if (farmerHooks.length === 0) {
+    if (flags.json) {
+      console.log(JSON.stringify({ success: true, removed: 0, message: 'No farmer hooks found' }));
+    } else {
+      console.log('\n  No farmer hooks found in ' + SETTINGS_FILENAME + '.\n');
+    }
+    return;
+  }
+
+  // Show what will be removed
+  if (flags.dryRun) {
+    if (flags.json) {
+      console.log(JSON.stringify({
+        success: true,
+        dryRun: true,
+        removed: farmerHooks.length,
+        hookTypes: farmerHooks.map(h => h.hookType),
+      }));
+    } else {
+      console.log('\n  Would remove ' + farmerHooks.length + ' farmer hook(s):');
+      for (const { hookType } of farmerHooks) {
+        console.log('    - ' + hookType);
+      }
+      console.log('\n  (dry run -- no files were modified)\n');
+    }
+    return;
+  }
+
+  // Remove and write
+  const cleaned = removeFarmerHooks(settings);
+  writeSettingsAtomic(settingsPath, cleaned);
+
+  if (flags.json) {
+    console.log(JSON.stringify({
+      success: true,
+      removed: farmerHooks.length,
+      hookTypes: farmerHooks.map(h => h.hookType),
+      settingsPath,
+    }));
+  } else {
+    console.log();
+    console.log('  \x1b[32m\u2713\x1b[0m \x1b[1mFarmer disconnected\x1b[0m');
+    console.log('  \u2500'.repeat(40));
+    console.log('  Removed ' + farmerHooks.length + ' hook(s):');
+    for (const { hookType } of farmerHooks) {
+      console.log('    - ' + hookType);
+    }
+    console.log();
+    console.log('  Settings: ' + settingsPath);
+    console.log();
+    console.log('  To reconnect:');
+    console.log('    wheat connect farmer');
+    console.log();
+  }
+}