@aikdna/kdna-studio-cli 0.11.0 → 0.13.0-rc.components.2

package/src/llm/config.js

@@ -1,98 +0,0 @@
-// LLM Provider Configuration
-// Sources (priority order): env vars > ~/.kdna/config.json > defaults
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-const { canonicalLlmBaseUrl } = require('./transport');
-
-const ENV_PREFIX = 'KDNA_LLM_';
-
-const WELL_KNOWN = {
-  openai: { baseURL: 'https://api.openai.com/v1', models: ['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo'] },
-  anthropic: { baseURL: 'https://api.anthropic.com/v1', models: ['claude-sonnet-4-20250514', 'claude-3-5-haiku-latest'] },
-  deepseek: { baseURL: 'https://api.deepseek.com/v1', models: ['deepseek-chat', 'deepseek-reasoner'] },
-  openrouter: { baseURL: 'https://openrouter.ai/api/v1', models: ['openai/gpt-4o', 'anthropic/claude-sonnet-4', 'deepseek/deepseek-chat'] },
-  gemini: { baseURL: 'https://generativelanguage.googleapis.com/v1beta', models: ['gemini-2.5-flash', 'gemini-2.5-pro'] },
-  perplexity: { baseURL: 'https://api.perplexity.ai', models: ['sonar-pro', 'sonar'] },
-  groq: { baseURL: 'https://api.groq.com/openai/v1', models: ['llama-4-scout-17b-16e-instruct', 'deepseek-r1-distill-llama-70b'] },
-  local: { baseURL: 'http://127.0.0.1:11434/v1', models: ['llama3.2'] },
-  ollama: { baseURL: 'http://127.0.0.1:11434/v1', models: ['llama3.2'] },
-  openai_compatible: { baseURL: null, models: [] },
-};
-
-function loadConfig() {
-  const config = { provider: null, apiKey: null, model: null, baseURL: null, temperature: 0.7, maxTokens: 4096 };
-
-  // 1. Read from ~/.kdna/config.json
-  const configPath = path.join(os.homedir(), '.kdna', 'config.json');
-  try { if (fs.existsSync(configPath)) Object.assign(config, JSON.parse(fs.readFileSync(configPath, 'utf8')).llm || {}); } catch (e) { console.error('Error reading LLM config file:', e.message); }
-
-  // 2. Env vars override
-  if (process.env.KDNA_LLM_PROVIDER) config.provider = process.env.KDNA_LLM_PROVIDER;
-  if (process.env.KDNA_LLM_API_KEY) config.apiKey = process.env.KDNA_LLM_API_KEY;
-  if (process.env.KDNA_LLM_MODEL) config.model = process.env.KDNA_LLM_MODEL;
-  if (process.env.KDNA_LLM_BASE_URL) config.baseURL = process.env.KDNA_LLM_BASE_URL;
-  if (process.env.KDNA_LLM_TEMPERATURE) config.temperature = parseFloat(process.env.KDNA_LLM_TEMPERATURE);
-  if (process.env.KDNA_LLM_MAX_TOKENS) config.maxTokens = parseInt(process.env.KDNA_LLM_MAX_TOKENS, 10);
-
-  // 3. Resolve well-known provider
-  if (config.provider && WELL_KNOWN[config.provider]) {
-    const wk = WELL_KNOWN[config.provider];
-    if (wk.baseURL && !config.baseURL) config.baseURL = wk.baseURL;
-    if (wk.models.length > 0 && !config.model) config.model = wk.models[0];
-  }
-
-  // 4. Provider-specific env var (KDNA_LLM_API_KEY_<PROVIDER>)
-  if (!config.apiKey && config.provider) {
-    const keyEnv = `KDNA_LLM_API_KEY_${config.provider.toUpperCase().replace(/-/g, '_')}`;
-    if (process.env[keyEnv]) config.apiKey = process.env[keyEnv];
-  }
-
-  // 5. Provider-native fallback — each provider only uses its own native env var
-  if (!config.apiKey && config.provider) {
-    const PROVIDER_NATIVE_KEYS = {
-      openai: 'OPENAI_API_KEY',
-      anthropic: 'ANTHROPIC_API_KEY',
-      deepseek: 'DEEPSEEK_API_KEY',
-      groq: 'GROQ_API_KEY',
-      gemini: 'GEMINI_API_KEY',
-      perplexity: 'PERPLEXITY_API_KEY',
-      openrouter: 'OPENROUTER_API_KEY',
-    };
-    const nativeEnv = PROVIDER_NATIVE_KEYS[config.provider];
-    if (nativeEnv && process.env[nativeEnv]) config.apiKey = process.env[nativeEnv];
-  }
-
-  return config;
-}
-
-function saveConfig(updates) {
-  const safeUpdates = { ...updates };
-  if (Object.prototype.hasOwnProperty.call(safeUpdates, 'baseURL')) {
-    safeUpdates.baseURL = canonicalLlmBaseUrl(safeUpdates.baseURL);
-  }
-  const configPath = path.join(os.homedir(), '.kdna', 'config.json');
-  let existing = {};
-  try { if (fs.existsSync(configPath)) existing = JSON.parse(fs.readFileSync(configPath, 'utf8')); } catch (e) { console.error('Error reading config file for save:', e.message); }
-  existing.llm = { ...(existing.llm || {}), ...safeUpdates };
-  fs.mkdirSync(path.dirname(configPath), { recursive: true });
-  fs.writeFileSync(configPath, JSON.stringify(existing, null, 2) + '\n');
-}
-
-function validateConfig(config) {
-  const errors = [];
-  if (!config.provider) errors.push('Missing KDNA_LLM_PROVIDER. Set via env var or ~/.kdna/config.json');
-  if (!config.apiKey) errors.push('Missing KDNA_LLM_API_KEY');
-  if (!config.model) errors.push('Missing KDNA_LLM_MODEL');
-  if (!config.baseURL) errors.push('Missing KDNA_LLM_BASE_URL');
-  else {
-    try {
-      canonicalLlmBaseUrl(config.baseURL);
-    } catch {
-      errors.push('Invalid KDNA_LLM_BASE_URL: external providers require HTTPS; HTTP is loopback-only');
-    }
-  }
-  return { valid: errors.length === 0, errors };
-}
-
-module.exports = { loadConfig, saveConfig, validateConfig, WELL_KNOWN };

