@sumant.pathak/devjar 1.0.0

package/src/init.js

@@ -0,0 +1,388 @@
+// devjar init — 3-phase project scanner
+// Phase 1: Static analysis (offline)
+// Phase 2: Pattern extraction via single Haiku call
+// Phase 3: Write CLAUDE.md
+
+import fs from 'fs';
+import path from 'path';
+import Anthropic from '@anthropic-ai/sdk';
+import chalk from 'chalk';
+
+// ── Constants ──────────────────────────────────────────────────────────────
+
+const IGNORE_DIRS = new Set([
+  'node_modules', '.git', 'dist', '.next', 'out', 'build',
+  '.cache', 'coverage', '__pycache__', '.turbo', '.vercel', 'public'
+]);
+
+const BINARY_EXTS = new Set([
+  '.png', '.jpg', '.jpeg', '.gif', '.ico', '.svg', '.webp',
+  '.woff', '.woff2', '.ttf', '.eot', '.mp4', '.mp3', '.pdf',
+  '.zip', '.exe', '.dll', '.bin', '.map'
+]);
+
+const SKIP_FILES = new Set([
+  'package-lock.json', 'yarn.lock', 'pnpm-lock.yaml', 'bun.lockb',
+  '.env', '.env.local', '.env.production', '.DS_Store'
+]);
+
+// Entry point patterns — ordered by priority
+const ENTRY_PATTERNS = [
+  'src/index.js', 'src/index.ts', 'src/index.jsx', 'src/index.tsx',
+  'src/main.js', 'src/main.ts', 'src/main.jsx', 'src/main.tsx',
+  'src/App.jsx', 'src/App.tsx', 'src/app.js',
+  'server/index.js', 'workers/index.js',
+  'index.js', 'main.js', 'app.js', 'server.js',
+];
+
+// ── Spinner ────────────────────────────────────────────────────────────────
+
+function spinner(msg) {
+  const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+  let i = 0;
+  const id = setInterval(() => {
+    process.stdout.write(`\r${chalk.cyan(frames[i++ % frames.length])} ${chalk.yellow(msg)}`);
+  }, 80);
+  return () => {
+    clearInterval(id);
+    process.stdout.write('\r' + ' '.repeat(60) + '\r');
+  };
+}
+
+// ── Phase 1: Static Analysis ───────────────────────────────────────────────
+
+export function walkDir(dir, baseDir, depth = 0, maxDepth = 2) {
+  const entries = [];
+  if (depth > maxDepth) return entries;
+  let items;
+  try { items = fs.readdirSync(dir, { withFileTypes: true }); } catch { return entries; }
+
+  for (const item of items) {
+    if (item.name.startsWith('.') && item.name !== '.env.example') continue;
+    if (IGNORE_DIRS.has(item.name)) continue;
+
+    const fullPath = path.join(dir, item.name);
+    const relPath = path.relative(baseDir, fullPath).replace(/\\/g, '/');
+
+    if (item.isDirectory()) {
+      entries.push({ type: 'dir', path: relPath, name: item.name });
+      entries.push(...walkDir(fullPath, baseDir, depth + 1, maxDepth));
+    } else if (item.isFile()) {
+      const ext = path.extname(item.name).toLowerCase();
+      if (BINARY_EXTS.has(ext) || SKIP_FILES.has(item.name)) continue;
+      const size = fs.statSync(fullPath).size;
+      entries.push({ type: 'file', path: relPath, name: item.name, size });
+    }
+  }
+  return entries;
+}
+
+export function readJsonSafe(filePath) {
+  try { return JSON.parse(fs.readFileSync(filePath, 'utf8')); } catch { return null; }
+}
+
+function readFileSafe(filePath) {
+  try { return fs.readFileSync(filePath, 'utf8'); } catch { return null; }
+}
+
+export function detectStack(pkg, files, hasWrangler) {
+  if (!pkg) return { name: 'Unknown', stack: [], scripts: {} };
+
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+  const stack = [];
+
+  if (deps['next']) stack.push('Next.js');
+  else if (deps['react']) stack.push('React');
+  if (deps['vue']) stack.push('Vue');
+  if (deps['svelte']) stack.push('Svelte');
+  if (deps['vite']) stack.push('Vite');
+  if (deps['typescript'] || deps['ts-node']) stack.push('TypeScript');
+  if (deps['express']) stack.push('Express');
+  if (deps['fastify']) stack.push('Fastify');
+  if (deps['hono']) stack.push('Hono');
+  if (hasWrangler || deps['wrangler']) stack.push('Cloudflare Workers');
+  if (deps['@prisma/client']) stack.push('Prisma');
+  if (deps['drizzle-orm']) stack.push('Drizzle ORM');
+  if (deps['tailwindcss']) stack.push('Tailwind CSS');
+  if (stack.length === 0) stack.push('Node.js');
+
+  return { name: pkg.name || 'project', stack, scripts: pkg.scripts || {} };
+}
+
+function parseWranglerToml(content) {
+  const bindings = {};
+  const lines = content.split('\n');
+  let section = '';
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith('[')) section = trimmed;
+
+    // D1 databases
+    if (section.includes('d1_databases')) {
+      const bMatch = trimmed.match(/binding\s*=\s*"([^"]+)"/);
+      if (bMatch) bindings.D1 = (bindings.D1 || []).concat(bMatch[1]);
+    }
+    // KV namespaces
+    if (section.includes('kv_namespaces')) {
+      const bMatch = trimmed.match(/binding\s*=\s*"([^"]+)"/);
+      if (bMatch) bindings.KV = (bindings.KV || []).concat(bMatch[1]);
+    }
+    // R2
+    if (section.includes('r2_buckets')) {
+      const bMatch = trimmed.match(/binding\s*=\s*"([^"]+)"/);
+      if (bMatch) bindings.R2 = (bindings.R2 || []).concat(bMatch[1]);
+    }
+    // Routes
+    const routeMatch = trimmed.match(/^pattern\s*=\s*"([^"]+)"/);
+    if (routeMatch) bindings.routes = (bindings.routes || []).concat(routeMatch[1]);
+    // Name
+    const nameMatch = trimmed.match(/^name\s*=\s*"([^"]+)"/);
+    if (nameMatch && !bindings.workerName) bindings.workerName = nameMatch[1];
+  }
+  return bindings;
+}
+
+export function buildFileTree(entries) {
+  const lines = [];
+  for (const e of entries) {
+    const depth = e.path.split('/').length - 1;
+    const indent = '  '.repeat(depth);
+    const icon = e.type === 'dir' ? '📁' : '📄';
+    lines.push(`${indent}${icon} ${e.name}`);
+  }
+  return lines.join('\n');
+}
+
+// ── Phase 2: Key File Selection ─────────────────────────────────────────────
+
+export function pickKeyFiles(baseDir, allFiles) {
+  const selected = [];
+
+  // 1. Entry point
+  for (const pattern of ENTRY_PATTERNS) {
+    if (allFiles.some(f => f.path === pattern)) {
+      selected.push(pattern);
+      break;
+    }
+  }
+
+  // 2. Largest file in src/ (likely most complex component/route)
+  const srcFiles = allFiles
+    .filter(f => f.type === 'file' && f.path.startsWith('src/') && !selected.includes(f.path))
+    .sort((a, b) => b.size - a.size);
+  if (srcFiles[0]) selected.push(srcFiles[0].path);
+  if (srcFiles[1] && srcFiles[1].path !== srcFiles[0]?.path) selected.push(srcFiles[1].path);
+
+  // 3. Main route/api file
+  const routeFile = allFiles.find(f =>
+    f.type === 'file' && (
+      f.path.includes('routes/auth') || f.path.includes('routes/index') ||
+      f.path.includes('api/index') || f.path.includes('pages/api') ||
+      f.path.includes('router') || f.path.includes('routes.')
+    ) && !selected.includes(f.path)
+  );
+  if (routeFile) selected.push(routeFile.path);
+
+  // Read contents (truncated to ~400 chars each to stay under token limit)
+  const fileData = [];
+  for (const relPath of selected.slice(0, 5)) {
+    const content = readFileSafe(path.join(baseDir, relPath));
+    if (content) {
+      fileData.push(`// FILE: ${relPath}\n${content.slice(0, 400)}${content.length > 400 ? '\n// [truncated]' : ''}`);
+    }
+  }
+  return { paths: selected, contents: fileData };
+}
+
+// ── Phase 2: Haiku Call ─────────────────────────────────────────────────────
+
+export async function extractPatterns(fileContents) {
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) return null;
+
+  const client = new Anthropic({ apiKey });
+
+  const userMsg = `Analyze these project files and extract coding patterns.
+
+${fileContents.join('\n\n---\n\n')}
+
+Return ONLY valid JSON, no markdown:
+{
+  "naming": "description of naming convention used",
+  "imports": "named/default/mixed — describe pattern",
+  "errorHandling": "how errors are handled",
+  "stateManagement": "how state is managed",
+  "rules": [
+    "rule 1 — must follow exactly",
+    "rule 2",
+    "rule 3",
+    "rule 4",
+    "rule 5"
+  ]
+}`;
+
+  const msg = await client.messages.create({
+    model: 'claude-haiku-4-5-20251001',
+    max_tokens: 600,
+    messages: [{ role: 'user', content: userMsg }],
+  });
+
+  try {
+    const text = msg.content[0].text.trim();
+    const jsonStr = text.startsWith('{') ? text : text.slice(text.indexOf('{'));
+    return JSON.parse(jsonStr);
+  } catch {
+    return null;
+  }
+}
+
+// ── Phase 3: Write CLAUDE.md ───────────────────────────────────────────────
+
+function generateClaudeMd(opts) {
+  const { projectName, stack, scripts, allFiles, wranglerBindings, keyFilePaths, patterns, fileTree } = opts;
+
+  const stackLine = stack.length ? stack.join(' + ') : 'Node.js';
+
+  // File map — key files with purpose guesses
+  const fileMapLines = [];
+  for (const f of allFiles.filter(e => e.type === 'file').slice(0, 30)) {
+    fileMapLines.push(`  ${f.path}`);
+  }
+
+  // Scripts section
+  const scriptLines = Object.entries(scripts)
+    .map(([k, v]) => `  ${k}: ${v}`)
+    .join('\n');
+
+  // Rules
+  const rules = patterns?.rules || [
+    'Match existing naming conventions before adding new code',
+    'Never write files outside the project root',
+    'Read the key files listed in Project Map before editing',
+  ];
+  const rulesText = rules.slice(0, 7).map((r, i) => `${i + 1}. ${r}`).join('\n');
+
+  // Bindings
+  let bindingsSection = '';
+  if (wranglerBindings && Object.keys(wranglerBindings).length) {
+    const lines = [];
+    if (wranglerBindings.workerName) lines.push(`Worker: ${wranglerBindings.workerName}`);
+    if (wranglerBindings.D1) lines.push(`D1 (binding): ${wranglerBindings.D1.join(', ')}`);
+    if (wranglerBindings.KV) lines.push(`KV (binding): ${wranglerBindings.KV.join(', ')}`);
+    if (wranglerBindings.R2) lines.push(`R2 (binding): ${wranglerBindings.R2.join(', ')}`);
+    if (wranglerBindings.routes) lines.push(`Routes: ${wranglerBindings.routes.join(', ')}`);
+    bindingsSection = `\n## Bindings & Config\n${lines.join('\n')}\n`;
+  }
+
+  // Key patterns
+  const patternsSection = patterns ? `
+## Key Patterns
+- **Naming**: ${patterns.naming}
+- **Imports**: ${patterns.imports}
+- **Error handling**: ${patterns.errorHandling}
+- **State management**: ${patterns.stateManagement}
+` : '';
+
+  return `# ${projectName} — Claude Code Orientation
+
+## Stack
+${stackLine}
+
+${scriptLines ? `## Scripts\n${scriptLines}\n` : ''}
+## Project Map
+${fileTree}
+
+## Key Files Analyzed
+${keyFilePaths.map(p => `- ${p}`).join('\n')}
+${patternsSection}
+## Unbreakable Rules
+${rulesText}
+${bindingsSection}
+---
+*Generated by devjar init — do not edit manually, run \`devjar init\` to regenerate*
+`;
+}
+
+// ── Main Export ────────────────────────────────────────────────────────────
+
+export async function init(dir = '.', options = {}) {
+  const baseDir = path.resolve(dir);
+  const maxDepth = parseInt(options.depth || '2', 10);
+
+  if (!fs.existsSync(baseDir)) {
+    console.error(chalk.red(`✗ Directory not found: ${baseDir}`));
+    process.exit(1);
+  }
+
+  console.log(chalk.bold.blue('⬡ devjar') + chalk.gray(` init → ${baseDir}`));
+  console.log(chalk.gray('─'.repeat(52)));
+
+  // ── Phase 1 ──
+  console.log(chalk.bold.white('Phase 1') + chalk.gray('  Scanning project structure...'));
+
+  const allEntries = walkDir(baseDir, baseDir, 0, maxDepth);
+  const fileCount = allEntries.filter(e => e.type === 'file').length;
+
+  const pkg = readJsonSafe(path.join(baseDir, 'package.json'));
+  const wranglerRaw = readFileSafe(path.join(baseDir, 'wrangler.toml'));
+  const wranglerBindings = wranglerRaw ? parseWranglerToml(wranglerRaw) : null;
+
+  const { name: projectName, stack, scripts } = detectStack(pkg, allEntries, !!wranglerRaw);
+  const fileTree = buildFileTree(allEntries);
+
+  console.log(
+    chalk.green('  ✓') +
+    chalk.white(` ${fileCount} files`) +
+    chalk.gray(' | Stack: ') +
+    chalk.cyan(stack.join(' + ') || 'Node.js')
+  );
+
+  // ── Phase 2 ──
+  const { paths: keyFilePaths, contents: keyFileContents } = pickKeyFiles(baseDir, allEntries);
+  let patterns = null;
+
+  console.log(chalk.bold.white('Phase 2') + chalk.gray('  Pattern extraction via Haiku...'));
+  if (keyFileContents.length > 0 && process.env.ANTHROPIC_API_KEY) {
+    const stop = spinner('  Calling Haiku...');
+    try {
+      patterns = await extractPatterns(keyFileContents);
+    } finally {
+      stop();
+    }
+    if (patterns) {
+      console.log(
+        chalk.green('  ✓') +
+        chalk.white(` ${patterns.rules?.length || 0} rules extracted`) +
+        chalk.gray(` from ${keyFilePaths.length} key files`)
+      );
+    } else {
+      console.log(chalk.yellow('  ⚠ Haiku response could not be parsed — using defaults'));
+    }
+  } else if (!process.env.ANTHROPIC_API_KEY) {
+    console.log(chalk.yellow('  ⚠ ANTHROPIC_API_KEY not set — skipping (offline mode)'));
+  }
+
+  // ── Phase 3 ──
+  console.log(chalk.bold.white('Phase 3') + chalk.gray('  Writing CLAUDE.md...'));
+
+  const content = generateClaudeMd({
+    projectName, stack, scripts, allFiles: allEntries,
+    wranglerBindings, keyFilePaths, patterns, fileTree,
+  });
+
+  const outputPath = options.output
+    ? path.resolve(options.output)
+    : path.join(baseDir, 'CLAUDE.md');
+
+  fs.writeFileSync(outputPath, content, 'utf8');
+
+  const ruleCount = patterns?.rules?.length || 3;
+  console.log(chalk.gray('─'.repeat(52)));
+  console.log(
+    chalk.bold.green('✓ CLAUDE.md generated') +
+    chalk.gray(` — ${fileCount} files scanned, `) +
+    chalk.white(`${ruleCount} rules extracted`)
+  );
+  console.log(chalk.gray('  → ') + chalk.underline.cyan(outputPath));
+}

