@thispointon/kondi-chat 0.1.2

package/src/council-engine/pipeline/index.ts

@@ -0,0 +1,9 @@
+/**
+ * Pipeline System: Barrel Exports
+ */
+
+export * from './types';
+export { pipelineStore, PipelineStore } from './store';
+export { PipelineExecutor, type PipelineExecutorCallbacks, type PlatformAdapter } from './executor';
+export * from './memory-store';
+export * from './run-output';

package/src/council-engine/pipeline/install-detect.ts

@@ -0,0 +1,84 @@
+/**
+ * Install Command Auto-Detection
+ * Scans project files to determine the appropriate dependency install command.
+ * Reuses ReadFileFn type from test-detect.ts.
+ */
+
+import type { ReadFileFn } from './test-detect';
+
+export interface DetectedInstall {
+  command: string;
+  framework: string;
+  confidence: 'high' | 'medium' | 'low';
+}
+
+/**
+ * Detect the appropriate install command for a project directory.
+ * Checks common project files in priority order.
+ *
+ * @param workingDir  Absolute path to the project root
+ * @param readFile    Optional callback that reads a file and returns its content
+ *                    (or null if not found). When omitted, detection is skipped.
+ */
+export async function detectInstallCommand(
+  workingDir: string,
+  readFile?: ReadFileFn,
+): Promise<DetectedInstall | null> {
+  if (!readFile) return null;
+
+  const fileExists = async (path: string): Promise<string | null> => {
+    try {
+      return await readFile(path);
+    } catch {
+      return null;
+    }
+  };
+
+  // 1. Node.js — lockfile-first detection
+  const pnpmLock = await fileExists(`${workingDir}/pnpm-lock.yaml`);
+  if (pnpmLock) {
+    return { command: 'pnpm install', framework: 'pnpm', confidence: 'high' };
+  }
+
+  const yarnLock = await fileExists(`${workingDir}/yarn.lock`);
+  if (yarnLock) {
+    return { command: 'yarn install', framework: 'yarn', confidence: 'high' };
+  }
+
+  const packageLock = await fileExists(`${workingDir}/package-lock.json`);
+  if (packageLock) {
+    return { command: 'npm install', framework: 'npm', confidence: 'high' };
+  }
+
+  const packageJson = await fileExists(`${workingDir}/package.json`);
+  if (packageJson) {
+    return { command: 'npm install', framework: 'npm', confidence: 'medium' };
+  }
+
+  // 2. Python — requirements.txt or pyproject.toml
+  const requirements = await fileExists(`${workingDir}/requirements.txt`);
+  if (requirements) {
+    return { command: 'pip install -r requirements.txt', framework: 'pip', confidence: 'high' };
+  }
+
+  const pyprojectToml = await fileExists(`${workingDir}/pyproject.toml`);
+  if (pyprojectToml && (pyprojectToml.includes('[project.dependencies]') || pyprojectToml.includes('dependencies'))) {
+    return { command: 'pip install -e .', framework: 'pip', confidence: 'medium' };
+  }
+
+  // 3. Rust — skip (cargo build handles deps implicitly)
+
+  // 4. Go — go.mod
+  const goMod = await fileExists(`${workingDir}/go.mod`);
+  if (goMod) {
+    return { command: 'go mod download', framework: 'go', confidence: 'high' };
+  }
+
+  // 5. Makefile with install target
+  const makefile = await fileExists(`${workingDir}/Makefile`);
+  if (makefile && /^install\s*:/m.test(makefile)) {
+    return { command: 'make install', framework: 'make', confidence: 'medium' };
+  }
+
+  return null;
+}

package/src/council-engine/pipeline/memory-store.ts