package/src/llm/index.js

@@ -1,50 +0,0 @@
-// KDNA Studio CLI — unified LLM interface
-// Supports OpenAI-compatible and Anthropic APIs
-// Configuration via KDNA_LLM_* env vars or ~/.kdna/config.json
-const { loadConfig, saveConfig, validateConfig } = require('./config');
-const openai = require('./providers/openai');
-const anthropic = require('./providers/anthropic');
-
-function getProvider(config) {
-  if (!config || !config.provider) throw new Error('LLM not configured. Run: kdna-studio llm config');
-  if (config.provider === 'anthropic') return anthropic;
-  return openai; // All OpenAI-compatible providers use the same API
-}
-
-async function chat(messages, options = {}) {
-  const config = loadConfig();
-  if (options.provider) config.provider = options.provider;
-  if (options.model) config.model = options.model;
-  if (options.apiKey) config.apiKey = options.apiKey;
-  if (options.baseURL) config.baseURL = options.baseURL;
-
-  const validation = validateConfig(config);
-  if (!validation.valid) throw new Error(`LLM configuration error:\n${validation.errors.map(e => `  - ${e}`).join('\n')}`);
-
-  const provider = getProvider(config);
-  return provider.chat(config, messages, options);
-}
-
-async function chatWithJSON(messages, options = {}) {
-  const result = await chat(messages, { ...options, responseFormat: { type: 'json_object' } });
-  try {
-    result.data = JSON.parse(result.content);
-  } catch {
-    console.error('Error parsing LLM JSON response.');
-    // Try to extract JSON from markdown code blocks
-    const match = result.content.match(/```(?:json)?\s*([\s\S]*?)```/);
-    if (match) {
-      try { result.data = JSON.parse(match[1].trim()); } catch { console.error('Error parsing JSON from markdown code block.'); }
-    }
-  }
-  return result;
-}
-
-function config() { return loadConfig(); }
-
-function configure(updates) {
-  saveConfig(updates);
-  return loadConfig();
-}
-
-module.exports = { chat, chatWithJSON, config, configure };

package/src/llm/providers/anthropic.js