package/src/prompt.js

@@ -0,0 +1,135 @@
+// devjar prompt — STAR-C normalizer
+// Provider-agnostic: works with ollama (free/local), anthropic, gemini, openai
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import readline from 'readline';
+import clipboard from 'clipboardy';
+import chalk from 'chalk';
+import { loadConfig, getProvider, buildSystemPrompt } from './providers/index.js';
+import { runWizard } from './config.js';
+
+const HISTORY_FILE = path.join(os.homedir(), '.devjar', 'history.json');
+const MAX_HISTORY = 100;
+
+// ── Helpers ────────────────────────────────────────────────────────────────
+
+function findClaudeMd() {
+  for (const loc of [path.join(process.cwd(), 'CLAUDE.md'), path.join(process.cwd(), '..', 'CLAUDE.md')]) {
+    if (fs.existsSync(loc)) return fs.readFileSync(loc, 'utf8');
+  }
+  return null;
+}
+
+function readProjectName() {
+  try { return JSON.parse(fs.readFileSync(path.join(process.cwd(), 'package.json'), 'utf8')).name || path.basename(process.cwd()); }
+  catch { return path.basename(process.cwd()); }
+}
+
+function spinner(msg) {
+  const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+  let i = 0;
+  const id = setInterval(() => process.stdout.write(`\r${chalk.cyan(frames[i++ % frames.length])} ${chalk.yellow(msg)}`), 80);
+  return () => { clearInterval(id); process.stdout.write('\r' + ' '.repeat(60) + '\r'); };
+}
+
+function ask(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise(resolve => rl.question(question, ans => { rl.close(); resolve(ans.trim()); }));
+}
+
+function saveHistory(entry) {
+  try {
+    const dir = path.dirname(HISTORY_FILE);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    let h = fs.existsSync(HISTORY_FILE) ? JSON.parse(fs.readFileSync(HISTORY_FILE, 'utf8')) : [];
+    h.unshift(entry);
+    if (h.length > MAX_HISTORY) h = h.slice(0, MAX_HISTORY);
+    fs.writeFileSync(HISTORY_FILE, JSON.stringify(h, null, 2), 'utf8');
+  } catch {}
+}
+
+function displayResult(structured) {
+  console.log();
+  console.log(chalk.bold.blue('─── STAR-C Prompt ') + chalk.gray('─'.repeat(34)));
+  const colors = { S: chalk.cyan, T: chalk.green, A: chalk.yellow, R: chalk.magenta, C: chalk.red };
+  for (const line of structured.split('\n')) {
+    const m = line.match(/^([STARC])\s*[—\-–]\s*(.*)/);
+    if (m) console.log((colors[m[1]] || chalk.white).bold(`${m[1]} —`) + chalk.white(` ${m[2]}`));
+    else if (line.trim()) console.log(chalk.gray('    ') + chalk.white(line));
+  }
+  console.log(chalk.gray('─'.repeat(52)));
+  console.log();
+}
+
+// ── Main Export ────────────────────────────────────────────────────────────
+
+export async function prompt(textParts = [], options = {}) {
+  console.log(chalk.bold.blue('⬡ devjar') + chalk.gray(' prompt'));
+  console.log(chalk.gray('─'.repeat(52)));
+
+  // ── First run: no config → wizard ──
+  let config = loadConfig();
+  if (!config) {
+    console.log(chalk.yellow('No provider configured — running setup wizard...\n'));
+    config = await runWizard();
+  }
+
+  const providerLabel = chalk.cyan(config.provider) + chalk.gray(`/${config.model}`);
+  console.log(chalk.gray('  Provider: ') + providerLabel);
+
+  // ── Get input ──
+  let rawInput;
+  if (textParts.length > 0) {
+    rawInput = textParts.join(' ');
+    console.log(chalk.gray('  Input:    ') + chalk.white(rawInput));
+  } else {
+    console.log(chalk.gray('\nInteractive mode — describe what you want to do:'));
+    rawInput = await ask(chalk.cyan('> '));
+    if (!rawInput) { console.log(chalk.yellow('No input. Exiting.')); process.exit(0); }
+  }
+
+  // ── Load context ──
+  const projectName = readProjectName();
+  const claudeMd = findClaudeMd();
+  if (claudeMd) {
+    console.log(chalk.green('  ✓') + chalk.gray(` CLAUDE.md loaded (${claudeMd.length} chars)`));
+  } else {
+    console.log(chalk.yellow('  ⚠ No CLAUDE.md — run `devjar init` for better results'));
+  }
+
+  // ── Normalize ──
+  const stop = spinner(`Normalizing via ${config.provider}...`);
+  let structured;
+  try {
+    const provider = await getProvider(config);
+    const systemPrompt = buildSystemPrompt(claudeMd, projectName);
+    structured = await provider.normalize(rawInput, systemPrompt, config);
+  } catch (e) {
+    stop();
+    console.log(chalk.red('\n✗ ' + e.message));
+    process.exit(1);
+  }
+  stop();
+
+  // ── Display ──
+  displayResult(structured);
+
+  // ── Clipboard ──
+  const answer = await ask(chalk.bold('Copy to clipboard?') + chalk.gray(' (Y/n) '));
+  if (answer === '' || answer.toLowerCase() === 'y') {
+    try {
+      await clipboard.write(structured);
+      console.log(chalk.bold.green('✓ Copied'));
+    } catch {
+      console.log(chalk.yellow('⚠ Clipboard unavailable'));
+    }
+  } else {
+    console.log(chalk.gray('Skipped.'));
+  }
+
+  // ── History ──
+  saveHistory({ timestamp: new Date().toISOString(), project: projectName, provider: config.provider, original: rawInput, structured });
+  console.log(chalk.gray(`  Saved to history`));
+}