@@ -0,0 +1,182 @@
+/**
+ * Pipeline Memory Store
+ * Reads/writes JSONL memory files and patterns from disk via PlatformAdapter.
+ * Memory lives at {workingDir}/.kondi/memory/{pipelineId}.jsonl
+ */
+
+import type { MemoryEntry } from './types';
+import type { PlatformAdapter } from './executor';
+
+// ============================================================================
+// Path Helpers
+// ============================================================================
+
+export function getMemoryDir(workingDir: string): string {
+  return `${workingDir.replace(/\/$/, '')}/.kondi/memory`;
+}
+
+export function getMemoryFilePath(workingDir: string, pipelineId: string): string {
+  return `${getMemoryDir(workingDir)}/${pipelineId}.jsonl`;
+}
+
+export function getPatternsFilePath(workingDir: string, pipelineId: string): string {
+  return `${getMemoryDir(workingDir)}/${pipelineId}_patterns.json`;
+}
+
+// ============================================================================
+// Read Operations
+// ============================================================================
+
+export async function readAllEntries(
+  platform: PlatformAdapter,
+  workingDir: string,
+  pipelineId: string
+): Promise<MemoryEntry[]> {
+  if (!platform.readFile) return [];
+  const filePath = getMemoryFilePath(workingDir, pipelineId);
+  try {
+    const content = await platform.readFile(filePath);
+    if (!content) return [];
+    return content
+      .split('\n')
+      .filter((line) => line.trim())
+      .map((line) => JSON.parse(line) as MemoryEntry);
+  } catch {
+    return [];
+  }
+}
+
+export async function readLastEntries(
+  platform: PlatformAdapter,
+  workingDir: string,
+  pipelineId: string,
+  n: number
+): Promise<MemoryEntry[]> {
+  const all = await readAllEntries(platform, workingDir, pipelineId);
+  return all.slice(-n);
+}
+
+export async function readPatterns(
+  platform: PlatformAdapter,
+  workingDir: string,
+  pipelineId: string
+): Promise<string> {
+  if (!platform.readFile) return '';
+  const filePath = getPatternsFilePath(workingDir, pipelineId);
+  try {
+    const content = await platform.readFile(filePath);
+    if (!content) return '';
+    const data = JSON.parse(content);
+    if (!Array.isArray(data.patterns)) return '';
+    return data.patterns.map((p: string) => `- ${p}`).join('\n');
+  } catch {
+    return '';
+  }
+}
+
+// ============================================================================
+// Write Operations
+// ============================================================================
+
+export async function appendEntry(
+  platform: PlatformAdapter,
+  workingDir: string,
+  pipelineId: string,
+  entry: MemoryEntry
+): Promise<void> {
+  const filePath = getMemoryFilePath(workingDir, pipelineId);
+  const line = JSON.stringify(entry);
+
+  let existing = '';
+  if (platform.readFile) {
+    try {
+      existing = (await platform.readFile(filePath)) || '';
+    } catch {
+      // File doesn't exist yet
+    }
+  }
+
+  const newContent = existing
+    ? (existing.endsWith('\n') ? existing : existing + '\n') + line + '\n'
+    : line + '\n';
+
+  await platform.writeFile(filePath, newContent);
+}
+
+// ============================================================================
+// Formatting for Templates
+// ============================================================================
+
+function formatDate(iso: string): string {
+  try {
+    return new Date(iso).toISOString().split('T')[0];
+  } catch {
+    return iso;
+  }
+}
+
+export function formatEntriesForTemplate(entries: MemoryEntry[]): string {
+  if (entries.length === 0) return '';
+  return entries.map((entry) => {
+    const header = `--- Run #${entry.runNumber} (${formatDate(entry.runDate)})${entry.compressed ? ' [compressed]' : ''} ---`;
+    const captures = Object.entries(entry.captures)
+      .map(([stepName, content]) => `[${stepName}]:\n${content}`)
+      .join('\n\n');
+    return `${header}\n${captures}`;
+  }).join('\n\n');
+}
+
+export function formatEntryCapture(entry: MemoryEntry, stepName: string): string {
+  // Try exact match first, then case-insensitive
+  if (entry.captures[stepName]) return entry.captures[stepName];
+  const key = Object.keys(entry.captures).find(
+    (k) => k.toLowerCase() === stepName.toLowerCase()
+  );
+  return key ? entry.captures[key] : '';
+}
+
+// ============================================================================
+// Run Numbering
+// ============================================================================
+
+export async function getNextRunNumber(
+  platform: PlatformAdapter,
+  workingDir: string,
+  pipelineId: string
+): Promise<number> {
+  const entries = await readAllEntries(platform, workingDir, pipelineId);
+  if (entries.length === 0) return 1;
+  const maxRun = Math.max(...entries.map((e) => e.runNumber));
+  return maxRun + 1;
+}
+
+// ============================================================================
+// Memory Context Builder (for template rendering)
+// ============================================================================
+
+export interface MemoryContext {
+  all: string;
+  last: string;
+  lastN: (n: number) => string;
+  lastCapture: (stepName: string) => string;
+  patterns: string;
+}
+
+export async function buildMemoryContext(
+  platform: PlatformAdapter,
+  workingDir: string,
+  pipelineId: string
+): Promise<MemoryContext> {
+  const allEntries = await readAllEntries(platform, workingDir, pipelineId);
+  const patternsStr = await readPatterns(platform, workingDir, pipelineId);
+  const lastEntry = allEntries.length > 0 ? allEntries[allEntries.length - 1] : null;
+
+  return {
+    all: formatEntriesForTemplate(allEntries),
+    last: lastEntry ? formatEntriesForTemplate([lastEntry]) : '',
+    lastN: (n: number) => formatEntriesForTemplate(allEntries.slice(-n)),
+    lastCapture: (stepName: string) =>
+      lastEntry ? formatEntryCapture(lastEntry, stepName) : '',
+    patterns: patternsStr,
+  };
+}

