@geraldmaron/construct 1.0.2 → 1.0.4

package/lib/setup.mjs

@@ -4,7 +4,7 @@
  *
  * Guides users through provider selection, API key entry, and model tier
  * assignment. Writes the resulting config to ~/.cx/env and optionally to
- * project-level .env. Invoked by `construct setup` and on first init.
+ * project-level .env. Invoked by `construct init` and on first init.
  */
 
 import fs from 'node:fs';
@@ -25,10 +25,6 @@ import { createSqlClient, closeSqlClient } from './storage/backend.mjs';
 import { getEmbeddingModelInfo, warmupEmbeddingModel } from './storage/embeddings-engine.mjs';
 import { restoreConstructDb } from './storage/postgres-backup.mjs';
 import { buildPressureGuardValues, installPressureGuardLaunchAgent, loadPressureGuardLaunchAgent } from './runtime-pressure.mjs';
-import {
-  isRemoteTelemetry,
-  startManagedServices,
-} from './services/telemetry-backend.mjs';
 import { consentToInstall } from './setup-prompts.mjs';
 
 const ROOT_DIR = path.resolve(import.meta.dirname, '..');
@@ -43,7 +39,7 @@ function printHelp() {
   console.log(`Construct setup
 
 Usage:
-  construct setup [--yes] [--no-docker]
+  construct init [--yes] [--no-docker]
 
 What it does:
   - creates ~/.construct/config.env
@@ -86,9 +82,8 @@ export function defaultVectorIndexPath(homeDir = HOME) {
 export async function buildManagedSetupValues({ homeDir = HOME, env = process.env, databaseUrl = '' } = {}) {
   const modelInfo = await getEmbeddingModelInfo({ env });
 
-  // Local telemetry backend
   const values = {
-    CONSTRUCT_TRACE_BACKEND: env.CONSTRUCT_TRACE_BACKEND || 'remote',
+    CONSTRUCT_TRACE_BACKEND: env.CONSTRUCT_TRACE_BACKEND || 'local',
     CONSTRUCT_VECTOR_INDEX_PATH: env.CONSTRUCT_VECTOR_INDEX_PATH || defaultVectorIndexPath(homeDir),
     CONSTRUCT_VECTOR_MODEL: env.CONSTRUCT_VECTOR_MODEL || modelInfo.model,
     ...buildPressureGuardValues({ env }),
@@ -533,37 +528,10 @@ export async function runSetup({ rootDir = ROOT_DIR, args = [], homeDir = HOME }
     console.log(`  ${dockerInstallHint()}`);
   }
 
-  // Local telemetry backend — starts Postgres via services/docker-compose.yml.
-  // Skipped automatically when CONSTRUCT_TELEMETRY_URL points to a remote instance.
-
-  let telemetryResult = { status: 'skipped', note: 'Docker not available' };
-  if (dockerAvailable) {
-    const svcConsent = await consentToInstall({
-      name: 'telemetry',
-      isYes,
-      alreadyConfigured: isRemoteTelemetry(process.env.CONSTRUCT_TELEMETRY_URL || ''),
-      alreadyConfiguredNote: 'CONSTRUCT_TELEMETRY_URL points to a remote instance — local stack not started.',
-      envPath,
-    });
-    if (svcConsent.decision) {
-      try {
-        telemetryResult = await startManagedServices({
-          rootDir,
-          homeDir,
-          env: process.env,
-          composeRunner: dockerRunner,
-          spawnDetached: spawnDetachedForSetup,
-        });
-        console.log(`Telemetry: ${telemetryResult.status} — ${telemetryResult.note || ''}`);
-      } catch (err) {
-        telemetryResult = { status: 'error', note: err?.message || 'spin-up failed' };
-        console.log(`Telemetry: error — ${telemetryResult.note}`);
-      }
-    } else {
-      telemetryResult = { status: 'skipped', note: svcConsent.note };
-      console.log(`Telemetry: skipped (${svcConsent.note})`);
-    }
-  }
+  const telemetryResult = process.env.CONSTRUCT_TELEMETRY_URL
+    ? { status: 'configured', note: `remote export configured (${process.env.CONSTRUCT_TELEMETRY_URL})` }
+    : { status: 'local', note: 'local JSONL traces in .cx/traces; remote export optional' };
+  console.log(`Telemetry: ${telemetryResult.note}`);
 
   fs.mkdirSync(path.dirname(defaultVectorIndexPath(homeDir)), { recursive: true });
 
@@ -585,6 +553,50 @@ export async function runSetup({ rootDir = ROOT_DIR, args = [], homeDir = HOME }
     console.log(`Embeddings: warmup skipped (${err?.message || 'unknown error'}) — model will load on first use`);
   }
 
+  // Cheapest provider selection — opt-out by default. When user consents,
+  // evaluate all configured providers, pick the lowest-cost model per tier,
+  // and write to config.env. On subsequent runs the preference is persisted
+  // so the prompt is skipped.
+
+  const { isCheapestProviderEnabled, selectCheapestForAllTiers, setCheapestProviderPreference, formatCheapestProviderMessage } =
+    await import('./model-cheapest-provider.mjs');
+  const cheapestAlreadyEnabled = isCheapestProviderEnabled(envPath, { env: process.env });
+  if (!cheapestAlreadyEnabled) {
+    const cheapestConsent = await consentToInstall({
+      name: 'cheapest-provider',
+      isYes,
+      alreadyConfigured: false,
+      envPath,
+      defaultYes: false,
+    });
+    if (cheapestConsent.decision) {
+      try {
+        const selections = await selectCheapestForAllTiers({ env: process.env });
+        const applied = {};
+        for (const tier of ['reasoning', 'standard', 'fast']) {
+          if (selections[tier]?.modelId) applied[tier] = selections[tier].modelId;
+        }
+        if (Object.keys(applied).length > 0) {
+          applyToEnv(envPath, applied);
+          console.log('\nCheapest providers applied:');
+          for (const [tier, model] of Object.entries(applied)) {
+            const label = selections[tier]?.providerLabel || '';
+            console.log(`  ${tier.padEnd(11)} ${model} (${label})`);
+          }
+        } else {
+          console.log('\nCheapest provider: no configured providers found — nothing to apply.');
+        }
+        setCheapestProviderPreference(envPath, true);
+      } catch (err) {
+        console.log(`Cheapest provider: skipped (${err?.message || 'unknown error'})`);
+      }
+    } else {
+      console.log(`Cheapest provider: skipped (${cheapestConsent.note})`);
+    }
+  } else {
+    console.log('Cheapest provider: already enabled — skipping prompt.');
+  }
+
   const hooksResult = ensureGitHooksPath({ cwd: process.cwd() });
   if (hooksResult.status === 'set') console.log(`Git hooks: ${hooksResult.message}`);
   else if (hooksResult.status === 'ok') console.log('Git hooks: wired');
@@ -705,7 +717,7 @@ export async function runSetup({ rootDir = ROOT_DIR, args = [], homeDir = HOME }
     console.log(`  Trace backend: ${managedValues.CONSTRUCT_TRACE_BACKEND}${managedValues.CONSTRUCT_TELEMETRY_URL ? ` (${managedValues.CONSTRUCT_TELEMETRY_URL})` : ''}`);
     console.log(`  Pressure guard: swap ${managedValues.CONSTRUCT_PRESSURE_GUARD_SWAP_GB} GiB, opencode max ${managedValues.CONSTRUCT_PRESSURE_GUARD_MAX_OPENCODE}`);
     console.log('\nFor unattended setup, including local Postgres when Docker is running:');
-    console.log('  construct setup --yes');
+    console.log('  construct init --yes');
   }
 
   runConstruct(['sync']);
@@ -746,18 +758,15 @@ export async function runSetup({ rootDir = ROOT_DIR, args = [], homeDir = HOME }
   // Local-service summary — surfaces running local services. Same pattern
   // as `supabase start`, which prints all local URLs + keys after spin-up.
 
-  const hasLocalTelemetry = telemetryResult?.status === 'started' || telemetryResult?.status === 'degraded';
   const hasLocalPostgres = serviceResult?.status === 'ok' && serviceResult?.databaseUrl?.includes('127.0.0.1');
   const vectorBackend = hasLocalPostgres
     ? { label: 'Postgres + pgvector', detail: `${serviceResult.databaseUrl} (384d embeddings, ${managedValues.CONSTRUCT_VECTOR_MODEL})` }
     : { label: 'JSON fallback', detail: `${managedValues.CONSTRUCT_VECTOR_INDEX_PATH} (${managedValues.CONSTRUCT_VECTOR_MODEL})` };
 
   console.log('\nLocal services:');
-  if (hasLocalTelemetry) {
-    console.log(`  Telemetry:   ${telemetryResult.note || 'started'}`);
-  } else {
-    console.log(`  Telemetry:   not started`);
-  }
+  console.log('  Traces:      local JSONL (.cx/traces)');
+  if (process.env.CONSTRUCT_TELEMETRY_URL) console.log(`  Telemetry:   remote export (${process.env.CONSTRUCT_TELEMETRY_URL})`);
+  else console.log('  Telemetry:   remote export not configured');
   if (hasLocalPostgres) {
     console.log(`  Postgres:    ${serviceResult.databaseUrl}`);
   } else if (process.env.DATABASE_URL) {

package/lib/status.mjs

@@ -24,6 +24,7 @@ import { describeSqlStore, sqlStoreHealth } from './storage/sql-store.mjs';
 import { describeVectorStore } from './storage/vector-store.mjs';
 import { describeSqlStoreHealth } from './storage/sql-store.mjs';
 import { triggerAutoBackfillIfSparse } from './telemetry/backfill.mjs';
+import { resolveTraceBackend, telemetryProviderLabel } from './telemetry/client.mjs';
 const TOTAL_BYTES_WARNING_THRESHOLD = 750_000;
 
 function readJSON(path) {
@@ -317,20 +318,29 @@ async function defaultProbeService(service) {
 }
 
 async function fetchTelemetryStatus(env, { timeout = 2500 } = {}) {
+  const backend = resolveTraceBackend(env);
+  if (backend === 'local') return { status: 'healthy', summary: 'Local JSONL tracing enabled · remote export not configured', backend, provider: telemetryProviderLabel(env) };
+  if (backend === 'none') return { status: 'disabled', summary: 'Remote telemetry disabled · local JSONL tracing preserved', backend, provider: telemetryProviderLabel(env) };
+  if (backend === 'otel') {
+    const endpoint = (env.CONSTRUCT_OTEL_EXPORTER_OTLP_ENDPOINT ?? '').replace(/\/$/, '');
+    if (!endpoint) return { status: 'unavailable', summary: 'OTLP endpoint not configured', backend, provider: telemetryProviderLabel(env) };
+    return { status: 'configured', summary: `OTLP export configured · ${endpoint}`, backend, provider: telemetryProviderLabel(env) };
+  }
   const baseUrl = (env.CONSTRUCT_TELEMETRY_URL ?? '').replace(/\/$/, '');
   const key = env.CONSTRUCT_TELEMETRY_PUBLIC_KEY;
   const secret = env.CONSTRUCT_TELEMETRY_SECRET_KEY;
-  if (!key || !secret) return { status: 'unavailable', summary: 'Telemetry credentials not configured' };
+  if (backend === 'langfuse' && (!key || !secret)) return { status: 'unavailable', summary: 'Langfuse credentials not configured', backend, provider: telemetryProviderLabel(env) };
   if (!baseUrl) return { status: 'unavailable', summary: 'CONSTRUCT_TELEMETRY_URL not set' };
   const headers = {
-    Authorization: `Basic ${Buffer.from(`${key}:${secret}`).toString('base64')}`,
+    ...(key && secret ? { Authorization: `Basic ${Buffer.from(`${key}:${secret}`).toString('base64')}` } : {}),
   };
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), timeout);
   try {
-    const res = await fetch(`${baseUrl}/api/public/traces?limit=25`, { headers, signal: controller.signal });
+    const tracesPath = backend === 'http' ? '/traces?limit=25' : '/api/public/traces?limit=25';
+    const res = await fetch(`${baseUrl}${tracesPath}`, { headers, signal: controller.signal });
     if (res.status === 401 || res.status === 403) {
-      return { status: 'credentials-invalid', summary: `Telemetry credentials rejected (HTTP ${res.status}) — run: construct setup` };
+      return { status: 'credentials-invalid', summary: `Telemetry credentials rejected (HTTP ${res.status}) — run: construct init` };
     }
     if (!res.ok) return { status: 'degraded', summary: `Telemetry HTTP ${res.status}` };
     const json = await res.json().catch(() => ({}));
@@ -359,6 +369,8 @@ async function fetchTelemetryStatus(env, { timeout = 2500 } = {}) {
 
     return {
       status,
+      backend,
+      provider: telemetryProviderLabel(env),
       total,
       rich: counts.rich,
       partial: counts.partial,
@@ -478,6 +490,40 @@ export function buildPublicHealthSurface({
 }
 
 function traceBackendDefinition(env) {
+  const backend = resolveTraceBackend(env);
+  const provider = telemetryProviderLabel(env);
+  if (backend === 'local' || backend === 'none') {
+    return {
+      id: 'telemetry',
+      name: 'Telemetry',
+      url: 'local://.cx/traces',
+      runtime: 'local',
+      note: backend === 'none' ? 'Remote disabled; local JSONL preserved' : 'Local JSONL traces',
+      healthyMessage: 'Local trace capture enabled',
+      impactsOverall: false,
+      selfCheck: {
+        status: backend === 'none' ? 'disabled' : 'healthy',
+        message: backend === 'none' ? 'Remote telemetry disabled' : 'Writing .cx/traces/*.jsonl',
+      },
+    };
+  }
+  if (backend === 'otel') {
+    const endpoint = (env.CONSTRUCT_OTEL_EXPORTER_OTLP_ENDPOINT ?? '').replace(/\/$/, '');
+    return {
+      id: 'telemetry',
+      name: 'Telemetry',
+      url: endpoint || '(not configured)',
+      probeUrl: '',
+      runtime: 'remote',
+      note: `${provider} trace export`,
+      healthyMessage: 'Configured',
+      impactsOverall: false,
+      selfCheck: {
+        status: endpoint ? 'configured' : 'unavailable',
+        message: endpoint ? `OTLP export configured: ${endpoint}` : 'CONSTRUCT_OTEL_EXPORTER_OTLP_ENDPOINT not set',
+      },
+    };
+  }
   const url = (env.CONSTRUCT_TELEMETRY_URL ?? '').replace(/\/$/, '');
   const pubKey = env.CONSTRUCT_TELEMETRY_PUBLIC_KEY || '';
   const secKey = env.CONSTRUCT_TELEMETRY_SECRET_KEY || '';
@@ -486,11 +532,12 @@ function traceBackendDefinition(env) {
     id: 'telemetry',
     name: 'Telemetry',
     url: url || '(not configured)',
-    probeUrl: url ? `${url}/api/public/traces?limit=1` : '',
+    probeUrl: url ? `${url}${backend === 'http' ? '/traces?limit=1' : '/api/public/traces?limit=1'}` : '',
     probeHeaders: auth ? { Authorization: auth } : undefined,
     runtime: 'live',
-    note: 'Trace backend',
+    note: `${provider} trace export`,
     healthyMessage: 'Reachable',
+    impactsOverall: false,
   };
 }
 
@@ -588,6 +635,7 @@ function serviceDefinitions(env, dashboardPort, selfDashboard) {
       runtime: 'live',
       note: 'MCP-managed',
       healthyMessage: 'Reachable',
+      impactsOverall: false,
     },
     {
       id: 'opencode',
@@ -772,8 +820,8 @@ export async function buildStatus({
 }
 
 function serviceIcon(status) {
-  if (status === 'healthy') return '✓';
-  if (status === 'degraded' || status === 'configured') return '⚠';
+  if (status === 'healthy' || status === 'configured') return '✓';
+  if (status === 'degraded') return '⚠';
   return '✗';
 }
 

package/lib/storage/backend.mjs

@@ -1,17 +1,27 @@
 #!/usr/bin/env node
 /**
  * lib/storage/backend.mjs — shared storage backend helpers for SQL/vector wiring.
+ *
+ * postgres is an optional peer dep. Top-level await catches the case where it is not
+ * installed (fresh installs, test temp dirs) so the module loads cleanly everywhere.
  */
-import postgres from 'postgres';
 import { resolveDatabaseUrl } from '../env-config.mjs';
 
+let postgres = null;
+try {
+  const mod = await import('postgres');
+  postgres = mod.default ?? mod;
+} catch {
+  // postgres not installed — SQL features unavailable; createSqlClient returns null
+}
+
 function cleanUrl(url) {
   return String(url || '').trim();
 }
 
 export function createSqlClient(env = process.env) {
   const databaseUrl = cleanUrl(resolveDatabaseUrl(env));
-  if (!databaseUrl) return null;
+  if (!databaseUrl || !postgres) return null;
   return postgres(databaseUrl, {
     max: Number.parseInt(env.CONSTRUCT_DB_POOL_SIZE || '5', 10),
     idle_timeout: Number.parseInt(env.CONSTRUCT_DB_IDLE_TIMEOUT_MS || '30000', 10),

package/lib/storage/postgres-backup.mjs

@@ -4,7 +4,7 @@
  *
  * Mirrors the telemetry backup pattern in service-manager.mjs. Entry points:
  *   - construct down  → stashConstructDb  (dump before container stop)
- *   - construct setup → restoreConstructDb (reload after fresh container start)
+ *   - construct init → restoreConstructDb (reload after fresh container start)
  *
  * Dumps are stored in ~/.construct/backups/postgres/ as pg_dump custom-format
  * files. The N most recent are kept; older ones are pruned automatically.