patina-cli 3.11.0 → 4.0.0

package/src/commands/init.js

@@ -1,208 +0,0 @@
-import { existsSync, writeFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { createInterface } from 'node:readline/promises';
-import { spawnSync } from 'node:child_process';
-import { stdin as input, stdout as output } from 'node:process';
-import yaml from 'js-yaml';
-import { listBackends } from '../backends/index.js';
-import { inputError } from '../errors.js';
-import { createLogger } from '../logger.js';
-
-const LANGUAGES = ['ko', 'en', 'zh', 'ja'];
-const PROFILES = [
-  'default',
-  'blog',
-  'academic',
-  'technical',
-  'formal',
-  'social',
-  'email',
-  'legal',
-  'medical',
-  'marketing',
-  'narrative',
-  'instructional',
-  'casual-conversation',
-  'code-comment',
-  'commit-message',
-  'release-notes',
-];
-const TONES = ['profile-only', 'casual', 'professional', 'academic', 'narrative', 'marketing', 'instructional', 'auto'];
-const DISPATCH_MODES = ['omc', 'direct', 'api'];
-
-export async function runInit(args = [], { logger = createLogger() } = {}) {
-  const parsed = parseInitArgs(args);
-  if (parsed.help) {
-    printInitHelp();
-    return;
-  }
-
-  const target = resolve(process.cwd(), '.patina.yaml');
-  if (existsSync(target) && !parsed.force) {
-    if (parsed.defaults || !process.stdin.isTTY) {
-      throw inputError(
-        '.patina.yaml already exists',
-        'init will not overwrite an existing project config without confirmation.',
-        'Run `patina init --force` to replace it, or edit .patina.yaml manually.'
-      );
-    }
-  }
-
-  const detected = detectInitDefaults();
-  const answers = parsed.defaults
-    ? detected
-    : await promptForConfig(detected, { target, force: parsed.force, logger });
-
-  if (!answers) {
-    logger.info('init.kept_existing', { message: '[patina] kept existing .patina.yaml' });
-    return;
-  }
-
-  const config = buildInitConfig(answers);
-  writeFileSync(target, `${yaml.dump(config, { lineWidth: 100 }).trimEnd()}\n`, 'utf8');
-  console.log(`[patina] wrote ${target}`);
-}
-
-export function detectInitDefaults() {
-  const backends = listBackends();
-  const authenticated = backends.filter((b) => b.available && b.authenticated);
-  const preferredBackend = (
-    authenticated.find((b) => b.name !== 'openai-http') ||
-    authenticated[0] ||
-    backends.find((b) => b.name === 'openai-http')
-  )?.name || 'openai-http';
-
-  const maxModels = authenticated
-    .map((b) => MODEL_BY_BACKEND[b.name])
-    .filter(Boolean);
-
-  return {
-    language: 'ko',
-    profile: 'default',
-    tone: 'profile-only',
-    backend: preferredBackend,
-    maxModels: maxModels.length > 0 ? maxModels : ['claude', 'gemini'],
-    dispatch: commandAvailable('tmux') ? 'omc' : 'direct',
-  };
-}
-
-function parseInitArgs(args) {
-  const parsed = {};
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    switch (arg) {
-      case '--help':
-      case '-h':
-        parsed.help = true;
-        break;
-      case '--defaults':
-        parsed.defaults = true;
-        break;
-      case '--force':
-      case '--yes':
-      case '-y':
-        parsed.force = true;
-        break;
-      default:
-        throw inputError(
-          `unknown init option ${arg}`,
-          'The init command only accepts --defaults, --force, and --help.',
-          'Run `patina init --help` for usage.'
-        );
-    }
-  }
-  return parsed;
-}
-
-async function promptForConfig(defaults, { target, force, logger = createLogger() }) {
-  if (!process.stdin.isTTY) {
-    throw inputError(
-      'init needs an interactive terminal',
-      'guided setup asks questions before writing .patina.yaml.',
-      'Run `patina init --defaults` for a non-interactive config.'
-    );
-  }
-
-  const rl = createInterface({ input, output });
-  try {
-    if (existsSync(target) && !force) {
-      const overwrite = await ask(rl, `Overwrite existing .patina.yaml?`, 'no', ['yes', 'no'], logger);
-      if (overwrite !== 'yes') return null;
-    }
-
-    const language = await ask(rl, 'Language', defaults.language, LANGUAGES, logger);
-    const profile = await ask(rl, 'Profile', defaults.profile, PROFILES, logger);
-    const tone = await ask(rl, 'Tone', defaults.tone, TONES, logger);
-    const backendChoices = listBackends().map((b) => b.name);
-    const backend = await ask(rl, 'Backend', defaults.backend, backendChoices, logger);
-    const maxModels = await askMulti(rl, 'MAX models', defaults.maxModels, ['claude', 'codex', 'gemini'], logger);
-    const dispatch = await ask(rl, 'Dispatch mode', defaults.dispatch, DISPATCH_MODES, logger);
-    return { language, profile, tone, backend, maxModels, dispatch };
-  } finally {
-    rl.close();
-  }
-}
-
-async function ask(rl, label, defaultValue, choices, logger = createLogger()) {
-  const choiceHint = choices ? ` (${choices.join('/')})` : '';
-  const raw = (await rl.question(`${label}${choiceHint} [${defaultValue}]: `)).trim();
-  const value = raw || defaultValue;
-  if (choices && !choices.includes(value)) {
-    logger.warn('init.unknown_value', { message: `[patina] ${label}: unknown value "${value}", keeping ${defaultValue}` });
-    return defaultValue;
-  }
-  return value;
-}
-
-async function askMulti(rl, label, defaultValues, choices, logger = createLogger()) {
-  const raw = (await rl.question(`${label} (${choices.join(',')}) [${defaultValues.join(',')}]: `)).trim();
-  const values = (raw ? raw.split(',') : defaultValues)
-    .map((value) => value.trim())
-    .filter(Boolean);
-  const valid = values.filter((value) => choices.includes(value));
-  if (valid.length === 0) {
-    logger.warn('init.no_valid_values', { message: `[patina] ${label}: no valid values, keeping ${defaultValues.join(',')}` });
-    return defaultValues;
-  }
-  return [...new Set(valid)];
-}
-
-function buildInitConfig(answers) {
-  return {
-    language: answers.language,
-    profile: answers.profile,
-    tone: answers.tone === 'profile-only' ? null : answers.tone,
-    backend: answers.backend,
-    'max-models': answers.maxModels,
-    dispatch: answers.dispatch,
-  };
-}
-
-function commandAvailable(name) {
-  try {
-    const result = spawnSync(name, ['-V'], { stdio: 'ignore' });
-    return result.status === 0;
-  } catch {
-    return false;
-  }
-}
-
-const MODEL_BY_BACKEND = {
-  'codex-cli': 'codex',
-  'claude-cli': 'claude',
-  'gemini-cli': 'gemini',
-};
-
-function printInitHelp() {
-  console.log(`patina init — create a project .patina.yaml
-
-Usage: patina init [--defaults] [--force]
-
-Guided mode asks for language, profile, tone, backend, MAX models, and dispatch
-mode. It preselects authenticated local backends when available.
-
-Options:
-  --defaults   Write detected defaults without prompts
-  --force      Overwrite an existing .patina.yaml
-`);
-}