package/src/council-engine/pipeline/output-parsers.ts

@@ -0,0 +1,146 @@
+/**
+ * Shared Output Parsers
+ *
+ * Parsing functions for Claude CLI stream-json and Codex CLI JSONL output.
+ * Used by both the GUI caller (Tauri invoke) and CLI caller (Node.js spawn).
+ */
+
+export interface ParsedOutput {
+  text: string;
+  tokensUsed: number;
+  sessionId?: string;
+}
+
+/**
+ * Check if a model ID corresponds to an OpenAI model (routes to Codex CLI).
+ */
+export function isOpenAIModel(model: string): boolean {
+  return /^(gpt-|o[1-9]|codex|davinci|chatgpt)/.test(model);
+}
+
+/**
+ * Parse raw stream-json output from Claude CLI.
+ * Handles the `--output-format stream-json` JSONL stream.
+ */
+export function parseStreamJsonOutput(rawOutput: string): ParsedOutput {
+  if (!rawOutput.includes('{"type":')) {
+    return { text: rawOutput, tokensUsed: 0 };
+  }
+
+  const lines = rawOutput.split('\n').filter(l => l.trim());
+  let resultText = '';
+  let isErrorResult = false;
+  const textChunks: string[] = [];
+  const errorChunks: string[] = [];
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let sessionId: string | undefined;
+
+  for (const line of lines) {
+    try {
+      const json = JSON.parse(line);
+
+      // Extract session_id from init event or result
+      if (json.session_id && !sessionId) {
+        sessionId = json.session_id;
+      }
+
+      if (json.type === 'result' && json.result) {
+        resultText = typeof json.result === 'string' ? json.result : JSON.stringify(json.result);
+        if (json.is_error) isErrorResult = true;
+        if (json.session_id) sessionId = json.session_id;
+      }
+
+      if (json.type === 'error') {
+        const errText = json.error || json.body || JSON.stringify(json);
+        errorChunks.push(typeof errText === 'string' ? errText : JSON.stringify(errText));
+      }
+
+      if (json.type === 'assistant' && json.message?.content) {
+        for (const block of json.message.content) {
+          if (block.type === 'text' && block.text) {
+            textChunks.push(block.text);
+          }
+        }
+        if (json.message?.usage) {
+          inputTokens += json.message.usage.input_tokens || 0;
+          outputTokens += json.message.usage.output_tokens || 0;
+        }
+      }
+
+      if (json.type === 'content_block_delta' && json.delta?.type === 'text_delta' && json.delta.text) {
+        textChunks.push(json.delta.text);
+      }
+    } catch {
+      // Not valid JSON, skip
+    }
+  }
+
+  const parts: string[] = [];
+  if (textChunks.length > 0) parts.push(textChunks.join(''));
+  if (resultText) {
+    const combined = parts.join('');
+    if (!combined.endsWith(resultText)) {
+      parts.push(isErrorResult ? '\n\nError: ' + resultText : '\n\n' + resultText);
+    }
+  }
+  if (errorChunks.length > 0) {
+    const errText = errorChunks.join('; ');
+    if (!parts.some(p => p.includes(errText))) {
+      parts.push('\n\nError: ' + errText);
+    }
+  }
+
+  const text = parts.length > 0 ? parts.join('').trim() : rawOutput;
+  return { text, tokensUsed: inputTokens + outputTokens, sessionId };
+}
+
+/**
+ * Parse JSONL output from `codex exec --json`.
+ *
+ * Event types:
+ *   {"type":"thread.started","thread_id":"..."}
+ *   {"type":"turn.started"}
+ *   {"type":"item.completed","item":{"id":"...","type":"agent_message","text":"..."}}
+ *   {"type":"item.completed","item":{"id":"...","type":"reasoning","text":"..."}}
+ *   {"type":"turn.completed","usage":{"input_tokens":N,"cached_input_tokens":N,"output_tokens":N}}
+ */
+export function parseCodexJsonOutput(rawOutput: string): ParsedOutput {
+  const lines = rawOutput.split('\n').filter(l => l.trim());
+  const textChunks: string[] = [];
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let sessionId: string | undefined;
+
+  for (const line of lines) {
+    try {
+      const json = JSON.parse(line);
+
+      if (json.type === 'thread.started' && json.thread_id) {
+        sessionId = json.thread_id;
+      }
+
+      if (json.type === 'item.completed' && json.item) {
+        if (json.item.type === 'agent_message' && json.item.text) {
+          textChunks.push(json.item.text);
+        }
+        // Skip reasoning items — they're internal thought, not output
+      }
+
+      if (json.type === 'turn.completed' && json.usage) {
+        inputTokens += json.usage.input_tokens || 0;
+        outputTokens += json.usage.output_tokens || 0;
+      }
+
+      if (json.type === 'error') {
+        const errText = json.message || json.error || JSON.stringify(json);
+        textChunks.push(`\n\nError: ${errText}`);
+      }
+    } catch {
+      // Not valid JSON, skip
+    }
+  }
+
+  const text = textChunks.join('\n').trim() || rawOutput;
+  return { text, tokensUsed: inputTokens + outputTokens, sessionId };
+}

