@sienklogic/plan-build-run 2.1.0 → 2.1.1

package/plugins/pbr/scripts/lib/todo.js

@@ -0,0 +1,300 @@
+/**
+ * lib/todo.js — File-based todo operations for Plan-Build-Run.
+ *
+ * Todos are individual .md files with YAML frontmatter stored in:
+ *   .planning/todos/pending/{NNN}-{slug}.md  — active todos
+ *   .planning/todos/done/{NNN}-{slug}.md     — completed todos
+ *
+ * Frontmatter fields: title, status, priority, source, created, completed, theme.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { parseYamlFrontmatter, atomicWrite } = require('./core');
+
+// --- Helpers ---
+
+/**
+ * Parse a todo filename into its components.
+ * @param {string} filename - e.g. "042-fix-login-bug.md"
+ * @returns {{ number: number, slug: string } | null}
+ */
+function parseTodoFilename(filename) {
+  const match = filename.match(/^(\d+)-(.+)\.md$/);
+  if (!match) return null;
+  return { number: parseInt(match[1], 10), slug: match[2] };
+}
+
+/**
+ * Read and parse a single todo file.
+ * @param {string} filePath - Absolute path to the .md file
+ * @param {string} filename - Just the filename for parsing NNN-slug
+ * @returns {object} Todo object with number, slug, title, priority, theme, etc.
+ */
+function parseTodoFile(filePath, filename) {
+  const parsed = parseTodoFilename(filename);
+  const content = fs.readFileSync(filePath, 'utf8');
+  const fm = parseYamlFrontmatter(content);
+
+  // Extract body (everything after frontmatter closing ---)
+  const bodyMatch = content.match(/^---[\s\S]*?\n---\s*\n?([\s\S]*)$/);
+  const body = bodyMatch ? bodyMatch[1].trim() : '';
+
+  return {
+    number: parsed ? parsed.number : null,
+    slug: parsed ? parsed.slug : filename.replace(/\.md$/, ''),
+    filename,
+    title: fm.title || '',
+    status: fm.status || 'pending',
+    priority: fm.priority || 'P2',
+    theme: fm.theme || 'general',
+    source: fm.source || 'conversation',
+    created: fm.created || null,
+    completed: fm.completed || null,
+    body
+  };
+}
+
+/**
+ * Scan both pending/ and done/ to find the highest existing todo number.
+ * @param {string} planningDir - Path to .planning/
+ * @returns {number} Highest number found (0 if none)
+ */
+function findHighestNumber(planningDir) {
+  let highest = 0;
+  const dirs = [
+    path.join(planningDir, 'todos', 'pending'),
+    path.join(planningDir, 'todos', 'done')
+  ];
+  for (const dir of dirs) {
+    if (!fs.existsSync(dir)) continue;
+    const files = fs.readdirSync(dir).filter(f => f.endsWith('.md'));
+    for (const file of files) {
+      const parsed = parseTodoFilename(file);
+      if (parsed && parsed.number > highest) {
+        highest = parsed.number;
+      }
+    }
+  }
+  return highest;
+}
+
+/**
+ * Generate a slug from a description.
+ * Takes first ~4 meaningful words, lowercase, hyphen-separated.
+ * @param {string} description
+ * @returns {string}
+ */
+function generateSlug(description) {
+  const stopWords = new Set(['a', 'an', 'the', 'to', 'in', 'on', 'for', 'of', 'and', 'or', 'is', 'it', 'with']);
+  const words = description
+    .toLowerCase()
+    .replace(/[^a-z0-9\s-]/g, '')
+    .split(/\s+/)
+    .filter(w => w.length > 0 && !stopWords.has(w))
+    .slice(0, 4);
+  return words.join('-') || 'untitled';
+}
+
+// --- Core operations ---
+
+/**
+ * List todos from a directory (pending or done).
+ * @param {string} planningDir - Path to .planning/
+ * @param {object} opts - { status: 'pending'|'done'|'all', theme: string|null }
+ * @returns {{ todos: object[], count: number }}
+ */
+function todoList(planningDir, opts = {}) {
+  const status = opts.status || 'pending';
+  const theme = opts.theme || null;
+  const todos = [];
+
+  const dirsToScan = status === 'all'
+    ? ['pending', 'done']
+    : [status];
+
+  for (const subdir of dirsToScan) {
+    const dir = path.join(planningDir, 'todos', subdir);
+    if (!fs.existsSync(dir)) continue;
+
+    const files = fs.readdirSync(dir).filter(f => f.endsWith('.md')).sort();
+    for (const file of files) {
+      const todo = parseTodoFile(path.join(dir, file), file);
+      if (theme && todo.theme !== theme) continue;
+      todos.push(todo);
+    }
+  }
+
+  // Sort by number
+  todos.sort((a, b) => (a.number || 0) - (b.number || 0));
+
+  return { todos, count: todos.length };
+}
+
+/**
+ * Get a specific todo by its NNN number.
+ * Searches pending first, then done.
+ * @param {string} planningDir - Path to .planning/
+ * @param {number|string} num - The todo number (e.g. 42 or "042")
+ * @returns {object} Todo object with full body, or { error: "..." }
+ */
+function todoGet(planningDir, num) {
+  const numStr = String(num).padStart(3, '0');
+  const prefix = numStr + '-';
+
+  for (const subdir of ['pending', 'done']) {
+    const dir = path.join(planningDir, 'todos', subdir);
+    if (!fs.existsSync(dir)) continue;
+
+    const files = fs.readdirSync(dir).filter(f => f.startsWith(prefix) && f.endsWith('.md'));
+    if (files.length > 0) {
+      const todo = parseTodoFile(path.join(dir, files[0]), files[0]);
+      todo.location = subdir;
+      return todo;
+    }
+  }
+
+  return { error: `Todo ${numStr} not found in pending or done` };
+}
+
+/**
+ * Add a new todo.
+ * @param {string} planningDir - Path to .planning/
+ * @param {string} title - The todo description
+ * @param {object} opts - { priority: 'P1'|'P2'|'P3', theme: string, source: string }
+ * @returns {{ success: boolean, number: number, filename: string, path: string } | { error: string }}
+ */
+function todoAdd(planningDir, title, opts = {}) {
+  if (!title || !title.trim()) {
+    return { error: 'Title is required' };
+  }
+
+  const pendingDir = path.join(planningDir, 'todos', 'pending');
+
+  // Ensure directory exists
+  fs.mkdirSync(pendingDir, { recursive: true });
+
+  const nextNum = findHighestNumber(planningDir) + 1;
+  const numStr = String(nextNum).padStart(3, '0');
+  const slug = generateSlug(title);
+  const filename = `${numStr}-${slug}.md`;
+  const filePath = path.join(pendingDir, filename);
+
+  const priority = opts.priority || 'P2';
+  const theme = opts.theme || 'general';
+  const source = opts.source || 'cli';
+  const today = new Date().toISOString().slice(0, 10);
+
+  const content = [
+    '---',
+    `title: "${title.replace(/"/g, '\\"')}"`,
+    'status: pending',
+    `priority: ${priority}`,
+    `source: ${source}`,
+    `created: ${today}`,
+    `theme: ${theme}`,
+    '---',
+    '',
+    '## Goal',
+    '',
+    title,
+    ''
+  ].join('\n');
+
+  const result = atomicWrite(filePath, content);
+  if (!result.success) {
+    return { error: `Failed to write todo file: ${result.error}` };
+  }
+
+  return {
+    success: true,
+    number: nextNum,
+    number_padded: numStr,
+    filename,
+    path: filePath
+  };
+}
+
+/**
+ * Mark a todo as done. Moves from pending/ to done/.
+ * Write to done/ first, verify, then delete from pending/.
+ * @param {string} planningDir - Path to .planning/
+ * @param {number|string} num - The todo number
+ * @returns {{ success: boolean, title: string, filename: string } | { error: string }}
+ */
+function todoDone(planningDir, num) {
+  const numStr = String(num).padStart(3, '0');
+  const prefix = numStr + '-';
+
+  const pendingDir = path.join(planningDir, 'todos', 'pending');
+  const doneDir = path.join(planningDir, 'todos', 'done');
+
+  if (!fs.existsSync(pendingDir)) {
+    return { error: `Todo ${numStr} not found — no pending directory` };
+  }
+
+  const files = fs.readdirSync(pendingDir).filter(f => f.startsWith(prefix) && f.endsWith('.md'));
+  if (files.length === 0) {
+    return { error: `Todo ${numStr} not found in pending todos` };
+  }
+
+  const filename = files[0];
+  const pendingPath = path.join(pendingDir, filename);
+  const content = fs.readFileSync(pendingPath, 'utf8');
+  const fm = parseYamlFrontmatter(content);
+  const title = fm.title || '';
+  const today = new Date().toISOString().slice(0, 10);
+
+  // Update frontmatter: status → done, add completed date
+  let updatedContent = content
+    .replace(/^status:\s*.*/m, 'status: done')
+    .replace(/^(---[\s\S]*?)(---)/, (match, front, close) => {
+      // Add completed field if not present
+      if (!/^completed:/m.test(front)) {
+        return front + `completed: ${today}\n${close}`;
+      }
+      return match.replace(/^completed:\s*.*/m, `completed: ${today}`);
+    });
+
+  // Ensure done/ directory exists
+  fs.mkdirSync(doneDir, { recursive: true });
+
+  // Write to done/ FIRST
+  const donePath = path.join(doneDir, filename);
+  const writeResult = atomicWrite(donePath, updatedContent);
+  if (!writeResult.success) {
+    return { error: `Failed to write to done/: ${writeResult.error}. Pending file preserved.` };
+  }
+
+  // Verify done/ write succeeded
+  if (!fs.existsSync(donePath)) {
+    return { error: 'Done file not found after write. Pending file preserved.' };
+  }
+
+  // Only now delete from pending/
+  try {
+    fs.unlinkSync(pendingPath);
+  } catch (e) {
+    // Non-fatal — todo is in done/ now, pending copy is just stale
+    return {
+      success: true,
+      title,
+      filename,
+      warning: `Completed but could not remove from pending/: ${e.message}`
+    };
+  }
+
+  return { success: true, title, filename };
+}
+
+module.exports = {
+  todoList,
+  todoGet,
+  todoAdd,
+  todoDone,
+  // Exported for testing
+  parseTodoFilename,
+  parseTodoFile,
+  findHighestNumber,
+  generateSlug
+};