package/src/manifest.js

@@ -1,162 +0,0 @@
-// Reproducibility manifest writer — captures enough metadata about a run
-// to reproduce it later (config hash, prompt hash, selected patterns,
-// provider/model, package version, results). Schema is versioned so
-// callers and tooling can detect breaking shape changes.
-
-import { createHash } from 'node:crypto';
-import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
-import { resolve } from 'node:path';
-
-export const MANIFEST_SCHEMA_VERSION = '2';
-
-export function hashSha256(input) {
-  if (input == null) return null;
-  const data = typeof input === 'string' ? input : JSON.stringify(input);
-  return `sha256:${createHash('sha256').update(data).digest('hex')}`;
-}
-
-// Build the manifest body. Caller passes the already-resolved run state;
-// this function is pure (no I/O) so it's easy to unit-test.
-export function buildManifest({
-  patinaVersion,
-  mode,
-  lang,
-  profile,
-  provider,
-  backend,
-  model,
-  configPath,
-  config,
-  patterns,
-  results,
-  startedAt,
-  finishedAt = new Date().toISOString(),
-  temperature = null,
-  seed = null,
-}) {
-  return {
-    manifestVersion: MANIFEST_SCHEMA_VERSION,
-    patina: patinaVersion,
-    startedAt,
-    finishedAt,
-    mode,
-    lang,
-    profile,
-    provider: provider ?? null,
-    backend: backend ?? null,
-    model: model ?? null,
-    temperature,
-    seed,
-    configPath: configPath ?? null,
-    configHash: hashSha256(config),
-    patterns: (patterns ?? []).map((p) => p.frontmatter?.pack || p.file),
-    results: results ?? [],
-  };
-}
-
-// Add one input/output pair's hash + ref to the running results array.
-// Mutates the input array for convenience.
-export function appendResult(
-  results,
-  {
-    inputPath,
-    prompt,
-    outputRef,
-    response,
-    tokensIn = null,
-    tokensOut = null,
-    temperature = null,
-    seed = null,
-    cost = null,
-    scores,
-    iterationLog,
-    calls,
-  }
-) {
-  const entry = {
-    input: inputPath,
-    promptHash: hashSha256(prompt),
-    responseHash: hashSha256(response),
-    output: outputRef,
-    tokensIn,
-    tokensOut,
-    temperature,
-    seed,
-    cost,
-  };
-  if (scores) entry.scores = scores;
-  if (iterationLog) entry.iterationLog = iterationLog;
-  if (calls) entry.calls = calls;
-  results.push(entry);
-  return results;
-}
-
-export function readManifest(path) {
-  return normalizeManifest(JSON.parse(readFileSync(path, 'utf8')));
-}
-
-export function normalizeManifest(manifest) {
-  if (!manifest || typeof manifest !== 'object') {
-    throw new Error('Manifest must be a JSON object');
-  }
-
-  const version = String(manifest.manifestVersion ?? '1');
-  if (version === MANIFEST_SCHEMA_VERSION) {
-    return {
-      ...manifest,
-      results: normalizeV2Results(manifest.results),
-    };
-  }
-
-  if (version === '1') {
-    return {
-      ...manifest,
-      manifestVersion: '1',
-      temperature: manifest.temperature ?? null,
-      seed: manifest.seed ?? null,
-      results: normalizeV1Results(manifest.results),
-    };
-  }
-
-  throw new Error(`Unsupported manifest schema version: ${version}`);
-}
-
-function normalizeV1Results(results) {
-  return (results ?? []).map((entry) => ({
-    input: entry.input ?? null,
-    promptHash: entry.promptHash ?? null,
-    responseHash: entry.responseHash ?? null,
-    output: entry.output ?? null,
-    tokensIn: entry.tokensIn ?? null,
-    tokensOut: entry.tokensOut ?? null,
-    temperature: entry.temperature ?? null,
-    seed: entry.seed ?? null,
-    cost: entry.cost ?? null,
-    ...(entry.scores ? { scores: entry.scores } : {}),
-    ...(entry.iterationLog ? { iterationLog: entry.iterationLog } : {}),
-    ...(entry.calls ? { calls: entry.calls } : {}),
-  }));
-}
-
-function normalizeV2Results(results) {
-  return (results ?? []).map((entry) => ({
-    ...entry,
-    responseHash: entry.responseHash ?? null,
-    tokensIn: entry.tokensIn ?? null,
-    tokensOut: entry.tokensOut ?? null,
-    temperature: entry.temperature ?? null,
-    seed: entry.seed ?? null,
-    cost: entry.cost ?? null,
-    calls: entry.calls ?? [],
-  }));
-}
-
-export function writeManifest(dir, manifest, outputs = []) {
-  mkdirSync(dir, { recursive: true });
-  const manifestPath = resolve(dir, 'manifest.json');
-  writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
-  for (const { name, content } of outputs) {
-    writeFileSync(resolve(dir, name), content);
-  }
-  return manifestPath;
-}