package/src/providers/anthropic.js

@@ -0,0 +1,27 @@
+// Provider: Anthropic — Haiku (fast, cheap)
+// Requires: ANTHROPIC_API_KEY or key in ~/.devjar/config.json
+
+export const name = 'anthropic';
+export const defaultModel = 'claude-haiku-4-5-20251001';
+
+export async function normalize(userPrompt, systemPrompt, config = {}) {
+  const apiKey = config.apiKey || process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) {
+    throw new Error(
+      'Anthropic API key required.\n' +
+      '  Set it:  devjar config --provider anthropic --key sk-ant-...\n' +
+      '  Or use:  export ANTHROPIC_API_KEY=sk-ant-...'
+    );
+  }
+
+  const { default: Anthropic } = await import('@anthropic-ai/sdk');
+  const client = new Anthropic({ apiKey });
+  const msg = await client.messages.create({
+    model: config.model || defaultModel,
+    max_tokens: 500,
+    system: systemPrompt,
+    messages: [{ role: 'user', content: userPrompt }],
+  });
+
+  return msg.content[0].text.trim();
+}

package/src/providers/gemini.js

@@ -0,0 +1,37 @@
+// Provider: Google Gemini — gemini-2.0-flash (free tier available)
+// Requires: API key from https://aistudio.google.com
+
+export const name = 'gemini';
+export const defaultModel = 'gemini-2.0-flash';
+
+export async function normalize(userPrompt, systemPrompt, config = {}) {
+  const apiKey = config.apiKey || process.env.GEMINI_API_KEY;
+  if (!apiKey) {
+    throw new Error(
+      'Gemini API key required.\n' +
+      '  Get free key: https://aistudio.google.com\n' +
+      '  Set it: devjar config --provider gemini --key AIza...'
+    );
+  }
+
+  const model = config.model || defaultModel;
+  const url = `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${apiKey}`;
+
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      system_instruction: { parts: [{ text: systemPrompt }] },
+      contents: [{ role: 'user', parts: [{ text: userPrompt }] }],
+      generationConfig: { maxOutputTokens: 500 },
+    }),
+  });
+
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({}));
+    throw new Error(`Gemini error ${res.status}: ${err?.error?.message || res.statusText}`);
+  }
+
+  const data = await res.json();
+  return data.candidates?.[0]?.content?.parts?.[0]?.text?.trim() || '';
+}