@@ -1,41 +0,0 @@
-// Anthropic Messages API provider
-
-const { postLlmJson } = require('../transport');
-
-async function chat(config, messages, options = {}) {
-  const model = options.model || config.model;
-  const maxTokens = options.maxTokens || config.maxTokens || 4096;
-
-  // Convert OpenAI-format messages to Anthropic format
-  const systemMessages = messages.filter(m => m.role === 'system').map(m => m.content).join('\n\n');
-  const conversationMessages = messages.filter(m => m.role !== 'system').map(m => ({
-    role: m.role === 'assistant' ? 'assistant' : 'user',
-    content: m.content,
-  }));
-
-  const body = { model, max_tokens: maxTokens, messages: conversationMessages };
-  if (systemMessages) body.system = systemMessages;
-
-  const headers = {
-    'Content-Type': 'application/json',
-    'x-api-key': config.apiKey,
-    'anthropic-version': '2023-06-01',
-  };
-
-  const data = await postLlmJson({
-    baseUrl: config.baseURL,
-    endpoint: '/messages',
-    headers,
-    body,
-  });
-  const content = data.content?.[0]?.text;
-  if (!content) throw new Error('Anthropic returned empty response');
-
-  return {
-    content: content.trim(),
-    model: data.model || model,
-    usage: data.usage || null,
-  };
-}
-
-module.exports = { chat };

package/src/llm/providers/openai.js

@@ -1,42 +0,0 @@
-// OpenAI-compatible chat completions provider
-// Works with: OpenAI, DeepSeek, OpenRouter, Groq, Ollama, LM Studio, Perplexity, and any OpenAI-compatible API
-
-const { postLlmJson } = require('../transport');
-
-async function chat(config, messages, options = {}) {
-  const model = options.model || config.model;
-  const temperature = options.temperature ?? config.temperature ?? 0.7;
-  const maxTokens = options.maxTokens || config.maxTokens || 4096;
-  const responseFormat = options.responseFormat || null;
-
-  const body = { model, messages, temperature, max_tokens: maxTokens };
-  if (responseFormat) body.response_format = responseFormat;
-
-  const headers = {
-    'Content-Type': 'application/json',
-    'Authorization': `Bearer ${config.apiKey}`,
-  };
-
-  // Provider-specific headers
-  if (config.provider === 'openrouter') {
-    headers['HTTP-Referer'] = 'https://github.com/aikdna/kdna-studio-cli';
-    headers['X-Title'] = 'KDNA Studio CLI';
-  }
-
-  const data = await postLlmJson({
-    baseUrl: config.baseURL,
-    endpoint: '/chat/completions',
-    headers,
-    body,
-  });
-  const content = data.choices?.[0]?.message?.content;
-  if (!content) throw new Error('LLM returned empty response');
-
-  return {
-    content: content.trim(),
-    model: data.model || model,
-    usage: data.usage || null,
-  };
-}
-
-module.exports = { chat };

package/src/llm/transport.js