package/src/max-mode.js

@@ -1,207 +0,0 @@
-import { callLLM as defaultCallLLM, callLLMMultiple } from './api.js';
-import { scoreText, scoreMPS } from './scoring.js';
-import { createLogger } from './logger.js';
-
-const DEFAULT_WALL_CLOCK_BUDGET_MS = 300_000;
-
-export async function runMaxMode({
-  prompt,
-  sourceText,
-  models,
-  apiKey,
-  baseURL,
-  config,
-  patterns,
-  maxConcurrency,
-  wallClockBudgetMs = DEFAULT_WALL_CLOCK_BUDGET_MS,
-  callLLM = defaultCallLLM,
-  now = () => Date.now(),
-  sleep,
-  callLLMMultipleImpl = callLLMMultiple,
-  scoreTextImpl = scoreText,
-  scoreMPSImpl = scoreMPS,
-  signal,
-  logger = createLogger(),
-}) {
-  logger.info('max.dispatch', {
-    message: `[patina-max] Dispatching to ${models.length} models: ${models.join(', ')}`,
-  });
-
-  const controller = new AbortController();
-  const abortFromCaller = () => controller.abort();
-  let cleanupCallerSignal = () => {};
-  if (signal) {
-    if (signal.aborted) {
-      controller.abort();
-    } else {
-      signal.addEventListener('abort', abortFromCaller, { once: true });
-      cleanupCallerSignal = () => signal.removeEventListener('abort', abortFromCaller);
-    }
-  }
-  const deadline = now() + wallClockBudgetMs;
-  const progressStartedAt = now();
-  const modelStatus = new Map(models.map((model) => [model, '...']));
-  const modelStartedAt = new Map();
-  let timedOut = false;
-  const timeout = setTimeout(() => {
-    timedOut = true;
-    controller.abort();
-    logger.warn('max.timeout', { message: '[patina-max] MAX wall-clock timeout reached; returning partial results' });
-  }, wallClockBudgetMs);
-
-  const renderProgress = () => {
-    const statuses = models.map((model) => `${model} ${modelStatus.get(model) || '...'}`).join('  ');
-    const elapsedSeconds = Math.max(0, Math.round((now() - progressStartedAt) / 1000));
-    logger.progress('max.progress', {
-      message: `[patina-max] ${statuses}  (${elapsedSeconds}s)`,
-      elapsed_ms: Math.max(0, now() - progressStartedAt),
-    });
-  };
-
-  const candidates = [];
-  try {
-    const results = await callLLMMultipleImpl({
-      prompt,
-      models,
-      apiKey,
-      baseURL,
-      maxConcurrency,
-      deadline,
-      signal: controller.signal,
-      callLLM,
-      now,
-      sleep,
-      onStart: (model) => {
-        modelStartedAt.set(model, now());
-        modelStatus.set(model, '...');
-        renderProgress();
-      },
-      onComplete: (model, ok) => {
-        const latencyMs = modelStartedAt.has(model) ? Math.max(0, now() - modelStartedAt.get(model)) : undefined;
-        modelStatus.set(model, ok ? '✓' : '✗');
-        logger.progress('max.model_complete', {
-          message: formatMaxProgress(models, modelStatus, progressStartedAt, now),
-          model,
-          latency_ms: latencyMs,
-        });
-      },
-    });
-
-    for (const r of results) {
-      if (!r.ok) {
-        candidates.push({ model: r.model, ok: false, error: r.error });
-        continue;
-      }
-
-      let aiScoreResult = null;
-      let mpsResult = null;
-
-      if (!timedOut) {
-        aiScoreResult = await scoreTextImpl({
-          text: r.result,
-          config,
-          patterns,
-          apiKey,
-          baseURL,
-          model: r.model,
-          deadline,
-          signal: controller.signal,
-          callLLM,
-          logger,
-          now,
-          sleep,
-        });
-      }
-
-      if (!timedOut) {
-        mpsResult = await scoreMPSImpl({
-          original: sourceText,
-          rewritten: r.result,
-          apiKey,
-          baseURL,
-          model: r.model,
-          deadline,
-          signal: controller.signal,
-          callLLM,
-          logger,
-          now,
-          sleep,
-        });
-      }
-
-      candidates.push({
-        model: r.model,
-        ok: true,
-        result: r.result,
-        aiScore: aiScoreResult?.overall ?? null,
-        mps: mpsResult?.mps ?? null,
-      });
-
-      if (timedOut) break;
-    }
-  } finally {
-    clearTimeout(timeout);
-    cleanupCallerSignal();
-    logger.closeProgress();
-  }
-
-  const { candidate: best, fallback } = selectBest(candidates, {
-    log: (message) => logger.warn('max.selection_tie', { message }),
-  });
-  const allFailed = best === null;
-
-  return {
-    type: 'max-mode',
-    candidates,
-    best,
-    allFailed,
-    mpsFallback: fallback,
-    timedOut,
-  };
-}
-
-export function selectBest(
-  candidates,
-  { log = (message) => createLogger().warn('max.selection_tie', { message }) } = {}
-) {
-  const valid = candidates.filter((c) => c.ok && c.aiScore !== null);
-
-  if (valid.length === 0) {
-    return { candidate: null, fallback: false };
-  }
-
-  const passingMps = valid.filter((c) => (c.mps ?? 0) >= 70);
-
-  if (passingMps.length > 0) {
-    const best = passingMps.reduce((best, current) =>
-      // Strict comparison preserves --models config order when AI scores tie.
-      (current.aiScore < best.aiScore) ? current : best
-    );
-
-    if (passingMps.some((c) => c !== best && c.aiScore === best.aiScore)) {
-      log(`[patina-max] Tie on AI score — picked ${best.model} by config order`);
-    }
-
-    return { candidate: best, fallback: false };
-  }
-
-  const best = valid.reduce((best, current) => {
-    const bestMps = best.mps ?? -1;
-    const currentMps = current.mps ?? -1;
-    // Strict comparison preserves --models config order when MPS scores tie.
-    return currentMps > bestMps ? current : best;
-  });
-
-  const bestMps = best.mps ?? -1;
-  if (valid.some((c) => c !== best && (c.mps ?? -1) === bestMps)) {
-    log(`[patina-max] Tie on MPS — picked ${best.model} by config order`);
-  }
-
-  return { candidate: best, fallback: true };
-}
-
-function formatMaxProgress(models, modelStatus, startedAt, now) {
-  const statuses = models.map((model) => `${model} ${modelStatus.get(model) || '...'}`).join('  ');
-  const elapsedSeconds = Math.max(0, Math.round((now() - startedAt) / 1000));
-  return `[patina-max] ${statuses}  (${elapsedSeconds}s)`;
-}