archer-wizard 0.1.0

package/src/wizard/injector.ts

@@ -0,0 +1,115 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import * as clack from '@clack/prompts';
+import pc from 'picocolors';
+import { logSuccess, logError, logAction } from '../lib/ascii.js';
+import { getConfigKey } from './detector.js';
+import type { AgentInfo, InjectionResult, McpServerEntry } from '../types/index.js';
+
+// ─── Archer MCP Entry ───────────────────────────────────────
+
+function buildArcherEntry(supabaseUrl: string, serviceRoleKey: string): McpServerEntry {
+  return {
+    command: 'npx',
+    args: ['-y', 'archer', '--mcp'],
+    env: {
+      SUPABASE_URL: supabaseUrl,
+      SUPABASE_SERVICE_ROLE_KEY: serviceRoleKey,
+    },
+  };
+}
+
+// ─── Read or Create Config ──────────────────────────────────
+
+function readConfig(configPath: string): Record<string, unknown> {
+  try {
+    if (fs.existsSync(configPath)) {
+      const content = fs.readFileSync(configPath, 'utf-8');
+      return JSON.parse(content) as Record<string, unknown>;
+    }
+  } catch {
+    // Parse error or read error — start fresh
+  }
+  return {};
+}
+
+function writeConfig(configPath: string, config: Record<string, unknown>): void {
+  const dir = path.dirname(configPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+}
+
+// ─── Inject Into Single Agent ───────────────────────────────
+
+function injectIntoAgent(
+  agent: AgentInfo,
+  supabaseUrl: string,
+  serviceRoleKey: string,
+): InjectionResult {
+  try {
+    const configKey = getConfigKey(agent.name);
+    const config = readConfig(agent.configPath);
+    const archerEntry = buildArcherEntry(supabaseUrl, serviceRoleKey);
+
+    // Ensure the config key object exists
+    if (!config[configKey] || typeof config[configKey] !== 'object') {
+      config[configKey] = {};
+    }
+
+    // Inject archer entry without overwriting other servers
+    const servers = config[configKey] as Record<string, unknown>;
+    servers['archer'] = archerEntry;
+
+    writeConfig(agent.configPath, config);
+
+    logSuccess(`injected into ${pc.bold(agent.name)} → ${agent.configPath}`);
+    return { agent: agent.name, success: true };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    logError(`failed to inject into ${agent.name}: ${message}`);
+    return { agent: agent.name, success: false, error: message };
+  }
+}
+
+// ─── Main Injector ──────────────────────────────────────────
+
+export async function injectIntoAgents(
+  agents: AgentInfo[],
+  supabaseUrl: string,
+  serviceRoleKey: string,
+): Promise<InjectionResult[]> {
+  if (agents.length === 0) {
+    logError('no AI agents detected on this system');
+    return [];
+  }
+
+  // Display found agents
+  console.log();
+  logAction('detected agents:');
+  for (const agent of agents) {
+    console.log(`   ${pc.dim('·')} ${pc.bold(agent.name)}`);
+  }
+  console.log();
+
+  // Single confirmation
+  const shouldInject = await clack.confirm({
+    message: `inject archer into ${agents.length} agent${agents.length !== 1 ? 's' : ''}?`,
+    initialValue: true,
+  });
+
+  if (clack.isCancel(shouldInject) || !shouldInject) {
+    logAction('skipped injection');
+    return [];
+  }
+
+  // Inject into all confirmed agents
+  const results: InjectionResult[] = [];
+  for (const agent of agents) {
+    const result = injectIntoAgent(agent, supabaseUrl, serviceRoleKey);
+    results.push(result);
+  }
+
+  return results;
+}

package/src/wizard/rules.ts

@@ -0,0 +1,112 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { logSuccess, logError } from '../lib/ascii.js';
+import { getRulesPath } from './detector.js';
+import type { AgentInfo } from '../types/index.js';
+
+// ─── Rule Content ───────────────────────────────────────────
+
+const RULE_CONTENT = `
+# Archer — Event Intelligence for AI Agents
+
+Archer is connected to this project's Supabase instance.
+
+## Available Tool: archer.watch
+
+You can watch real-time events from Supabase using the \`archer.watch\` MCP tool.
+
+### Parameters
+
+- **source**: always \`"supabase"\`
+- **event**: one of \`"auth.signup"\`, \`"table.insert"\`, \`"table.update"\`, \`"table.delete"\`
+- **table**: the table name (required for table events)
+- **condition**: optional filter like \`"email ends with @gmail.com"\`
+- **webhookUrl**: URL to receive POST notifications
+
+### Examples
+
+1. Watch for new user signups:
+   \`\`\`
+   archer.watch({ source: "supabase", event: "auth.signup", webhookUrl: "https://hooks.example.com/signups" })
+   \`\`\`
+
+2. Watch for inserts to the orders table:
+   \`\`\`
+   archer.watch({ source: "supabase", event: "table.insert", table: "orders", webhookUrl: "https://hooks.example.com/orders" })
+   \`\`\`
+
+3. Watch with a condition:
+   \`\`\`
+   archer.watch({ source: "supabase", event: "table.insert", table: "users", condition: "email ends with @company.com", webhookUrl: "https://hooks.example.com/vip" })
+   \`\`\`
+
+When the user asks to "watch" or "monitor" something in their database, use this tool.
+`.trim();
+
+// ─── Archer Block Markers ───────────────────────────────────
+
+const BLOCK_START = '<!-- archer:start -->';
+const BLOCK_END = '<!-- archer:end -->';
+
+function wrapInBlock(content: string): string {
+  return `${BLOCK_START}\n${content}\n${BLOCK_END}`;
+}
+
+// ─── Replace or Append Block ────────────────────────────────
+
+function insertContent(existingContent: string, newBlock: string): string {
+  const startIdx = existingContent.indexOf(BLOCK_START);
+  const endIdx = existingContent.indexOf(BLOCK_END);
+
+  if (startIdx !== -1 && endIdx !== -1) {
+    // Replace existing block
+    return (
+      existingContent.slice(0, startIdx) +
+      newBlock +
+      existingContent.slice(endIdx + BLOCK_END.length)
+    );
+  }
+
+  // Append to end
+  const separator = existingContent.endsWith('\n') ? '\n' : '\n\n';
+  return existingContent + separator + newBlock + '\n';
+}
+
+// ─── Write Rules to Agent ───────────────────────────────────
+
+function writeRulesForAgent(agent: AgentInfo, cwd: string): boolean {
+  try {
+    const rulesPath = getRulesPath(agent.name, cwd);
+    const dir = path.dirname(rulesPath);
+    const wrappedContent = wrapInBlock(RULE_CONTENT);
+
+    // Ensure directory exists
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+
+    // Read existing content or start fresh
+    let existingContent = '';
+    if (fs.existsSync(rulesPath)) {
+      existingContent = fs.readFileSync(rulesPath, 'utf-8');
+    }
+
+    const finalContent = insertContent(existingContent, wrappedContent);
+    fs.writeFileSync(rulesPath, finalContent, 'utf-8');
+
+    logSuccess(`wrote rules to ${agent.name} → ${rulesPath}`);
+    return true;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    logError(`failed to write rules for ${agent.name}: ${message}`);
+    return false;
+  }
+}
+
+// ─── Main Rules Injector ────────────────────────────────────
+
+export function injectRules(agents: AgentInfo[], cwd: string): void {
+  for (const agent of agents) {
+    writeRulesForAgent(agent, cwd);
+  }
+}

package/src/wizard/scanner.ts

@@ -0,0 +1,250 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import * as clack from '@clack/prompts';
+import { z } from 'zod';
+import { logSuccess, logError, maskCredential } from '../lib/ascii.js';
+import type { ScanResult, Framework } from '../types/index.js';
+
+// ─── Env File Priority ──────────────────────────────────────
+
+const ENV_FILES = [
+  '.env.local',
+  '.env',
+  '.env.development',
+  '.env.production',
+] as const;
+
+// ─── Key Aliases ────────────────────────────────────────────
+
+const SUPABASE_URL_ALIASES = [
+  'SUPABASE_URL',
+  'NEXT_PUBLIC_SUPABASE_URL',
+  'VITE_SUPABASE_URL',
+] as const;
+
+const SERVICE_ROLE_KEY_ALIASES = [
+  'SUPABASE_SERVICE_ROLE_KEY',
+  'SUPABASE_SERVICE_KEY',
+] as const;
+
+const ANON_KEY_ALIASES = [
+  'SUPABASE_ANON_KEY',
+  'NEXT_PUBLIC_SUPABASE_ANON_KEY',
+  'VITE_SUPABASE_ANON_KEY',
+] as const;
+
+// ─── Validation Schemas ─────────────────────────────────────
+
+const SupabaseUrlSchema = z.string().url().startsWith('https://', {
+  message: 'SUPABASE_URL must start with https://',
+});
+
+const ServiceRoleKeySchema = z.string().min(1, {
+  message: 'SUPABASE_SERVICE_ROLE_KEY must be a non-empty string',
+});
+
+// ─── Parse Env File ─────────────────────────────────────────
+
+function parseEnvFile(filePath: string): Map<string, string> {
+  const vars = new Map<string, string>();
+
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const lines = content.split('\n');
+
+    for (const rawLine of lines) {
+      const line = rawLine.trim();
+      if (!line || line.startsWith('#')) continue;
+
+      const eqIndex = line.indexOf('=');
+      if (eqIndex === -1) continue;
+
+      const key = line.slice(0, eqIndex).trim();
+      let value = line.slice(eqIndex + 1).trim();
+
+      // Strip surrounding quotes
+      if (
+        (value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))
+      ) {
+        value = value.slice(1, -1);
+      }
+
+      if (key && value) {
+        vars.set(key, value);
+      }
+    }
+  } catch {
+    // File doesn't exist or can't be read — skip silently
+  }
+
+  return vars;
+}
+
+// ─── Find Key By Aliases ────────────────────────────────────
+
+function findByAliases(
+  envMap: Map<string, string>,
+  aliases: readonly string[],
+): string | null {
+  for (const alias of aliases) {
+    const value = envMap.get(alias);
+    if (value) return value;
+  }
+  return null;
+}
+
+// ─── Detect Framework ───────────────────────────────────────
+
+function detectFramework(cwd: string): { framework: Framework; hasSupabaseInstalled: boolean } {
+  let framework: Framework = 'unknown';
+  let hasSupabaseInstalled = false;
+
+  try {
+    const pkgPath = path.join(cwd, 'package.json');
+    const content = fs.readFileSync(pkgPath, 'utf-8');
+    const pkg = JSON.parse(content) as {
+      dependencies?: Record<string, string>;
+      devDependencies?: Record<string, string>;
+    };
+
+    const allDeps = {
+      ...pkg.dependencies,
+      ...pkg.devDependencies,
+    };
+
+    if ('next' in allDeps) {
+      framework = 'nextjs';
+    } else if ('vite' in allDeps) {
+      framework = 'vite';
+    }
+
+    if ('@supabase/supabase-js' in allDeps) {
+      hasSupabaseInstalled = true;
+    }
+  } catch {
+    // No package.json or parse error — defaults are fine
+  }
+
+  return { framework, hasSupabaseInstalled };
+}
+
+// ─── Main Scanner ───────────────────────────────────────────
+
+export async function scanProject(cwd: string): Promise<ScanResult> {
+  // Merge all env files (earlier files win)
+  const mergedEnv = new Map<string, string>();
+  let foundInFile: string | null = null;
+
+  // Read in reverse so earlier files overwrite later ones
+  for (const file of [...ENV_FILES].reverse()) {
+    const filePath = path.join(cwd, file);
+    const vars = parseEnvFile(filePath);
+    for (const [key, value] of vars) {
+      mergedEnv.set(key, value);
+    }
+    if (vars.size > 0 && !foundInFile) {
+      foundInFile = file;
+    }
+  }
+
+  // Re-check which file had the first match (priority order)
+  for (const file of ENV_FILES) {
+    const filePath = path.join(cwd, file);
+    const vars = parseEnvFile(filePath);
+    if (vars.size > 0) {
+      foundInFile = file;
+      break;
+    }
+  }
+
+  const supabaseUrl = findByAliases(mergedEnv, SUPABASE_URL_ALIASES);
+  const serviceRoleKey = findByAliases(mergedEnv, SERVICE_ROLE_KEY_ALIASES);
+  const anonKey = findByAliases(mergedEnv, ANON_KEY_ALIASES);
+
+  const { framework, hasSupabaseInstalled } = detectFramework(cwd);
+
+  // Log found credentials
+  if (supabaseUrl) {
+    logSuccess(`SUPABASE_URL = ${maskCredential(supabaseUrl)}`);
+  } else {
+    logError('missing SUPABASE_URL');
+  }
+
+  if (serviceRoleKey) {
+    logSuccess(`SUPABASE_SERVICE_ROLE_KEY = ${maskCredential(serviceRoleKey)}`);
+  } else {
+    logError('missing SUPABASE_SERVICE_ROLE_KEY');
+  }
+
+  if (anonKey) {
+    logSuccess(`SUPABASE_ANON_KEY = ${maskCredential(anonKey)}`);
+  }
+
+  if (foundInFile) {
+    logSuccess(`found credentials in ${foundInFile}`);
+  }
+
+  return {
+    supabaseUrl,
+    serviceRoleKey,
+    anonKey,
+    framework,
+    hasSupabaseInstalled,
+    foundInFile,
+  };
+}
+
+// ─── Prompt for Missing Credentials ─────────────────────────
+
+export async function promptForMissing(
+  scan: ScanResult,
+): Promise<{ supabaseUrl: string; serviceRoleKey: string }> {
+  let supabaseUrl = scan.supabaseUrl;
+  let serviceRoleKey = scan.serviceRoleKey;
+
+  if (!supabaseUrl) {
+    const value = await clack.text({
+      message: 'Enter your SUPABASE_URL',
+      placeholder: 'https://your-project.supabase.co',
+      validate: (input) => {
+        const result = SupabaseUrlSchema.safeParse(input);
+        if (!result.success) {
+          return result.error.issues[0]?.message ?? 'Invalid URL';
+        }
+        return undefined;
+      },
+    });
+
+    if (clack.isCancel(value)) {
+      process.exit(0);
+    }
+
+    supabaseUrl = value as string;
+  }
+
+  if (!serviceRoleKey) {
+    const value = await clack.text({
+      message: 'Enter your SUPABASE_SERVICE_ROLE_KEY',
+      placeholder: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...',
+      validate: (input) => {
+        const result = ServiceRoleKeySchema.safeParse(input);
+        if (!result.success) {
+          return result.error.issues[0]?.message ?? 'Invalid key';
+        }
+        return undefined;
+      },
+    });
+
+    if (clack.isCancel(value)) {
+      process.exit(0);
+    }
+
+    serviceRoleKey = value as string;
+  }
+
+  return {
+    supabaseUrl: SupabaseUrlSchema.parse(supabaseUrl),
+    serviceRoleKey: ServiceRoleKeySchema.parse(serviceRoleKey),
+  };
+}

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "noImplicitAny": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}