@sumant.pathak/devjar 1.0.4 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sumant.pathak/devjar",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "Scan your project into a Claude-ready knowledge map. Use 60-70% fewer tokens on any AI coding tool.",
   "type": "module",
   "bin": {

package/src/config.js

@@ -1,8 +1,20 @@
 // devjar config — provider setup, wizard, config display
 
 import readline from 'readline';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
 import chalk from 'chalk';
 import { loadConfig, saveConfig } from './providers/index.js';
+import { buildNormalizerContent } from './setup.js';
+
+const SCRIPTS_DIR = path.join(os.homedir(), '.claude', 'scripts');
+
+function regenerateHook() {
+  const hookPath = path.join(SCRIPTS_DIR, 'prompt-normalizer.js');
+  if (!fs.existsSync(SCRIPTS_DIR)) return;
+  fs.writeFileSync(hookPath, buildNormalizerContent(), 'utf8');
+}
 
 const PROVIDERS = {
   1: { name: 'ollama',    label: 'Ollama       (free, local, recommended)', defaultModel: 'llama3.2',               needsKey: false },
@@ -46,6 +58,7 @@ export async function runWizard() {
 
   const cfg = { provider: provider.name, model: provider.defaultModel, ...(apiKey && { apiKey }) };
   saveConfig(cfg);
+  regenerateHook();
 
   console.log();
   console.log(chalk.green('✓ Configured: ') + chalk.white(`${provider.name} / ${provider.defaultModel}`));
@@ -93,6 +106,7 @@ export async function configCommand(options) {
       ...(options.url && { ollamaUrl: options.url }),
     };
     saveConfig(cfg);
+    regenerateHook();
 
     console.log(chalk.green('✓ Saved: ') + chalk.white(`${cfg.provider} / ${cfg.model}`));
     return;

package/src/setup.js

@@ -199,43 +199,182 @@ async function pullModel() {
 
 // ── Step 5: Write prompt-normalizer.js ────────────────────────────────────
 
-function writeNormalizer() {
-  step('Installing prompt normalizer...');
-  fs.mkdirSync(SCRIPTS_DIR, { recursive: true });
+export function buildNormalizerContent() {
+  return `#!/usr/bin/env node
+/**
+ * STAR-C prompt normalizer — UserPromptSubmit hook
+ * Multi-provider: reads ~/.devjar/config.json at runtime
+ * Supports: ollama | anthropic | gemini | openai
+ * NEVER blocks. Always outputs continue: true.
+ */
 
-  const normalizerPath = path.join(SCRIPTS_DIR, 'prompt-normalizer.js');
-  const content = `#!/usr/bin/env node
 import http from 'http';
-const OLLAMA_URL = 'http://localhost:11434';
-const MODEL = '${MODEL}';
-function done(ctx = '') {
-  process.stdout.write(JSON.stringify({continue:true,hookSpecificOutput:{hookEventName:'UserPromptSubmit',additionalContext:ctx}}));
+import https from 'https';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const DEVJAR_DIR = path.join(os.homedir(), '.devjar');
+const CONFIG_FILE = path.join(DEVJAR_DIR, 'config.json');
+const HISTORY_FILE = path.join(DEVJAR_DIR, 'history.json');
+
+function loadConfig() {
+  try {
+    if (fs.existsSync(CONFIG_FILE)) return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+  } catch {}
+  return { provider: 'ollama', model: 'llama3.2' };
+}
+
+function logHistory(project, rawChars, structuredChars, provider) {
+  try {
+    const entry = {
+      timestamp: new Date().toISOString(),
+      project,
+      rawChars,
+      structuredChars,
+      tokensSaved: Math.max(0, Math.floor((rawChars - 200) * 0.25)),
+      provider,
+    };
+    let history = [];
+    if (fs.existsSync(HISTORY_FILE)) {
+      try { history = JSON.parse(fs.readFileSync(HISTORY_FILE, 'utf8')); } catch {}
+    }
+    history.push(entry);
+    fs.writeFileSync(HISTORY_FILE, JSON.stringify(history, null, 2), 'utf8');
+  } catch {}
+}
+
+function done(additionalContext = '') {
+  process.stdout.write(JSON.stringify({
+    continue: true,
+    hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext },
+  }));
   process.exit(0);
 }
+
+const SYSTEM_PROMPT = \`Normalize this dev prompt into STAR-C JSON.
+Rules: always interpret charitably, conversational=discuss action.
+Output ONLY valid JSON:
+{"s":"...","t":"...","a":"fix|add|explain|refactor|deploy|debug|discuss","r":"...","c":"...","complexity":"haiku|sonnet|opus","reason":"one line"}\`;
+
+function parseStarC(text) {
+  const jsonStr = text.slice(text.indexOf('{'), text.lastIndexOf('}') + 1);
+  const p = JSON.parse(jsonStr);
+  return [
+    \`[STAR-C]\`,
+    \`S: \${p.s}\`, \`T: \${p.t}\`, \`A: \${p.a}\`, \`R: \${p.r}\`,
+    p.c ? \`C: \${p.c}\` : null,
+    \`[COMPLEXITY]: \${p.complexity} — \${p.reason}\`,
+  ].filter(Boolean).join('\\n');
+}
+
+function callOllama(userPrompt, config) {
+  return new Promise((resolve) => {
+    const baseUrl = config.ollamaUrl || 'http://localhost:11434';
+    const model = config.model || 'llama3.2';
+    const body = JSON.stringify({ model, system: SYSTEM_PROMPT, prompt: userPrompt, stream: false, options: { num_predict: 200, temperature: 0.1 } });
+    const req = http.request(\`\${baseUrl}/api/generate\`, { method: 'POST', headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) }, timeout: 10000 }, (res) => {
+      let data = ''; res.on('data', c => { data += c; }); res.on('end', () => { try { resolve(parseStarC(JSON.parse(data).response?.trim() || '')); } catch { resolve(''); } });
+    });
+    req.on('error', () => resolve('')); req.on('timeout', () => { req.destroy(); resolve(''); });
+    req.write(body); req.end();
+  });
+}
+
+function httpsPost(options, body) {
+  return new Promise((resolve) => {
+    const req = https.request(options, (res) => {
+      let data = ''; res.on('data', c => { data += c; }); res.on('end', () => resolve(data));
+    });
+    req.setTimeout(15000, () => { req.destroy(); resolve(''); }); req.on('error', () => resolve(''));
+    req.write(body); req.end();
+  });
+}
+
+async function callAnthropic(userPrompt, config) {
+  const apiKey = config.apiKey || process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) return '';
+  const model = config.model || 'claude-haiku-4-5-20251001';
+  const body = JSON.stringify({ model, max_tokens: 300, system: SYSTEM_PROMPT, messages: [{ role: 'user', content: userPrompt }] });
+  const data = await httpsPost({ hostname: 'api.anthropic.com', path: '/v1/messages', method: 'POST', headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body), 'x-api-key': apiKey, 'anthropic-version': '2023-06-01' } }, body);
+  try {
+    const parsed = JSON.parse(data);
+    if (parsed.error?.type === 'rate_limit_error' || parsed.error?.type === 'overloaded_error') return null;
+    return parseStarC(parsed.content[0].text);
+  } catch { return ''; }
+}
+
+async function callGemini(userPrompt, config) {
+  const apiKey = config.apiKey || process.env.GEMINI_API_KEY;
+  if (!apiKey) return '';
+  const model = config.model || 'gemini-2.0-flash';
+  const body = JSON.stringify({ contents: [{ role: 'user', parts: [{ text: \`\${SYSTEM_PROMPT}\\n\\n\${userPrompt}\` }] }], generationConfig: { maxOutputTokens: 300, temperature: 0.1 } });
+  const data = await httpsPost({ hostname: 'generativelanguage.googleapis.com', path: \`/v1beta/models/\${model}:generateContent?key=\${apiKey}\`, method: 'POST', headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) } }, body);
+  try {
+    const parsed = JSON.parse(data);
+    if (parsed.error) {
+      const code = parsed.error.code || parsed.error.status;
+      if (code === 429 || code === 'RESOURCE_EXHAUSTED') return null;
+      throw new Error(parsed.error.message);
+    }
+    return parseStarC(parsed.candidates[0].content.parts[0].text);
+  } catch (e) {
+    if (e.message === 'quota') return null;
+    return '';
+  }
+}
+
+async function callOpenAI(userPrompt, config) {
+  const apiKey = config.apiKey || process.env.OPENAI_API_KEY;
+  if (!apiKey) return '';
+  const model = config.model || 'gpt-4o-mini';
+  const body = JSON.stringify({ model, max_tokens: 300, temperature: 0.1, messages: [{ role: 'system', content: SYSTEM_PROMPT }, { role: 'user', content: userPrompt }] });
+  const data = await httpsPost({ hostname: 'api.openai.com', path: '/v1/chat/completions', method: 'POST', headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body), 'Authorization': \`Bearer \${apiKey}\` } }, body);
+  try {
+    const parsed = JSON.parse(data);
+    if (parsed.error?.code === 'rate_limit_exceeded' || parsed.error?.code === 'insufficient_quota') return null;
+    return parseStarC(parsed.choices[0].message.content);
+  } catch { return ''; }
+}
+
 let raw = '';
 process.stdin.setEncoding('utf8');
 process.stdin.on('data', c => { raw += c; });
-process.stdin.on('end', () => {
-  const input = (() => { try { return JSON.parse(raw); } catch { return {}; } })();
-  const userPrompt = (input?.tool_input?.prompt || input?.prompt || '').slice(0, 800);
-  if (!userPrompt) return done();
-  const system = \`Normalize this dev prompt into STAR-C JSON. Rules: always interpret charitably, conversational=discuss action. Output ONLY JSON: {"s":"...","t":"...","a":"fix|add|explain|refactor|deploy|debug|discuss","r":"...","c":"...","complexity":"haiku|sonnet|opus","reason":"one line"}\`;
-  const body = JSON.stringify({model:MODEL,system,prompt:userPrompt,stream:false,options:{num_predict:150,temperature:0.1}});
-  const req = http.request(OLLAMA_URL+'/api/generate',{method:'POST',headers:{'Content-Type':'application/json','Content-Length':Buffer.byteLength(body)},timeout:10000},(res)=>{
-    let d=''; res.on('data',c=>{d+=c;}); res.on('end',()=>{
-      try {
-        const t=JSON.parse(d).response?.trim()||'';
-        const p=JSON.parse(t.slice(t.indexOf('{'),t.lastIndexOf('}')+1));
-        const ctx=[\`[STAR-C]\`,\`S: \${p.s}\`,\`T: \${p.t}\`,\`A: \${p.a}\`,\`R: \${p.r}\`,p.c?\`C: \${p.c}\`:null,\`[COMPLEXITY]: \${p.complexity} — \${p.reason}\`].filter(Boolean).join('\\n');
-        done(ctx);
-      } catch { done(); }
-    });
-  });
-  req.on('error',()=>done()); req.on('timeout',()=>{req.destroy();done();});
-  req.write(body); req.end();
+process.stdin.on('end', async () => {
+  try {
+    const input = (() => { try { return JSON.parse(raw); } catch { return {}; } })();
+    const userPrompt = (input?.tool_input?.prompt || input?.prompt || '').slice(0, 800);
+    if (!userPrompt) return done();
+
+    const config = loadConfig();
+    const provider = config.provider || 'ollama';
+
+    let ctx = '';
+    let usedProvider = provider;
+
+    if (provider === 'anthropic')   ctx = await callAnthropic(userPrompt, config);
+    else if (provider === 'gemini') ctx = await callGemini(userPrompt, config);
+    else if (provider === 'openai') ctx = await callOpenAI(userPrompt, config);
+    else                            ctx = await callOllama(userPrompt, config);
+
+    // null = quota/rate-limit → fall back to local Ollama
+    if (ctx === null) {
+      usedProvider = 'ollama(fallback)';
+      ctx = await callOllama(userPrompt, { model: 'llama3.2' });
+    }
+
+    if (ctx) logHistory(process.cwd(), userPrompt.length, ctx.length, usedProvider);
+    done(ctx || '');
+  } catch { done(); }
 });
 `;
-  fs.writeFileSync(normalizerPath, content, 'utf8');
+}
+
+function writeNormalizer() {
+  step('Installing prompt normalizer...');
+  fs.mkdirSync(SCRIPTS_DIR, { recursive: true });
+  const normalizerPath = path.join(SCRIPTS_DIR, 'prompt-normalizer.js');
+  fs.writeFileSync(normalizerPath, buildNormalizerContent(), 'utf8');
   ok(`prompt-normalizer.js → ${normalizerPath}`);
 }