package/src/council-engine/pipeline/run-output.ts

@@ -0,0 +1,149 @@
+/**
+ * Pipeline Run Output Isolation
+ * Structured per-run/per-stage/per-step output directories.
+ * Runs live at {workingDir}/kondi-runs/{pipelineName}_run_NNN_date_time/
+ */
+
+import type { StepArtifact, StepMeta, RunManifest, OutputType } from './types';
+import type { PlatformAdapter } from './executor';
+
+// ============================================================================
+// Name Sanitization
+// ============================================================================
+
+export function sanitizeFolderName(name: string): string {
+  return name
+    .toLowerCase()
+    .replace(/[^a-z0-9_-]/g, '_')
+    .replace(/_+/g, '_')
+    .replace(/^_|_$/g, '')
+    .slice(0, 40);
+}
+
+// ============================================================================
+// Directory Name Builders
+// ============================================================================
+
+export function buildRunDirName(pipelineName: string, runNumber: number, date: Date): string {
+  const safeName = sanitizeFolderName(pipelineName);
+  const num = String(runNumber).padStart(3, '0');
+  const y = date.getFullYear();
+  const m = String(date.getMonth() + 1).padStart(2, '0');
+  const d = String(date.getDate()).padStart(2, '0');
+  const h = String(date.getHours()).padStart(2, '0');
+  const min = String(date.getMinutes()).padStart(2, '0');
+  return `${safeName}_run_${num}_${y}-${m}-${d}_${h}${min}`;
+}
+
+export function buildStageDirName(stageIndex: number, stageName: string): string {
+  return `stage_${stageIndex + 1}_${sanitizeFolderName(stageName)}`;
+}
+
+export function buildStepDirName(stepIndex: number, stepName: string): string {
+  return `step_${stepIndex + 1}_${sanitizeFolderName(stepName)}`;
+}
+
+export function getRunsBaseDir(workingDir: string): string {
+  return `${workingDir.replace(/\/$/, '')}/kondi-runs`;
+}
+
+export function buildStepOutputDir(
+  runDir: string,
+  stageIndex: number,
+  stageName: string,
+  stepIndex: number,
+  stepName: string
+): string {
+  const stageDir = buildStageDirName(stageIndex, stageName);
+  const stepDir = buildStepDirName(stepIndex, stepName);
+  return `${runDir}/${stageDir}/${stepDir}`;
+}
+
+// ============================================================================
+// File Extension Mapping
+// ============================================================================
+
+export function getOutputExtension(outputType: OutputType): string {
+  switch (outputType) {
+    case 'json': return '.json';
+    default: return '.md';
+  }
+}
+
+// ============================================================================
+// Write Operations
+// ============================================================================
+
+export async function writeStepOutput(
+  platform: PlatformAdapter,
+  stepDir: string,
+  artifact: StepArtifact,
+  meta: StepMeta
+): Promise<string> {
+  const ext = getOutputExtension(meta.outputType);
+  const outputPath = `${stepDir}/output${ext}`;
+
+  await platform.writeFile(outputPath, artifact.content);
+  await platform.writeFile(`${stepDir}/_meta.json`, JSON.stringify(meta, null, 2));
+
+  return outputPath;
+}
+
+export async function writeDeliberationFiles(
+  platform: PlatformAdapter,
+  stepDir: string,
+  deliberationMd: string,
+  decisionMd?: string
+): Promise<void> {
+  await platform.writeFile(`${stepDir}/deliberation.md`, deliberationMd);
+  if (decisionMd) {
+    await platform.writeFile(`${stepDir}/decision.md`, decisionMd);
+  }
+}
+
+export async function writeRunManifest(
+  platform: PlatformAdapter,
+  runDir: string,
+  manifest: RunManifest
+): Promise<void> {
+  await platform.writeFile(
+    `${runDir}/_manifest.json`,
+    JSON.stringify(manifest, null, 2)
+  );
+}
+
+// ============================================================================
+// Run Pruning
+// ============================================================================
+
+export async function pruneOldRuns(
+  platform: PlatformAdapter,
+  runsBaseDir: string,
+  pipelineName: string,
+  maxRetained: number
+): Promise<void> {
+  if (maxRetained <= 0 || !platform.runCommand) return;
+
+  try {
+    const prefix = sanitizeFolderName(pipelineName);
+    const result = await platform.runCommand(
+      `ls -1d ${prefix}_run_* 2>/dev/null | sort`,
+      runsBaseDir
+    );
+
+    if (!result.success || !result.stdout.trim()) return;
+
+    const dirs = result.stdout.trim().split('\n').filter(Boolean);
+    if (dirs.length <= maxRetained) return;
+
+    const toDelete = dirs.slice(0, dirs.length - maxRetained);
+    for (const dir of toDelete) {
+      if (new RegExp(`^${prefix}_run_\\d{3}_`).test(dir)) {
+        await platform.runCommand(`rm -rf "${dir}"`, runsBaseDir);
+        console.log(`[RunOutput] Pruned old run: ${dir}`);
+      }
+    }
+  } catch (err) {
+    console.warn('[RunOutput] Failed to prune old runs:', err);
+  }
+}