phewsh 0.5.3 → 0.6.0

package/bin/phewsh.js

@@ -44,6 +44,7 @@ const COMMANDS = {
   link:    () => require('../commands/link'),
   login:   () => require('../commands/login'),
   ai:      () => require('../commands/ai'),
+  style:   () => require('../commands/style'),
   music:   () => require('../commands/music'),
   sap:     () => require('../commands/sap'),
   help:    showHelp,
@@ -67,6 +68,7 @@ function showHelp() {
   console.log(`    ${w('ai')}        Run context-aware AI prompts (reads .intent/)`);
   console.log(`    ${w('login')}     Set up identity, API key, and cloud sync`);
   console.log(`    ${w('sap')}       Sustainable AI Protocol — usage and accountability`);
+  console.log(`    ${w('style')}     Build your style identity — ingest, profile, sync`);
   console.log(`    ${w('music')}     MBHD music engine`);
   console.log('');
   console.log(`  ${b('Quick start')}`);

package/commands/ai.js

@@ -1,6 +1,7 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const { trackSap } = require('../lib/supabase');
 
 const CONFIG_PATH = path.join(os.homedir(), '.phewsh', 'config.json');
 const INTENT_DIR = path.join(process.cwd(), '.intent');
@@ -35,14 +36,10 @@ function buildSystemPrompt(intentFiles) {
   return `You are a focused execution assistant. The user has structured intent artifacts that define what they are building. Use these as your primary context for every response — stay aligned with their vision, plan, and next actions.\n\n${sections}`;
 }
 
-async function streamResponse(apiKey, systemPrompt, userPrompt) {
+async function streamResponse(apiKey, systemPrompt, userPrompt, userId, accessToken) {
+  const model = 'claude-sonnet-4-6';
   const messages = [{ role: 'user', content: userPrompt }];
-  const body = {
-    model: 'claude-sonnet-4-6',
-    max_tokens: 1024,
-    messages,
-    stream: true,
-  };
+  const body = { model, max_tokens: 1024, messages, stream: true };
   if (systemPrompt) body.system = systemPrompt;
 
   const response = await fetch('https://api.anthropic.com/v1/messages', {
@@ -62,6 +59,9 @@ async function streamResponse(apiKey, systemPrompt, userPrompt) {
 
   process.stdout.write('\n');
 
+  let promptTokens = null;
+  let completionTokens = null;
+
   for await (const chunk of response.body) {
     const text = Buffer.from(chunk).toString('utf-8');
     const lines = text.split('\n').filter(l => l.startsWith('data: '));
@@ -73,11 +73,21 @@ async function streamResponse(apiKey, systemPrompt, userPrompt) {
         if (parsed.type === 'content_block_delta' && parsed.delta?.text) {
           process.stdout.write(parsed.delta.text);
         }
+        // Capture token counts from Anthropic stream
+        if (parsed.type === 'message_start' && parsed.message?.usage) {
+          promptTokens = parsed.message.usage.input_tokens;
+        }
+        if (parsed.type === 'message_delta' && parsed.usage) {
+          completionTokens = parsed.usage.output_tokens;
+        }
       } catch { /* skip malformed chunks */ }
     }
   }
 
   process.stdout.write('\n\n');
+
+  // SAP: fire-and-forget after stream completes
+  trackSap({ userId, source: 'cli', model, promptTokens, completionTokens, accessToken });
 }
 
 async function main() {
@@ -135,7 +145,7 @@ async function main() {
       console.log('\n  No .intent/ found — running without project context');
     }
 
-    await streamResponse(config.apiKey, systemPrompt, prompt);
+    await streamResponse(config.apiKey, systemPrompt, prompt, config.supabaseUserId, config.supabaseAccessToken);
     return;
   }
 

package/commands/style.js

@@ -0,0 +1,320 @@
+// phewsh style — build and manage your StyleTree identity
+// Pipeline: ingest → extract features → rebuild profile → display
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const readline = require('readline');
+const { select, upsert, SUPABASE_URL, SUPABASE_ANON_KEY } = require('../lib/supabase');
+
+const CONFIG_PATH = path.join(os.homedir(), '.phewsh', 'config.json');
+const STYLE_CACHE_DIR = path.join(os.homedir(), '.phewsh', 'styletree');
+
+// ── ANSI
+const b = (s) => `\x1b[1m${s}\x1b[0m`;
+const d = (s) => `\x1b[2m${s}\x1b[0m`;
+const g = (s) => `\x1b[90m${s}\x1b[0m`;
+const c = (s) => `\x1b[36m${s}\x1b[0m`;
+const y = (s) => `\x1b[33m${s}\x1b[0m`;
+
+function loadConfig() {
+  try { return JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8')); } catch { return null; }
+}
+
+function ask(rl, q) {
+  return new Promise((resolve) => rl.question(q, (a) => resolve(a.trim())));
+}
+
+function ensureCacheDir() {
+  fs.mkdirSync(STYLE_CACHE_DIR, { recursive: true });
+}
+
+// ── Basic audio metadata via Node (no heavy deps — just file info for MVP)
+function extractBasicFileInfo(filePath) {
+  try {
+    const stat = fs.statSync(filePath);
+    const ext = path.extname(filePath).toLowerCase();
+    const mediumMap = {
+      '.mp3': 'audio', '.wav': 'audio', '.flac': 'audio', '.aac': 'audio',
+      '.ogg': 'audio', '.m4a': 'audio', '.aiff': 'audio',
+      '.mid': 'midi', '.midi': 'midi',
+      '.txt': 'text', '.md': 'text',
+    };
+    return {
+      file_size_bytes: stat.size,
+      mime_type: ext,
+      medium: mediumMap[ext] || 'other',
+    };
+  } catch {
+    return { medium: 'other' };
+  }
+}
+
+// ── Save artifact + features locally (Tier 0)
+function saveLocally(artifact, features) {
+  ensureCacheDir();
+  const localPath = path.join(STYLE_CACHE_DIR, 'artifacts.json');
+  let existing = [];
+  try { existing = JSON.parse(fs.readFileSync(localPath, 'utf-8')); } catch { /* empty */ }
+  existing.push({ artifact, features, savedAt: new Date().toISOString() });
+  fs.writeFileSync(localPath, JSON.stringify(existing, null, 2));
+}
+
+// ── Load local artifact cache
+function loadLocal() {
+  try {
+    const localPath = path.join(STYLE_CACHE_DIR, 'artifacts.json');
+    return JSON.parse(fs.readFileSync(localPath, 'utf-8'));
+  } catch { return []; }
+}
+
+// ── Rebuild profile from local cache
+function buildLocalProfile(entries) {
+  const tempos = entries.map(e => e.features?.tempo_bpm).filter(Boolean);
+  const keys = entries.map(e => e.features?.key_signature).filter(Boolean);
+  const vibes = entries.flatMap(e => e.features?.vibe || []).filter(Boolean);
+  const instruments = entries.flatMap(e => e.features?.instruments || []).filter(Boolean);
+  const energies = entries.map(e => e.features?.energy).filter(Boolean);
+
+  const freq = (arr) => {
+    const counts = {};
+    arr.forEach(v => counts[v] = (counts[v] || 0) + 1);
+    return Object.entries(counts).sort((a, b) => b[1] - a[1]).map(([k]) => k);
+  };
+
+  return {
+    artifact_count: entries.length,
+    tempo_range: tempos.length ? [Math.min(...tempos), Math.max(...tempos)] : null,
+    dominant_keys: [...new Set(keys)].slice(0, 3),
+    vibe_signature: freq(vibes).slice(0, 5),
+    instrument_palette: freq(instruments).slice(0, 6),
+    energy_avg: energies.length ? energies.reduce((a, b) => a + b, 0) / energies.length : null,
+  };
+}
+
+// ── Print style profile
+function printProfile(profile, email) {
+  console.log('');
+  console.log(`  ${b('your style')}  ${g(email ? `· ${email}` : '')}`);
+  console.log(`  ${d('─────────────────────────────')}`);
+
+  if (profile.artifact_count === 0) {
+    console.log(`  ${g('no artifacts yet — run: phewsh style --ingest <file>')}`);
+    return;
+  }
+
+  console.log(`  ${g('sessions     ')}${profile.artifact_count}`);
+
+  if (profile.tempo_range) {
+    const [lo, hi] = profile.tempo_range;
+    const label = lo === hi ? `${lo} BPM` : `${Math.round(lo)}–${Math.round(hi)} BPM`;
+    console.log(`  ${g('tempo        ')}${label}`);
+  }
+
+  if (profile.dominant_keys?.length) {
+    console.log(`  ${g('keys         ')}${profile.dominant_keys.join(', ')}`);
+  }
+
+  if (profile.vibe_signature?.length) {
+    console.log(`  ${g('vibe         ')}${profile.vibe_signature.join(' · ')}`);
+  }
+
+  if (profile.instrument_palette?.length) {
+    console.log(`  ${g('instruments  ')}${profile.instrument_palette.join(', ')}`);
+  }
+
+  if (profile.energy_avg !== null && profile.energy_avg !== undefined) {
+    const energyLabel = profile.energy_avg > 0.7 ? 'high' : profile.energy_avg > 0.4 ? 'mid' : 'soft';
+    console.log(`  ${g('dynamics     ')}${energyLabel}`);
+  }
+
+  console.log('');
+}
+
+// ── Sync artifact + features to Supabase
+async function syncToCloud(config, artifact, features) {
+  if (!config?.supabaseAccessToken) return null;
+
+  const headers = {
+    'Content-Type': 'application/json',
+    'apikey': SUPABASE_ANON_KEY,
+    'Authorization': `Bearer ${config.supabaseAccessToken}`,
+    'Prefer': 'resolution=merge-duplicates,return=representation',
+  };
+
+  // Insert artifact
+  const artifactRes = await fetch(`${SUPABASE_URL}/rest/v1/styletree_artifacts`, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify({ ...artifact, user_id: config.supabaseUserId }),
+  });
+  if (!artifactRes.ok) return null;
+  const [savedArtifact] = await artifactRes.json();
+
+  // Insert features
+  await fetch(`${SUPABASE_URL}/rest/v1/styletree_features`, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify({ ...features, artifact_id: savedArtifact.id, user_id: config.supabaseUserId }),
+  });
+
+  // Trigger profile rebuild via RPC
+  await fetch(`${SUPABASE_URL}/rest/v1/rpc/rebuild_styletree_profile`, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify({ p_user_id: config.supabaseUserId }),
+  });
+
+  return savedArtifact.id;
+}
+
+// ── Main
+async function main() {
+  const args = process.argv.slice(3);
+  const config = loadConfig();
+
+  // --status
+  if (args.includes('--status') || args.length === 0) {
+    const entries = loadLocal();
+    const profile = buildLocalProfile(entries);
+    printProfile(profile, config?.email);
+    if (!config?.supabaseUserId) {
+      console.log(`  ${g('tip: run phewsh login to sync your style to the cloud')}`);
+      console.log('');
+    }
+    return;
+  }
+
+  // --ingest <file>
+  if (args.includes('--ingest')) {
+    const fileIdx = args.indexOf('--ingest');
+    const filePath = args[fileIdx + 1];
+
+    if (!filePath) {
+      console.error(`\n  Usage: phewsh style --ingest <file>\n`);
+      process.exit(1);
+    }
+
+    const absPath = path.resolve(filePath);
+    if (!fs.existsSync(absPath)) {
+      console.error(`\n  File not found: ${absPath}\n`);
+      process.exit(1);
+    }
+
+    const fileInfo = extractBasicFileInfo(absPath);
+    const fileName = path.basename(absPath);
+
+    console.log('');
+    console.log(`  ${b('😮\u200d💨  ingesting')} ${c(fileName)}`);
+    console.log(`  ${g('medium: ' + fileInfo.medium + '  ·  size: ' + (fileInfo.file_size_bytes ? Math.round(fileInfo.file_size_bytes / 1024) + 'kb' : 'unknown'))}`);
+    console.log('');
+
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+    const title = await ask(rl, `  ${g('title')} (or enter to use filename)\n  > `);
+    const tempoInput = await ask(rl, `  ${g('tempo')} BPM (leave blank if unknown)\n  > `);
+    const keyInput = await ask(rl, `  ${g('key')} (e.g. C minor, F# major — blank to skip)\n  > `);
+    const vibeInput = await ask(rl, `  ${g('vibe')} (e.g. dark chill driving — space-separated)\n  > `);
+    const instrumentInput = await ask(rl, `  ${g('instruments')} (e.g. piano bass drums — space-separated)\n  > `);
+
+    rl.close();
+    console.log('');
+
+    const artifact = {
+      title: title || fileName,
+      medium: fileInfo.medium,
+      file_path: absPath,
+      file_size_bytes: fileInfo.file_size_bytes || null,
+      mime_type: fileInfo.mime_type || null,
+      sync_tier: 0,
+    };
+
+    const features = {
+      tempo_bpm: tempoInput ? parseFloat(tempoInput) : null,
+      key_signature: keyInput || null,
+      mode: keyInput?.toLowerCase().includes('minor') ? 'minor'
+           : keyInput?.toLowerCase().includes('major') ? 'major'
+           : 'unknown',
+      vibe: vibeInput ? vibeInput.split(/\s+/).filter(Boolean) : [],
+      instruments: instrumentInput ? instrumentInput.split(/\s+/).filter(Boolean) : [],
+    };
+
+    // Always save locally first
+    saveLocally(artifact, features);
+    console.log(`  ${c('✓')} saved locally`);
+
+    // Sync to cloud if logged in
+    if (config?.supabaseAccessToken) {
+      process.stdout.write(`  ${g('syncing to cloud...')}`);
+      try {
+        const id = await syncToCloud(config, artifact, features);
+        if (id) {
+          process.stdout.write(`\r  ${c('✓')} synced to cloud\n`);
+        } else {
+          process.stdout.write(`\r  ${g('⚠ cloud sync skipped (run phewsh login --refresh)')}\n`);
+        }
+      } catch {
+        process.stdout.write(`\r  ${g('⚠ cloud sync failed — local copy saved')}\n`);
+      }
+    } else {
+      console.log(`  ${g('tip: run phewsh login to enable cloud sync')}`);
+    }
+
+    // Print updated profile
+    const entries = loadLocal();
+    const profile = buildLocalProfile(entries);
+    printProfile(profile, config?.email);
+    return;
+  }
+
+  // --sync
+  if (args.includes('--sync')) {
+    if (!config?.supabaseAccessToken) {
+      console.error(`\n  Not logged in. Run: phewsh login\n`);
+      process.exit(1);
+    }
+    const entries = loadLocal();
+    if (!entries.length) {
+      console.log(`\n  Nothing to sync. Run: phewsh style --ingest <file>\n`);
+      return;
+    }
+    console.log(`\n  Syncing ${entries.length} artifact(s) to cloud...\n`);
+    let synced = 0;
+    for (const { artifact, features } of entries) {
+      try {
+        const id = await syncToCloud(config, artifact, features);
+        if (id) synced++;
+      } catch { /* skip */ }
+    }
+    console.log(`  ${c('✓')} ${synced}/${entries.length} synced\n`);
+    return;
+  }
+
+  // --link-intent: mark that style should influence intent generation
+  if (args.includes('--link-intent')) {
+    const intentDir = path.join(process.cwd(), '.intent');
+    if (!fs.existsSync(intentDir)) {
+      console.error(`\n  No .intent/ found here. Run: phewsh intent --init\n`);
+      process.exit(1);
+    }
+    const entries = loadLocal();
+    const profile = buildLocalProfile(entries);
+    const linkPath = path.join(intentDir, 'style.json');
+    fs.writeFileSync(linkPath, JSON.stringify(profile, null, 2));
+    console.log(`\n  ${c('✓')} style profile linked to .intent/style.json`);
+    console.log(`  ${g('phewsh ai will now include your style context automatically')}\n`);
+    return;
+  }
+
+  console.error(`\n  Unknown style command. Try:\n`);
+  console.error(`    phewsh style --ingest <file>    ingest a new artifact`);
+  console.error(`    phewsh style --status           view your style profile`);
+  console.error(`    phewsh style --sync             push to cloud`);
+  console.error(`    phewsh style --link-intent      link style to current project\n`);
+  process.exit(1);
+}
+
+main().catch(err => {
+  console.error('\n  Error:', err.message);
+  process.exit(1);
+});

package/lib/supabase.js

@@ -77,4 +77,49 @@ async function upsert(table, data, accessToken) {
   return res.json();
 }
 
-module.exports = { sendOtp, verifyOtp, refreshSession, select, upsert, SUPABASE_URL, SUPABASE_ANON_KEY };
+// SAP: fire-and-forget per-inference tracking
+// kWh estimates by model family (conservative)
+const MODEL_KWH = {
+  'claude-haiku':   0.00025,
+  'claude-sonnet':  0.00060,
+  'claude-opus':    0.00200,
+  'gemini-flash':   0.00020,
+  'deepseek':       0.00030,
+  'kimi':           0.00040,
+};
+
+function estimateKwh(model, totalTokens) {
+  let base = 0.0004;
+  if (model) {
+    const lower = model.toLowerCase();
+    for (const [key, val] of Object.entries(MODEL_KWH)) {
+      if (lower.includes(key)) { base = val; break; }
+    }
+  }
+  const scale = Math.max(0.5, Math.min(4, (totalTokens || 1000) / 1000));
+  return base * scale;
+}
+
+function trackSap({ userId, source = 'cli', model, promptTokens, completionTokens, accessToken } = {}) {
+  const totalTokens = (promptTokens || 0) + (completionTokens || 0);
+  const kwh = estimateKwh(model, totalTokens);
+  const co2_g = kwh * 500;   // US grid avg gCO2/kWh
+  const water_ml = kwh * 1800;
+
+  req('/rest/v1/rpc/track_sap_event', {
+    method: 'POST',
+    body: JSON.stringify({
+      p_user_id:           userId || null,
+      p_session_id:        null,
+      p_source:            source,
+      p_model:             model || null,
+      p_prompt_tokens:     promptTokens || null,
+      p_completion_tokens: completionTokens || null,
+      p_kwh:               kwh,
+      p_co2_g:             co2_g,
+      p_water_ml:          water_ml,
+    }),
+  }, accessToken).catch(() => { /* never surface SAP errors */ });
+}
+
+module.exports = { sendOtp, verifyOtp, refreshSession, select, upsert, trackSap, SUPABASE_URL, SUPABASE_ANON_KEY };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "phewsh",
-  "version": "0.5.3",
+  "version": "0.6.0",
   "description": "Turn intent into action. Structure your thinking, execute your next step.",
   "bin": {
     "phewsh": "bin/phewsh.js"