package/src/providers/index.js

@@ -0,0 +1,54 @@
+// Provider router — picks provider from config, builds system prompt
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const CONFIG_FILE = path.join(os.homedir(), '.devjar', 'config.json');
+
+export function loadConfig() {
+  try {
+    if (fs.existsSync(CONFIG_FILE)) return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+  } catch {}
+  return null;
+}
+
+export function saveConfig(cfg) {
+  const dir = path.dirname(CONFIG_FILE);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(cfg, null, 2), 'utf8');
+}
+
+export function buildSystemPrompt(claudeMdContent, projectName) {
+  const context = claudeMdContent
+    ? claudeMdContent.slice(0, 2000)
+    : `Project: ${projectName}\nNo CLAUDE.md — run devjar init for better results.`;
+
+  return `You are a senior developer's prompt engineer.
+Given a vague request and project context below, restructure into STAR-C format:
+
+S — Situation: what exists right now (1 line)
+T — Task: exactly what to build/fix (1 line)
+A — Action: how to do it, which files (2-3 lines)
+R — Result: what done looks like (1 line)
+C — Constraints: what NOT to do (2-3 lines)
+
+Project context:
+${context}
+
+Be concise. Output only the STAR-C prompt. No preamble. No explanation.`;
+}
+
+export async function getProvider(config) {
+  const providerName = config?.provider || 'ollama';
+  const providers = {
+    ollama:    () => import('./ollama.js'),
+    anthropic: () => import('./anthropic.js'),
+    gemini:    () => import('./gemini.js'),
+    openai:    () => import('./openai.js'),
+  };
+
+  const loader = providers[providerName];
+  if (!loader) throw new Error(`Unknown provider "${providerName}". Choose: ${Object.keys(providers).join(', ')}`);
+  return loader();
+}