@@ -1,196 +0,0 @@
-'use strict';
-
-/**
- * Transport boundary for supported AI authoring providers.
- *
- * Requests contain provider credentials plus source evidence, interview
- * answers, or other judgment-authoring material. External providers must use
- * HTTPS. Plain HTTP is limited to exact numeric loopback development hosts;
- * localhost, LAN addresses, and arbitrary hostnames are not exceptions.
- */
-
-const MAX_LLM_URL_BYTES = 2048;
-const MAX_LLM_RESPONSE_BYTES = 4 * 1024 * 1024;
-const ALLOWED_ENDPOINTS = new Set(['/chat/completions', '/messages']);
-
-class LlmTransportError extends Error {
-  constructor(code, message, status = null) {
-    super(message);
-    this.name = 'LlmTransportError';
-    this.code = code;
-    this.status = Number.isInteger(status) ? status : null;
-  }
-}
-
-function isExactLoopback(hostname) {
-  return hostname === '127.0.0.1' || hostname === '[::1]';
-}
-
-function canonicalLlmBaseUrl(value) {
-  if (
-    typeof value !== 'string' ||
-    value.length === 0 ||
-    Buffer.byteLength(value, 'utf8') > MAX_LLM_URL_BYTES ||
-    [...value].some((character) => {
-      const codePoint = character.codePointAt(0);
-      return (
-        character === '\\' ||
-        character === '?' ||
-        character === '#' ||
-        codePoint < 0x21 ||
-        codePoint > 0x7e
-      );
-    })
-  ) {
-    throw new LlmTransportError(
-      'LLM_URL_REFUSED',
-      'LLM base URL must be a canonical visible-ASCII URL.',
-    );
-  }
-
-  let parsed;
-  try {
-    parsed = new URL(value);
-  } catch {
-    throw new LlmTransportError('LLM_URL_REFUSED', 'LLM base URL must be absolute.');
-  }
-  if (
-    !parsed.hostname ||
-    parsed.username ||
-    parsed.password ||
-    parsed.search ||
-    parsed.hash ||
-    parsed.pathname.includes('%') ||
-    parsed.pathname
-      .split('/')
-      .some((segment, index) =>
-        segment === '.' ||
-        segment === '..' ||
-        (index > 0 && segment === '' && parsed.pathname !== '/'))
-  ) {
-    throw new LlmTransportError(
-      'LLM_URL_REFUSED',
-      'LLM base URL contains credentials or an unsupported component.',
-    );
-  }
-  if (
-    parsed.protocol !== 'https:' &&
-    !(parsed.protocol === 'http:' && isExactLoopback(parsed.hostname))
-  ) {
-    throw new LlmTransportError(
-      'LLM_URL_REFUSED',
-      'LLM base URL must use HTTPS except for an exact loopback HTTP origin.',
-    );
-  }
-
-  const canonical = parsed.pathname === '/' ? parsed.origin : `${parsed.origin}${parsed.pathname}`;
-  if (value !== canonical || (parsed.pathname !== '/' && parsed.pathname.endsWith('/'))) {
-    throw new LlmTransportError('LLM_URL_REFUSED', 'LLM base URL is not canonical.');
-  }
-  return canonical;
-}
-
-function providerEndpoint(baseUrl, endpoint) {
-  if (!ALLOWED_ENDPOINTS.has(endpoint)) {
-    throw new LlmTransportError('LLM_URL_REFUSED', 'LLM provider endpoint is not admitted.');
-  }
-  return `${canonicalLlmBaseUrl(baseUrl)}${endpoint}`;
-}
-
-async function refuseInvalidResponse(response) {
-  try {
-    await response.body?.cancel();
-  } catch {
-    // Response bytes never cross the transport boundary.
-  }
-  throw new LlmTransportError('LLM_RESPONSE_INVALID', 'LLM provider returned an invalid response.');
-}
-
-async function readBoundedJson(response) {
-  const contentType = response.headers.get('content-type') || '';
-  if (!/^application\/json(?:\s*;\s*charset=utf-8)?$/i.test(contentType)) {
-    return refuseInvalidResponse(response);
-  }
-  const contentLength = response.headers.get('content-length');
-  if (
-    contentLength !== null &&
-    (!/^(0|[1-9]\d*)$/.test(contentLength) || Number(contentLength) > MAX_LLM_RESPONSE_BYTES)
-  ) {
-    return refuseInvalidResponse(response);
-  }
-  if (!response.body) {
-    return refuseInvalidResponse(response);
-  }
-
-  const reader = response.body.getReader();
-  const chunks = [];
-  let total = 0;
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      total += value.byteLength;
-      if (total > MAX_LLM_RESPONSE_BYTES) {
-        await reader.cancel();
-        throw new LlmTransportError(
-          'LLM_RESPONSE_INVALID',
-          'LLM provider returned an invalid response.',
-        );
-      }
-      chunks.push(Buffer.from(value));
-    }
-    const text = new TextDecoder('utf-8', { fatal: true }).decode(Buffer.concat(chunks, total));
-    const payload = JSON.parse(text);
-    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
-      throw new Error('not an object');
-    }
-    return payload;
-  } catch (error) {
-    if (error instanceof LlmTransportError) throw error;
-    throw new LlmTransportError('LLM_RESPONSE_INVALID', 'LLM provider returned an invalid response.');
-  } finally {
-    reader.releaseLock();
-  }
-}
-
-async function postLlmJson({ baseUrl, endpoint, headers, body, timeoutMs = 120000 }) {
-  const url = providerEndpoint(baseUrl, endpoint);
-  let response;
-  try {
-    response = await fetch(url, {
-      method: 'POST',
-      headers,
-      body: JSON.stringify(body),
-      redirect: 'error',
-      signal: AbortSignal.timeout(timeoutMs),
-    });
-  } catch {
-    throw new LlmTransportError(
-      'LLM_TRANSPORT_FAILED',
-      'LLM provider request failed [LLM_TRANSPORT_FAILED].',
-    );
-  }
-
-  if (!response.ok) {
-    try {
-      await response.body?.cancel();
-    } catch {
-      // Nothing from the provider response crosses the error boundary.
-    }
-    throw new LlmTransportError(
-      'LLM_HTTP_ERROR',
-      `LLM provider rejected the request [LLM_HTTP_ERROR] (HTTP ${response.status}).`,
-      response.status,
-    );
-  }
-  return readBoundedJson(response);
-}
-
-module.exports = {
-  LlmTransportError,
-  MAX_LLM_RESPONSE_BYTES,
-  canonicalLlmBaseUrl,
-  isExactLoopback,
-  postLlmJson,
-  providerEndpoint,
-};