package/plugins/pbr/scripts/local-llm/client.js

@@ -0,0 +1,237 @@
+/* global fetch, AbortSignal, performance */
+'use strict';
+
+const {
+  isDisabledPersistent,
+  recordFailurePersistent,
+  resetCircuitPersistent
+} = require('../lib/circuit-state');
+
+// Circuit breaker: Map<operationType, { failures: number, disabled: boolean }>
+const circuitState = new Map();
+
+/**
+ * Attempts to parse JSON from text that may be raw JSON or wrapped in a markdown code block.
+ * @param {string} text
+ * @returns {{ ok: true, data: any } | { ok: false, raw: string }}
+ */
+function tryParseJSON(text) {
+  // Attempt 1: direct parse
+  try {
+    const data = JSON.parse(text);
+    return { ok: true, data };
+  } catch (_) {
+    // fall through
+  }
+
+  // Attempt 2: extract from markdown code block
+  const codeBlockMatch = text.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+  if (codeBlockMatch) {
+    try {
+      const data = JSON.parse(codeBlockMatch[1].trim());
+      return { ok: true, data };
+    } catch (_) {
+      // fall through
+    }
+  }
+
+  // Attempt 3: find first {...}
+  const objectMatch = text.match(/\{[\s\S]*\}/);
+  if (objectMatch) {
+    try {
+      const data = JSON.parse(objectMatch[0]);
+      return { ok: true, data };
+    } catch (_) {
+      // fall through
+    }
+  }
+
+  return { ok: false, raw: text };
+}
+
+/**
+ * Maps an error to one of 5 canonical types.
+ * @param {Error} err
+ * @returns {{ type: string, message: string }}
+ */
+function categorizeError(err) {
+  if (
+    (err.cause && err.cause.code === 'ECONNREFUSED') ||
+    (err.message && err.message.includes('ECONNREFUSED'))
+  ) {
+    return { type: 'ECONNREFUSED', message: err.message };
+  }
+  if (err.name === 'TimeoutError' || err.name === 'AbortError') {
+    return { type: 'timeout', message: err.message };
+  }
+  if (err.message && err.message.startsWith('HTTP ')) {
+    return { type: 'http_error', message: err.message };
+  }
+  if (err instanceof SyntaxError) {
+    return { type: 'json_parse', message: err.message };
+  }
+  return { type: 'wrong_answer', message: err.message };
+}
+
+/**
+ * Returns true if the circuit is open (operation should be skipped).
+ * @param {string} operationType
+ * @param {number} maxFailures
+ * @returns {boolean}
+ */
+function isDisabled(operationType, maxFailures) {
+  const entry = circuitState.get(operationType);
+  if (!entry) return false;
+  return entry.disabled || entry.failures >= maxFailures;
+}
+
+/**
+ * Records a failure for an operation type. Disables the circuit if maxFailures is reached.
+ * @param {string} operationType
+ * @param {number} maxFailures
+ */
+function recordFailure(operationType, maxFailures) {
+  const entry = circuitState.get(operationType) || { failures: 0, disabled: false };
+  entry.failures += 1;
+  if (entry.failures >= maxFailures) {
+    entry.disabled = true;
+  }
+  circuitState.set(operationType, entry);
+}
+
+/**
+ * Resets the circuit breaker for an operation type.
+ * @param {string} operationType
+ */
+function resetCircuit(operationType) {
+  circuitState.delete(operationType);
+}
+
+/**
+ * Sends a chat completion request to a local LLM endpoint with retry and circuit-breaker logic.
+ *
+ * @param {object} config - local_llm config block (resolved)
+ * @param {string} prompt - user message to send
+ * @param {string} operationType - operation identifier for circuit breaker tracking
+ * @param {object} [options={}] - optional parameters
+ * @param {boolean} [options.logprobs] - if true, request logprobs from the API
+ * @param {string} [options.planningDir] - optional .planning directory for persistent circuit breaker state
+ * @returns {Promise<{ content: string, latency_ms: number, tokens: number, logprobsData: Array<{token: string, logprob: number}>|null }>}
+ */
+async function complete(config, prompt, operationType, options = {}) {
+  const endpoint = config.endpoint || 'http://localhost:11434';
+  const model = config.model || 'qwen2.5-coder:7b';
+  const timeoutMs = config.timeout_ms || 3000;
+  const maxRetries = config.max_retries != null ? config.max_retries : 1;
+  const numCtx = (config.advanced && config.advanced.num_ctx) || 4096;
+  const keepAlive = (config.advanced && config.advanced.keep_alive) || '30m';
+  const maxFailures = (config.advanced && config.advanced.disable_after_failures) || 3;
+  const planningDir = options.planningDir || null;
+
+  // Check in-memory circuit first (fast path), then persistent state
+  if (isDisabled(operationType, maxFailures)) {
+    const err = new Error('Circuit open for operation: ' + operationType);
+    err.type = 'circuit_open';
+    throw err;
+  }
+  if (planningDir && isDisabledPersistent(planningDir, operationType, maxFailures)) {
+    const err = new Error('Circuit open for operation: ' + operationType);
+    err.type = 'circuit_open';
+    throw err;
+  }
+
+  const bodyObj = {
+    model,
+    messages: [
+      {
+        role: 'system',
+        content:
+          'You are a precise classification assistant. Always respond with valid JSON only. No explanations outside the JSON.'
+      },
+      { role: 'user', content: prompt }
+    ],
+    response_format: { type: 'json_object' },
+    temperature: 0.1,
+    max_tokens: 200,
+    keep_alive: keepAlive,
+    num_ctx: numCtx
+  };
+  if (options.logprobs === true) {
+    bodyObj.logprobs = true;
+    bodyObj.top_logprobs = 3;
+  }
+  const body = JSON.stringify(bodyObj);
+
+  const url = endpoint + '/v1/chat/completions';
+  const totalAttempts = maxRetries + 1;
+
+  let lastErr;
+  for (let attempt = 0; attempt < totalAttempts; attempt++) {
+    const start = performance.now();
+    try {
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body,
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+
+      if (!res.ok) {
+        const errText = await res.text().catch(() => '');
+        throw new Error('HTTP ' + res.status + ': ' + errText);
+      }
+
+      const json = await res.json();
+      const content = json.choices[0].message.content;
+      const completionTokens = (json.usage && json.usage.completion_tokens) || 0;
+      const latency_ms = performance.now() - start;
+      const logprobsData = (options.logprobs && json.choices[0].logprobs)
+        ? json.choices[0].logprobs.content
+        : null;
+
+      return { content, latency_ms, tokens: completionTokens, logprobsData };
+    } catch (err) {
+      lastErr = err;
+      const isConnRefused =
+        (err.cause && err.cause.code === 'ECONNREFUSED') ||
+        (err.message && err.message.includes('ECONNREFUSED'));
+
+      if (isConnRefused) {
+        // Server not running — no point retrying
+        recordFailure(operationType, maxFailures);
+        if (planningDir) recordFailurePersistent(planningDir, operationType, maxFailures);
+        throw err;
+      }
+
+      const isTimeout = err.name === 'TimeoutError' || err.name === 'AbortError';
+      const isHttpError = err.message && err.message.startsWith('HTTP ');
+
+      if ((isTimeout || isHttpError) && attempt < totalAttempts - 1) {
+        // Retry
+        continue;
+      }
+
+      // Final attempt or non-retryable error
+      recordFailure(operationType, maxFailures);
+      if (planningDir) recordFailurePersistent(planningDir, operationType, maxFailures);
+      throw err;
+    }
+  }
+
+  // Should not reach here, but guard anyway
+  recordFailure(operationType, maxFailures);
+  if (planningDir) recordFailurePersistent(planningDir, operationType, maxFailures);
+  throw lastErr;
+}
+
+module.exports = {
+  tryParseJSON,
+  categorizeError,
+  isDisabled,
+  recordFailure,
+  resetCircuit,
+  complete,
+  isDisabledPersistent,
+  recordFailurePersistent,
+  resetCircuitPersistent
+};