@0xdevabir/enhance 0.1.0

package/README.md

@@ -0,0 +1,231 @@
+# Enhance
+
+> AI prompt middleware — upgrades vague developer prompts into production-quality instructions before sending to coding agents.
+
+## What it does
+
+Instead of sending `build login page` directly to Claude/Codex/OpenCode:
+
+1. Scans your project (stack, frameworks, folder structure)
+2. Analyzes your intent
+3. Finds relevant existing files for context
+4. Rewrites the prompt with structure, best practices, and project awareness
+5. Sends the enhanced prompt to the AI
+
+**Same effort. Dramatically better output.**
+
+---
+
+## Installation
+
+### Prerequisites
+
+- Node.js 20+
+- At least one AI coding tool: [Claude Code](https://claude.ai/code), [OpenCode](https://opencode.ai), or [Codex CLI](https://github.com/openai/codex)
+
+### Step 1 — Install globally
+
+```bash
+npm install -g @0xdevabir/enhance
+```
+
+### Step 2 — Run setup
+
+```bash
+enhance setup
+```
+
+Detects which AI coding tools you have installed and automatically adds the `/enhance` slash command to each one.
+
+```
+Enhance — Setup
+
+Detected: Claude Code, OpenCode
+Not found: Codex CLI
+
+✓ Claude Code → ~/.claude/commands/enhance.md
+✓ OpenCode    → ~/.opencode/commands/enhance.md
+
+Ready. In any project, type:
+
+  /enhance build a login page
+  /enhance fix the auth bug
+  /enhance refactor the user service
+```
+
+**Options:**
+```bash
+enhance setup --force   # overwrite existing installations
+enhance setup --all     # install for all tools even if not detected
+```
+
+### Step 3 — Use it
+
+Open Claude Code, OpenCode, or Codex CLI in any project and type:
+
+```
+/enhance build a login page with email and password
+```
+
+---
+
+## Usage
+
+### Inside Claude Code / OpenCode / Codex CLI (after `enhance setup`)
+
+```
+/enhance build a login page with email and password
+/enhance fix the auth bug
+/enhance create a payment form with Stripe
+/enhance refactor the user service to use dependency injection
+/enhance add dark mode support
+```
+
+### Standalone CLI (calls AI directly)
+
+Requires API key:
+```bash
+export ANTHROPIC_API_KEY=sk-ant-...
+```
+
+```bash
+# Basic — scans project, enhances prompt, calls Claude
+enhance "build a login page"
+
+# Dry run — see the enhanced prompt without calling AI
+enhance "fix the auth bug" --dry-run
+
+# Show enhanced prompt AND call AI
+enhance "create dashboard component" --print-prompt
+
+# See detected stack and intent
+enhance "refactor user service" --verbose
+
+# Use a different provider
+enhance "add payment form" --provider codex
+```
+
+---
+
+## Configuration
+
+Create `.enhancerc.json` in your project root to customize behavior per-project:
+
+```json
+{
+  "provider": "claude",
+  "model": "claude-sonnet-4-6",
+  "maxContextTokens": 3000,
+  "customInstructions": "Always use React Query. Prefer named exports."
+}
+```
+
+| Key | Default | Description |
+|---|---|---|
+| `provider` | `claude` | AI provider: `claude`, `codex`, `opencode` |
+| `model` | `claude-sonnet-4-6` | Model ID |
+| `maxContextTokens` | `3000` | Max characters of project files to include |
+| `customInstructions` | — | Extra instructions always injected into every prompt |
+
+---
+
+## Providers
+
+### Claude (default)
+
+Requires `ANTHROPIC_API_KEY`. Get one at [console.anthropic.com](https://console.anthropic.com/).
+
+```bash
+export ANTHROPIC_API_KEY=sk-ant-...
+enhance "build login page"
+```
+
+### Codex CLI
+
+```bash
+npm install -g @openai/codex
+enhance "build login page" --provider codex
+```
+
+### OpenCode
+
+```bash
+npm install -g opencode
+enhance "build login page" --provider opencode
+```
+
+---
+
+## What Enhance Detects
+
+| Category | Detected |
+|---|---|
+| Frameworks | Next.js, React, Vue, Svelte, Nuxt, Remix, Astro, Express, Fastify, Hono, NestJS |
+| Styling | TailwindCSS, shadcn/ui, Material UI, Chakra UI, Ant Design |
+| ORMs | Prisma, Drizzle, TypeORM, Mongoose |
+| Testing | Vitest, Jest, Playwright, Cypress |
+| Language | TypeScript vs JavaScript |
+| Router | Next.js App Router vs Pages Router |
+| Package manager | npm, yarn, pnpm, bun |
+
+---
+
+## Example Enhancement
+
+**Input:**
+```
+enhance "build login page"
+```
+
+**Enhanced prompt sent to AI:**
+```
+You are working inside a Next.js TypeScript project.
+
+## Project Stack
+- Language: TypeScript
+- Frameworks: Next.js, React, TailwindCSS, shadcn/ui
+- UI Library: shadcn/ui
+- ORM: Prisma
+- Next.js Router: App Router
+
+## Task
+Create: build login page
+
+## Requirements
+- Use TypeScript throughout — no `any`, prefer `unknown` with type guards
+- Use Server Components by default — only add "use client" when needed
+- Follow App Router conventions: page.tsx, layout.tsx, route.ts
+- Use `next/navigation` for navigation
+- Use Tailwind classes — no custom CSS unless unavoidable
+- Use shadcn/ui components over building from scratch
+- Never store plain text passwords — use bcrypt or argon2
+- Use httpOnly, secure cookies for session tokens — never localStorage
+- Validate and sanitize all auth inputs server-side
+- Consider rate limiting on login/signup endpoints
+- ...
+```
+
+---
+
+## Development
+
+```bash
+git clone https://github.com/0xdevabir/agent-enhance.git
+cd agent-enhance
+npm install
+
+# Run without building
+npm run dev -- "build login page" --dry-run
+
+# Run tests
+npm test
+
+# Build
+npm run build
+```
+
+---
+
+## License
+
+MIT

package/bin/enhance.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/index.js';

package/dist/index.js

@@ -0,0 +1,918 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command } from "commander";
+import ora from "ora";
+
+// src/cli/logger.ts
+import chalk from "chalk";
+var error = (msg, err) => {
+  console.error(chalk.red(`\u2717 ${msg}`));
+  if (err instanceof Error && process.env["ENHANCE_DEBUG"]) {
+    console.error(chalk.red(err.stack));
+  }
+};
+
+// src/cli/errors.ts
+var EnhanceError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "EnhanceError";
+  }
+  code;
+};
+
+// src/config/index.ts
+import { cosmiconfig } from "cosmiconfig";
+var DEFAULT_CONFIG = {
+  provider: "claude",
+  model: "claude-sonnet-4-6",
+  maxContextTokens: 3e3
+};
+async function loadConfig(root) {
+  const explorer = cosmiconfig("enhance", {
+    searchPlaces: [
+      ".enhancerc",
+      ".enhancerc.json",
+      ".enhancerc.yaml",
+      "enhance.config.js",
+      "enhance.config.ts",
+      "package.json"
+    ]
+  });
+  let userConfig = {};
+  try {
+    const result = await explorer.search(root);
+    if (result?.config) {
+      userConfig = result.config;
+    }
+  } catch {
+  }
+  const merged = { ...DEFAULT_CONFIG, ...userConfig };
+  if (!merged.apiKey) {
+    merged.apiKey = process.env["ANTHROPIC_API_KEY"] ?? process.env["OPENAI_API_KEY"];
+  }
+  return merged;
+}
+
+// src/scanner/package.ts
+import { readFile } from "fs/promises";
+import { join } from "path";
+async function readPackageJson(root) {
+  try {
+    const content = await readFile(join(root, "package.json"), "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+// src/scanner/frameworks.ts
+import { stat } from "fs/promises";
+import { join as join2 } from "path";
+async function detectStack(pkg, root) {
+  const deps = {
+    ...pkg["dependencies"] ?? {},
+    ...pkg["devDependencies"] ?? {}
+  };
+  const has = (name) => name in deps;
+  const frameworks = [];
+  if (has("next")) frameworks.push("nextjs");
+  if (has("react") && !frameworks.includes("nextjs")) frameworks.push("react");
+  if (has("vue")) frameworks.push("vue");
+  if (has("svelte") || has("@sveltejs/kit")) frameworks.push("svelte");
+  if (has("nuxt") || has("nuxt3")) frameworks.push("nuxt");
+  if (has("@remix-run/node") || has("@remix-run/react")) frameworks.push("remix");
+  if (has("astro")) frameworks.push("astro");
+  if (has("express")) frameworks.push("express");
+  if (has("fastify")) frameworks.push("fastify");
+  if (has("hono")) frameworks.push("hono");
+  if (has("@nestjs/core")) frameworks.push("nestjs");
+  if (has("tailwindcss")) frameworks.push("tailwind");
+  let uiLibrary;
+  if (has("@radix-ui/react-dialog") || has("shadcn") || has("@shadcn/ui")) {
+    frameworks.push("shadcn");
+    uiLibrary = "shadcn";
+  } else if (has("@mui/material")) {
+    frameworks.push("mui");
+    uiLibrary = "mui";
+  } else if (has("antd")) {
+    frameworks.push("antd");
+    uiLibrary = "antd";
+  } else if (has("@chakra-ui/react")) {
+    frameworks.push("chakra");
+    uiLibrary = "chakra";
+  }
+  let orm;
+  if (has("prisma") || has("@prisma/client")) orm = "prisma";
+  else if (has("drizzle-orm")) orm = "drizzle";
+  else if (has("typeorm")) orm = "typeorm";
+  else if (has("mongoose")) orm = "mongoose";
+  let testing;
+  if (has("vitest")) testing = "vitest";
+  else if (has("jest") || has("@jest/core")) testing = "jest";
+  else if (has("@playwright/test")) testing = "playwright";
+  else if (has("cypress")) testing = "cypress";
+  const language = has("typescript") ? "typescript" : "javascript";
+  const packageManager = await detectPackageManager(root);
+  let nextRouterType;
+  if (frameworks.includes("nextjs")) {
+    const hasApp = await pathExists(join2(root, "app")) || await pathExists(join2(root, "src", "app"));
+    const hasPages = await pathExists(join2(root, "pages")) || await pathExists(join2(root, "src", "pages"));
+    nextRouterType = hasApp ? "app" : hasPages ? "pages" : "app";
+  }
+  let runtime = "unknown";
+  if (frameworks.some((f) => ["express", "fastify", "hono", "nestjs"].includes(f))) runtime = "node";
+  else if (frameworks.some((f) => ["react", "vue", "svelte", "astro"].includes(f))) runtime = "browser";
+  else if (frameworks.includes("nextjs")) runtime = "browser";
+  return { language, frameworks, runtime, orm, testing, packageManager, nextRouterType, uiLibrary };
+}
+async function detectPackageManager(root) {
+  if (await pathExists(join2(root, "bun.lockb"))) return "bun";
+  if (await pathExists(join2(root, "pnpm-lock.yaml"))) return "pnpm";
+  if (await pathExists(join2(root, "yarn.lock"))) return "yarn";
+  return "npm";
+}
+async function pathExists(p) {
+  try {
+    await stat(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/scanner/structure.ts
+import { readdir, stat as stat2 } from "fs/promises";
+import { join as join3 } from "path";
+var EXCLUDE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".next",
+  ".nuxt",
+  "dist",
+  "build",
+  ".cache",
+  "coverage",
+  ".turbo",
+  "out",
+  ".output"
+]);
+async function scanFolderStructure(root) {
+  const entries = await readdir(root, { withFileTypes: true });
+  const dirs = entries.filter((e) => e.isDirectory() && !EXCLUDE_DIRS.has(e.name)).map((e) => e.name);
+  const hasSrcDir = dirs.includes("src");
+  const hasAppDir = dirs.includes("app") || await dirExists(join3(root, "src", "app"));
+  const hasPagesDir = dirs.includes("pages") || await dirExists(join3(root, "src", "pages"));
+  let srcDirs = [];
+  if (hasSrcDir) {
+    try {
+      const srcEntries = await readdir(join3(root, "src"), { withFileTypes: true });
+      srcDirs = srcEntries.filter((e) => e.isDirectory() && !EXCLUDE_DIRS.has(e.name)).map((e) => e.name);
+    } catch {
+    }
+  }
+  return { root, dirs, srcDirs, hasAppDir, hasPagesDir, hasSrcDir };
+}
+async function dirExists(path) {
+  try {
+    const s = await stat2(path);
+    return s.isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+// src/scanner/tsconfig.ts
+import { readFile as readFile2 } from "fs/promises";
+import { join as join4 } from "path";
+async function readTsConfig(root) {
+  try {
+    const content = await readFile2(join4(root, "tsconfig.json"), "utf-8");
+    const parsed = JSON.parse(content);
+    return {
+      paths: parsed.compilerOptions?.paths,
+      baseUrl: parsed.compilerOptions?.baseUrl
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/scanner/index.ts
+async function scanProject(root) {
+  const [pkg, structure] = await Promise.all([
+    readPackageJson(root),
+    scanFolderStructure(root)
+  ]);
+  const safePkg = pkg ?? {};
+  const [stack] = await Promise.all([
+    detectStack(safePkg, root),
+    readTsConfig(root)
+  ]);
+  return {
+    stack,
+    structure,
+    projectRoot: root,
+    scannedAt: Date.now()
+  };
+}
+
+// src/cache/index.ts
+import { readFile as readFile3, writeFile, stat as stat3 } from "fs/promises";
+import { join as join5 } from "path";
+var CACHE_FILE = ".enhance-cache.json";
+async function getCached(root) {
+  const cachePath = join5(root, CACHE_FILE);
+  try {
+    const raw = await readFile3(cachePath, "utf-8");
+    const payload = JSON.parse(raw);
+    const pkgStat = await stat3(join5(root, "package.json"));
+    if (pkgStat.mtimeMs > payload.scannedAt) return null;
+    return payload.result;
+  } catch {
+    return null;
+  }
+}
+async function setCached(root, result) {
+  const cachePath = join5(root, CACHE_FILE);
+  const payload = { scannedAt: Date.now(), result };
+  await writeFile(cachePath, JSON.stringify(payload, null, 2), "utf-8");
+}
+
+// src/analyzer/intent.ts
+var ACTION_KEYWORDS = {
+  create: ["build", "create", "make", "add", "implement", "write", "generate", "scaffold", "set up", "setup", "new"],
+  fix: ["fix", "debug", "resolve", "repair", "broken", "failing", "crash", "error", "bug", "issue", "problem"],
+  refactor: ["refactor", "clean", "improve", "optimize", "restructure", "simplify", "rewrite", "reorganize"],
+  explain: ["explain", "describe", "what", "how does", "why", "show me", "understand", "walkthrough"],
+  add: ["add", "integrate", "install", "include", "plug in", "connect"],
+  delete: ["delete", "remove", "drop", "clean up", "uninstall", "get rid"],
+  unknown: []
+};
+var ENTITY_KEYWORDS = {
+  page: ["page", "route", "view", "screen", "layout"],
+  component: ["component", "widget", "element", "button", "form", "modal", "card", "dialog", "input", "dropdown", "table", "list", "nav", "navbar", "sidebar", "header", "footer", "menu"],
+  api: ["api", "endpoint", "route handler", "server action", "action", "mutation", "query", "rest", "graphql"],
+  hook: ["hook", "usecallback", "useeffect", "usestate", "usememo", "custom hook"],
+  util: ["util", "utility", "helper", "function", "service", "lib", "library"],
+  config: ["config", "configuration", "setting", "env", "environment"],
+  style: ["style", "css", "theme", "design", "color", "spacing", "typography"],
+  unknown: []
+};
+var FEATURE_KEYWORDS = {
+  auth: ["auth", "authentication", "login", "logout", "signup", "sign up", "sign in", "register", "password", "session", "oauth", "jwt", "credentials"],
+  dashboard: ["dashboard", "admin", "panel", "overview", "analytics", "stats", "metrics"],
+  payment: ["payment", "checkout", "billing", "stripe", "invoice", "subscription", "pricing"],
+  user: ["user", "profile", "account", "avatar", "settings", "preferences"],
+  search: ["search", "filter", "query", "find", "lookup"],
+  upload: ["upload", "file", "image", "media", "attachment", "storage"],
+  notification: ["notification", "alert", "email", "push", "toast", "banner"],
+  navigation: ["nav", "navbar", "navigation", "menu", "breadcrumb", "sidebar", "header"],
+  table: ["table", "grid", "list", "data table", "datagrid"],
+  form: ["form", "input", "field", "validation", "submit"],
+  chart: ["chart", "graph", "visualization", "plot", "diagram"]
+};
+function analyzeIntent(rawPrompt) {
+  const lower = rawPrompt.toLowerCase();
+  let action = "unknown";
+  for (const [act, keywords] of Object.entries(ACTION_KEYWORDS)) {
+    if (act === "unknown") continue;
+    if (keywords.some((k) => lower.includes(k))) {
+      action = act;
+      break;
+    }
+  }
+  let entity = "unknown";
+  for (const [ent, keywords] of Object.entries(ENTITY_KEYWORDS)) {
+    if (ent === "unknown") continue;
+    if (keywords.some((k) => lower.includes(k))) {
+      entity = ent;
+      break;
+    }
+  }
+  let feature = "general";
+  for (const [feat, keywords] of Object.entries(FEATURE_KEYWORDS)) {
+    if (keywords.some((k) => lower.includes(k))) {
+      feature = feat;
+      break;
+    }
+  }
+  return { action, entity, feature, rawPrompt };
+}
+
+// src/analyzer/context.ts
+import { readFile as readFile4 } from "fs/promises";
+import { join as join6 } from "path";
+import fg from "fast-glob";
+var FEATURE_PATTERNS = {
+  auth: ["*auth*", "*login*", "*logout*", "*session*", "*jwt*", "*token*", "*credential*", "*middleware*", "*guard*"],
+  dashboard: ["*dashboard*", "*admin*", "*overview*", "*analytics*"],
+  payment: ["*payment*", "*checkout*", "*billing*", "*stripe*", "*invoice*"],
+  user: ["*user*", "*profile*", "*account*", "*avatar*"],
+  upload: ["*upload*", "*file*", "*storage*", "*media*"],
+  notification: ["*notification*", "*alert*", "*email*", "*toast*"],
+  navigation: ["*nav*", "*navbar*", "*sidebar*", "*header*", "*menu*"],
+  table: ["*table*", "*grid*", "*list*"],
+  form: ["*form*", "*field*", "*input*"],
+  search: ["*search*", "*filter*"]
+};
+var ALWAYS_INCLUDE_PATTERNS = [
+  "app/layout.tsx",
+  "app/layout.ts",
+  "src/app/layout.tsx",
+  "pages/_app.tsx",
+  "pages/_app.ts",
+  "src/pages/_app.tsx"
+];
+var MAX_CHARS = 12e3;
+var MAX_FILE_LINES = 250;
+async function findRelevantFiles(root, intent, structure) {
+  const sections = [];
+  let charBudget = MAX_CHARS;
+  for (const pattern of ALWAYS_INCLUDE_PATTERNS) {
+    const content = await tryRead(join6(root, pattern));
+    if (content) {
+      const snippet = truncateLines(content, MAX_FILE_LINES);
+      const section = `// FILE: ${pattern}
+${snippet}`;
+      if (section.length < charBudget) {
+        sections.push(section);
+        charBudget -= section.length;
+      }
+    }
+  }
+  const featurePatterns = FEATURE_PATTERNS[intent.feature] ?? [];
+  if (featurePatterns.length > 0) {
+    const searchBase = structure.hasSrcDir ? join6(root, "src") : root;
+    const globs = featurePatterns.flatMap((p) => [
+      `**/${p}.{ts,tsx,js,jsx}`,
+      `**/${p}/{*.ts,*.tsx,*.js,*.jsx}`
+    ]);
+    let files = [];
+    try {
+      files = await fg(globs, {
+        cwd: searchBase,
+        ignore: ["**/node_modules/**", "**/.next/**", "**/dist/**"],
+        absolute: true,
+        onlyFiles: true
+      });
+    } catch {
+    }
+    for (const file of files.slice(0, 5)) {
+      if (charBudget <= 0) break;
+      const content = await tryRead(file);
+      if (!content) continue;
+      const relPath = file.replace(root + "/", "");
+      const snippet = truncateLines(content, MAX_FILE_LINES);
+      const section = `// FILE: ${relPath}
+${snippet}`;
+      if (section.length < charBudget) {
+        sections.push(section);
+        charBudget -= section.length;
+      }
+    }
+  }
+  if (["component", "page"].includes(intent.entity) && charBudget > 1e3) {
+    const componentDir = structure.hasSrcDir ? join6(root, "src", "components") : join6(root, "components");
+    let sampleFiles = [];
+    try {
+      sampleFiles = await fg("**/*.{tsx,jsx}", {
+        cwd: componentDir,
+        ignore: ["**/node_modules/**"],
+        absolute: true,
+        onlyFiles: true,
+        deep: 2
+      });
+    } catch {
+    }
+    for (const file of sampleFiles.slice(0, 2)) {
+      if (charBudget <= 500) break;
+      const content = await tryRead(file);
+      if (!content) continue;
+      const relPath = file.replace(root + "/", "");
+      const snippet = truncateLines(content, 80);
+      const section = `// FILE: ${relPath} (pattern reference)
+${snippet}`;
+      if (section.length < charBudget) {
+        sections.push(section);
+        charBudget -= section.length;
+      }
+    }
+  }
+  return sections.join("\n\n");
+}
+async function tryRead(path) {
+  try {
+    return await readFile4(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function truncateLines(content, maxLines) {
+  const lines = content.split("\n");
+  if (lines.length <= maxLines) return content;
+  return lines.slice(0, maxLines).join("\n") + `
+// ... (truncated at ${maxLines} lines)`;
+}
+
+// src/enhancer/injectors.ts
+function getInjections(stack, intent) {
+  const rules = [];
+  if (stack.language === "typescript") {
+    rules.push("Use TypeScript throughout \u2014 no `any`, prefer `unknown` with type guards");
+    rules.push("Export all interfaces and types");
+    if (intent.action === "create" || intent.action === "add") {
+      rules.push("Add Zod validation at all external data boundaries (API input, form submissions)");
+    }
+  }
+  if (stack.frameworks.includes("nextjs")) {
+    if (stack.nextRouterType === "app") {
+      rules.push('Use Server Components by default \u2014 only add "use client" when you need browser APIs or interactivity');
+      rules.push("Follow App Router conventions: page.tsx, layout.tsx, loading.tsx, error.tsx, route.ts");
+      rules.push("Use `next/navigation` (not `next/router`) for navigation in App Router");
+      rules.push("Prefer server actions for mutations over API route handlers when possible");
+    } else if (stack.nextRouterType === "pages") {
+      rules.push("Use `next/router` for navigation");
+      rules.push("Keep data fetching in `getServerSideProps` or `getStaticProps`");
+    }
+    rules.push("Never expose secrets in client-side code \u2014 use environment variables with NEXT_PUBLIC_ prefix only for public values");
+  }
+  if (stack.frameworks.includes("react") || stack.frameworks.includes("nextjs")) {
+    rules.push("Keep components small and focused on a single responsibility");
+    rules.push("Extract reusable logic into custom hooks");
+    rules.push("Use composition over prop drilling for shared state");
+    if (intent.entity === "component") {
+      rules.push("Make the component accessible \u2014 add aria labels, keyboard navigation, focus management");
+    }
+  }
+  if (stack.frameworks.includes("tailwind")) {
+    rules.push("Use Tailwind classes \u2014 no custom CSS unless unavoidable");
+    rules.push("Design mobile-first: base styles for mobile, `md:` / `lg:` for larger screens");
+  }
+  if (stack.frameworks.includes("shadcn")) {
+    rules.push("Use shadcn/ui components (Button, Input, Dialog, etc.) over building from scratch");
+    rules.push("Follow shadcn component patterns: import from `@/components/ui/`");
+  }
+  if (stack.orm === "prisma") {
+    rules.push("Use Prisma client for all database operations \u2014 no raw SQL unless required");
+    rules.push("Always wrap multi-step DB operations in a transaction");
+  } else if (stack.orm === "drizzle") {
+    rules.push("Use Drizzle schema and query builder \u2014 avoid raw SQL");
+  }
+  if (intent.feature === "auth") {
+    rules.push("Never store plain text passwords \u2014 use bcrypt or argon2");
+    rules.push("Use httpOnly, secure cookies for session tokens \u2014 never localStorage");
+    rules.push("Validate and sanitize all auth inputs server-side");
+    rules.push("Consider rate limiting on login/signup endpoints");
+    rules.push("Implement CSRF protection for state-changing auth operations");
+  }
+  if (intent.feature === "payment") {
+    rules.push("Never log or store raw card data \u2014 let Stripe/payment processor handle it");
+    rules.push("Always verify webhook signatures server-side");
+    rules.push("Use idempotency keys for payment operations");
+  }
+  if (intent.feature === "upload") {
+    rules.push("Validate file type and size server-side, not just client-side");
+    rules.push("Sanitize filenames before storage");
+    rules.push("Use presigned URLs for direct-to-storage uploads");
+  }
+  if (intent.entity === "api") {
+    rules.push("Return consistent response shape: `{ data, error, status }`");
+    rules.push("Handle errors explicitly \u2014 never let unhandled rejections leak to the client");
+    rules.push("Validate all input with Zod before processing");
+    rules.push("Use appropriate HTTP status codes");
+  }
+  rules.push("Match the existing code style and file naming conventions");
+  rules.push("List every file you create or modify at the end of your response");
+  rules.push("Prefer reusing existing utilities over creating new ones");
+  return rules;
+}
+
+// src/enhancer/template.ts
+function buildEnhancedPrompt(opts) {
+  const { stack, structure, intent, contextFiles, injections } = opts;
+  const stackLabel = formatStack(stack);
+  const structureLabel = formatStructure(structure);
+  const taskDescription = buildTaskDescription(intent);
+  const requirementsList = injections.map((r) => `- ${r}`).join("\n");
+  const contextSection = contextFiles ? `
+## Existing Code Context
+
+${contextFiles}` : "";
+  return `You are working inside a ${stackLabel} project.
+
+## Project Stack
+${formatStackDetails(stack)}
+
+## Project Structure
+${structureLabel}
+
+## Task
+${taskDescription}
+
+## Requirements
+${requirementsList}
+${contextSection}
+
+---
+Complete the task above. Follow every requirement. At the end, list every file you created or modified.`;
+}
+function formatStack(stack) {
+  const primary = stack.frameworks[0] ?? "Node.js";
+  const lang = stack.language === "typescript" ? "TypeScript" : "JavaScript";
+  return `${capitalize(primary)} ${lang}`;
+}
+function formatStackDetails(stack) {
+  const lines = [];
+  lines.push(`- **Language**: ${stack.language === "typescript" ? "TypeScript" : "JavaScript"}`);
+  if (stack.frameworks.length > 0) {
+    lines.push(`- **Frameworks**: ${stack.frameworks.map(capitalize).join(", ")}`);
+  }
+  if (stack.uiLibrary) {
+    lines.push(`- **UI Library**: ${capitalize(stack.uiLibrary)}`);
+  }
+  if (stack.orm) {
+    lines.push(`- **ORM**: ${capitalize(stack.orm)}`);
+  }
+  if (stack.testing) {
+    lines.push(`- **Testing**: ${capitalize(stack.testing)}`);
+  }
+  if (stack.nextRouterType) {
+    lines.push(`- **Next.js Router**: ${stack.nextRouterType === "app" ? "App Router" : "Pages Router"}`);
+  }
+  lines.push(`- **Package Manager**: ${stack.packageManager}`);
+  return lines.join("\n");
+}
+function formatStructure(structure) {
+  const lines = [];
+  if (structure.dirs.length > 0) {
+    lines.push(`Top-level directories: \`${structure.dirs.join("/")}\``);
+  }
+  if (structure.hasSrcDir && structure.srcDirs.length > 0) {
+    lines.push(`Inside src/: \`${structure.srcDirs.join("/")}\``);
+  }
+  if (structure.hasAppDir) lines.push("Uses Next.js App Router (`app/` directory)");
+  if (structure.hasPagesDir) lines.push("Uses Next.js Pages Router (`pages/` directory)");
+  return lines.join("\n") || "Standard project structure";
+}
+function buildTaskDescription(intent) {
+  const actionMap = {
+    create: "Create",
+    fix: "Fix",
+    refactor: "Refactor",
+    explain: "Explain",
+    add: "Add",
+    delete: "Remove",
+    unknown: "Handle"
+  };
+  const action = actionMap[intent.action] ?? "Handle";
+  return `${action}: ${intent.rawPrompt}`;
+}
+function capitalize(s) {
+  if (!s) return s;
+  const map = {
+    nextjs: "Next.js",
+    tailwind: "TailwindCSS",
+    shadcn: "shadcn/ui",
+    prisma: "Prisma",
+    drizzle: "Drizzle ORM",
+    nestjs: "NestJS",
+    typescript: "TypeScript",
+    javascript: "JavaScript",
+    vitest: "Vitest",
+    mui: "Material UI",
+    chakra: "Chakra UI"
+  };
+  return map[s] ?? s.charAt(0).toUpperCase() + s.slice(1);
+}
+
+// src/enhancer/index.ts
+function enhance(rawPrompt, scan, contextFiles) {
+  const intent = analyzeIntent(rawPrompt);
+  const injections = getInjections(scan.stack, intent);
+  const enhanced = buildEnhancedPrompt({
+    stack: scan.stack,
+    structure: scan.structure,
+    intent,
+    contextFiles,
+    injections
+  });
+  return { original: rawPrompt, enhanced, intent, stack: scan.stack };
+}
+
+// src/providers/claude.ts
+import Anthropic from "@anthropic-ai/sdk";
+var ClaudeProvider = class {
+  name = "Claude";
+  client;
+  model;
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new EnhanceError(
+        "MISSING_API_KEY",
+        "ANTHROPIC_API_KEY environment variable is not set."
+      );
+    }
+    this.client = new Anthropic({ apiKey: config.apiKey });
+    this.model = config.model;
+  }
+  async send(prompt) {
+    const stream = await this.client.messages.create({
+      model: this.model,
+      max_tokens: 8192,
+      system: "You are an expert software engineer. Follow instructions precisely. Write clean, idiomatic, production-ready code.",
+      messages: [{ role: "user", content: prompt }],
+      stream: true
+    });
+    for await (const event of stream) {
+      if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
+        process.stdout.write(event.delta.text);
+      }
+    }
+    process.stdout.write("\n");
+  }
+};
+
+// src/providers/codex.ts
+import { spawn } from "child_process";
+var CodexProvider = class {
+  name = "Codex";
+  async send(prompt) {
+    await runSubprocess("codex", [prompt]);
+  }
+};
+var OpenCodeProvider = class {
+  name = "OpenCode";
+  async send(prompt) {
+    await runSubprocess("opencode", ["run", prompt]);
+  }
+};
+function runSubprocess(cmd, args) {
+  return new Promise((resolve2, reject) => {
+    const child = spawn(cmd, args, { stdio: "inherit" });
+    child.on("error", (err) => {
+      if (err.code === "ENOENT") {
+        reject(new EnhanceError(
+          "PROVIDER_NOT_FOUND",
+          `Provider "${cmd}" is not installed or not in PATH. Install it first.`
+        ));
+      } else {
+        reject(err);
+      }
+    });
+    child.on("close", (code) => {
+      if (code === 0 || code === null) resolve2();
+      else reject(new EnhanceError("PROVIDER_ERROR", `${cmd} exited with code ${code}`));
+    });
+  });
+}
+
+// src/providers/index.ts
+function getProvider(config) {
+  switch (config.provider) {
+    case "claude":
+      return new ClaudeProvider(config);
+    case "codex":
+      return new CodexProvider();
+    case "opencode":
+      return new OpenCodeProvider();
+    default:
+      throw new EnhanceError(
+        "UNKNOWN_PROVIDER",
+        `Unknown provider "${config.provider}". Use: claude, codex, opencode`
+      );
+  }
+}
+
+// src/cli/setup.ts
+import { access, mkdir, writeFile as writeFile2 } from "fs/promises";
+import { join as join7 } from "path";
+import { homedir } from "os";
+import { execSync } from "child_process";
+import chalk2 from "chalk";
+var TOOLS = [
+  {
+    name: "Claude Code",
+    cliCommand: "claude",
+    commandsDir: join7(homedir(), ".claude", "commands"),
+    commandFile: "enhance.md"
+  },
+  {
+    name: "OpenCode",
+    cliCommand: "opencode",
+    commandsDir: join7(homedir(), ".opencode", "commands"),
+    commandFile: "enhance.md"
+  },
+  {
+    name: "Codex CLI",
+    cliCommand: "codex",
+    commandsDir: join7(homedir(), ".codex", "commands"),
+    commandFile: "enhance.md"
+  }
+];
+var ENHANCE_COMMAND_TEMPLATE = `Your job is to rewrite the following messy/vague prompt into a structured, detailed, production-quality prompt that will get dramatically better results from any AI coding agent.
+
+**Original prompt:** $ARGUMENTS
+
+---
+
+**Step 1 \u2014 Scan the project silently:**
+- Read \`package.json\` \u2192 detect frameworks, language, ORM, testing tools, UI library
+- Check for \`tsconfig.json\` \u2192 note path aliases
+- Scan folder structure \u2192 note \`app/\` vs \`pages/\` (Next.js router), \`src/\`, \`components/\`, \`lib/\`, \`hooks/\`
+- Read 1-2 existing files most relevant to the prompt topic (for pattern/convention reference)
+
+**Step 2 \u2014 Understand the intent:**
+- What is the user actually trying to build/fix/refactor?
+- What entity is involved? (page, component, API, hook, util)
+- What feature domain? (auth, payment, dashboard, upload, etc.)
+
+**Step 3 \u2014 Output the enhanced prompt in this exact format:**
+
+---
+## \u2726 Enhanced Prompt
+
+**Context:**
+[Project stack, folder conventions, existing patterns found]
+
+**Task:**
+[Rewrite the original request as a clear, specific, unambiguous instruction]
+
+**Requirements:**
+[8-15 specific requirements based on detected stack + task domain:]
+- Language/type safety (TypeScript, Zod, no \`any\`)
+- Framework rules (App Router, server components, next/navigation, etc.)
+- UI/styling (Tailwind, shadcn components)
+- Security if relevant (auth \u2192 bcrypt, httpOnly; API \u2192 input validation)
+- Code quality (match existing conventions, reuse utils, no unnecessary deps)
+- Output rule: list every file created/modified at the end
+
+**Relevant existing code:**
+[1-2 file snippets for reference, or "no relevant files found"]
+
+---
+
+**Step 4 \u2014 Ask the user:**
+> Does this look right? Reply **yes** to execute, **no** to refine, or edit any part of the prompt above.
+
+---
+
+**Step 5 \u2014 Handle the response:**
+
+If the user says **yes** \u2192 execute the enhanced prompt exactly as written above.
+
+If the user says **no** or gives feedback \u2192 do all of the following:
+1. Ask: "What's missing or wrong? (e.g. wrong framework assumed, missing requirement, task unclear)"
+2. Wait for their answer
+3. Revise the enhanced prompt incorporating their feedback
+4. Show the updated prompt in the same format above
+5. Ask again: "Better? Reply yes to execute or no to keep refining."
+6. Repeat this loop until the user says yes.
+
+If the user edits specific parts of the prompt \u2192 accept their edits, merge with the enhanced version, confirm, then execute.
+
+The goal: never execute until the user is satisfied with the enhanced prompt.
+`;
+function isInstalled(cmd) {
+  try {
+    execSync(`which ${cmd}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function installForTool(tool) {
+  try {
+    await mkdir(tool.commandsDir, { recursive: true });
+    const dest = join7(tool.commandsDir, tool.commandFile);
+    await writeFile2(dest, ENHANCE_COMMAND_TEMPLATE, "utf-8");
+    return "installed";
+  } catch {
+    return "error";
+  }
+}
+async function runSetup(opts) {
+  console.log(chalk2.bold("\nEnhance \u2014 Setup\n"));
+  const detected = [];
+  const notFound = [];
+  for (const tool of TOOLS) {
+    if (opts.all || isInstalled(tool.cliCommand)) {
+      detected.push(tool);
+    } else {
+      notFound.push(tool);
+    }
+  }
+  if (detected.length === 0) {
+    console.log(chalk2.yellow("No supported AI coding tools detected in PATH.\n"));
+    console.log("Supported tools:", TOOLS.map((t) => t.cliCommand).join(", "));
+    console.log("\nTo install for all tools anyway:");
+    console.log(chalk2.gray("  enhance setup --all\n"));
+    return;
+  }
+  console.log(chalk2.gray("Detected:"), detected.map((t) => t.name).join(", "));
+  if (notFound.length > 0) {
+    console.log(chalk2.gray("Not found:"), notFound.map((t) => t.name).join(", "));
+  }
+  console.log();
+  let anyInstalled = false;
+  for (const tool of detected) {
+    const dest = join7(tool.commandsDir, tool.commandFile);
+    const exists = await fileExists(dest);
+    if (exists && !opts.force) {
+      console.log(chalk2.yellow(`\u26A0 ${tool.name}`), chalk2.gray(`already installed \u2014 use --force to overwrite`));
+      continue;
+    }
+    const result = await installForTool(tool);
+    if (result === "installed") {
+      console.log(chalk2.green(`\u2713 ${tool.name}`), chalk2.gray(`\u2192 ${dest}`));
+      anyInstalled = true;
+    } else {
+      console.log(chalk2.red(`\u2717 ${tool.name}`), chalk2.gray(`failed to write to ${dest}`));
+    }
+  }
+  if (anyInstalled || detected.every((t) => fileExists(join7(t.commandsDir, t.commandFile)))) {
+    console.log(chalk2.bold("\nReady. In any project, type:\n"));
+    console.log(chalk2.cyan("  /enhance build a login page"));
+    console.log(chalk2.cyan("  /enhance fix the auth bug"));
+    console.log(chalk2.cyan("  /enhance refactor the user service\n"));
+  }
+}
+async function fileExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/cli/index.ts
+var program = new Command();
+program.name("enhance").description("AI prompt middleware \u2014 upgrades vague prompts into production-quality AI instructions").version("0.1.0");
+program.command("setup").description("Install the /enhance slash command for Claude Code, OpenCode, and Codex CLI").option("--force", "Overwrite existing installations").option("--all", "Install for all supported tools even if not detected in PATH").action(async (opts) => {
+  await runSetup(opts);
+});
+program.command("<prompt>", { isDefault: true }).description("Enhance a prompt and send to AI").addHelpText("after", `
+Examples:
+  enhance "build a login page"
+  enhance "fix the auth bug" --dry-run
+  enhance "create dashboard" --print-prompt --verbose
+  enhance "refactor user service" --provider codex`).option("-p, --provider <name>", "AI provider: claude | codex | opencode").option("--dry-run", "Print enhanced prompt without sending to AI").option("--print-prompt", "Print enhanced prompt before sending to AI").option("--verbose", "Show detected stack and intent").action(async (rawPrompt, opts) => {
+  if (!rawPrompt) {
+    program.help();
+    return;
+  }
+  const cwd = process.cwd();
+  const spinner = ora();
+  try {
+    spinner.start("Loading config...");
+    const config = await loadConfig(cwd);
+    if (opts.provider) config.provider = opts.provider;
+    spinner.text = "Scanning project...";
+    let scan = await getCached(cwd);
+    if (!scan) {
+      scan = await scanProject(cwd);
+      await setCached(cwd, scan);
+    }
+    spinner.text = "Analyzing intent...";
+    const intent = analyzeIntent(rawPrompt);
+    if (opts.verbose) {
+      spinner.stop();
+      console.log("\nStack detected:", JSON.stringify(scan.stack, null, 2));
+      console.log("\nIntent:", JSON.stringify(intent, null, 2));
+      spinner.start("Optimizing context...");
+    }
+    spinner.text = "Optimizing context...";
+    const contextFiles = await findRelevantFiles(cwd, intent, scan.structure);
+    spinner.text = "Enhancing prompt...";
+    const enhanced = enhance(rawPrompt, scan, contextFiles);
+    spinner.stop();
+    if (opts.dryRun || opts.printPrompt) {
+      console.log("\n\u2500\u2500\u2500 Enhanced Prompt \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n");
+      console.log(enhanced.enhanced);
+      console.log("\n\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n");
+    }
+    if (opts.dryRun) {
+      process.exit(0);
+    }
+    const provider = getProvider(config);
+    console.log(`
+[${provider.name}]
+`);
+    await provider.send(enhanced.enhanced);
+  } catch (err) {
+    spinner.stop();
+    if (err instanceof EnhanceError) {
+      error(err.message);
+      if (err.code === "MISSING_API_KEY") {
+        console.error("\nSet your API key: export ANTHROPIC_API_KEY=sk-...\n");
+      }
+      process.exit(1);
+    }
+    error("Unexpected error", err);
+    process.exit(1);
+  }
+});
+program.parse();

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@0xdevabir/enhance",
+  "version": "0.1.0",
+  "description": "AI prompt middleware — intelligently rewrites developer prompts before sending to coding agents",
+  "bin": {
+    "enhance": "./bin/enhance.js"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "README.md"
+  ],
+  "scripts": {
+    "dev": "tsx src/cli/index.ts",
+    "build": "tsup",
+    "start": "node bin/enhance.js",
+    "test": "vitest run",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/0xdevabir/agent-enhance.git"
+  },
+  "keywords": [
+    "ai",
+    "cli",
+    "prompt",
+    "developer-tools",
+    "claude",
+    "codex",
+    "opencode",
+    "prompt-engineering"
+  ],
+  "author": "0xdevabir",
+  "license": "MIT",
+  "type": "module",
+  "bugs": {
+    "url": "https://github.com/0xdevabir/agent-enhance/issues"
+  },
+  "homepage": "https://github.com/0xdevabir/agent-enhance#readme",
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.98.0",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
+    "cosmiconfig": "^9.0.1",
+    "fast-glob": "^3.3.3",
+    "ora": "^9.4.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.9.1",
+    "tsup": "^8.5.1",
+    "tsx": "^4.22.3",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.7"
+  }
+}