package/src/providers/ollama.js

@@ -0,0 +1,40 @@
+// Provider: Ollama — free, local, no API key needed
+// Requires: ollama running at localhost:11434
+// Install:  https://ollama.com → then: ollama pull llama3.2
+
+export const name = 'ollama';
+export const defaultModel = 'llama3.2';
+
+export async function normalize(userPrompt, systemPrompt, config = {}) {
+  const base = config.ollamaUrl || 'http://localhost:11434';
+  const model = config.model || defaultModel;
+
+  let res;
+  try {
+    res = await fetch(`${base}/api/generate`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ model, system: systemPrompt, prompt: userPrompt, stream: false }),
+      signal: AbortSignal.timeout(30000),
+    });
+  } catch (e) {
+    if (e.cause?.code === 'ECONNREFUSED' || e.name === 'TimeoutError') {
+      throw new Error(
+        'Ollama is not running.\n' +
+        '  Start it:  ollama serve\n' +
+        '  Install:   https://ollama.com\n' +
+        `  Then pull: ollama pull ${model}`
+      );
+    }
+    throw e;
+  }
+
+  if (!res.ok) {
+    const body = await res.text();
+    if (res.status === 404) throw new Error(`Model "${model}" not found.\n  Run: ollama pull ${model}`);
+    throw new Error(`Ollama error ${res.status}: ${body}`);
+  }
+
+  const data = await res.json();
+  return data.response.trim();
+}