junecoder 1.0.0

package/cli.js

@@ -0,0 +1,199 @@
+#!/usr/bin/env node
+/**
+ * junecode CLI entry point — starts the TUI or single-shot execution.
+ *
+ * Usage:
+ *   junecode [directory]               # Start TUI in directory (default: .)
+ *   junecode open [directory]          # Start TUI in directory (default: .)
+ *   junecode -d <dir> [prompt]         # Specify working directory
+ *   junecode "write a hello world"     # Single-shot (non-TUI)
+ *
+ * API keys can be provided via:
+ *   1. .env file in project directory (DEEPSEEK_API_KEY=sk-...)
+ *   2. ~/.junecode/.env
+ *   3. DEEPSEEK_API_KEY environment variable
+ *   4. ~/.junecode/config.json
+ */
+import { existsSync, statSync, readFileSync } from 'node:fs';
+import { resolve, join } from 'node:path';
+import { homedir } from 'node:os';
+import { createAgent } from './agent.mjs';
+import { startTUI } from './tui.mjs';
+import { loadConfig } from './config.mjs';
+import { loadSession } from './session.mjs';
+import { memoryDir } from './memory.mjs';
+
+function expandHome(p) {
+  if (!p) return p;
+  if (p === '~' || p.startsWith('~/') || p.startsWith('~\\')) {
+    return join(homedir(), p.slice(1));
+  }
+  return p;
+}
+
+const rawArgs = process.argv.slice(2);
+
+let targetDir = process.cwd();
+let isTui = true;
+let promptInput = null;
+
+if (rawArgs.length > 0) {
+  const first = rawArgs[0];
+
+  if (first === '-h' || first === '--help' || first === 'help') {
+    console.log(`junecode - AI coding agent
+
+Usage:
+  junecode [directory]               Start TUI in directory (default: .)
+  junecode open [directory]          Start TUI in directory (default: .)
+  junecode --dir <path> [prompt]     Set working directory
+  junecode -p, --prompt <prompt>     Run single-shot prompt (non-TUI)
+  junecode "your prompt here"        Run single-shot prompt (non-TUI)
+
+Options:
+  -d, --dir <path>    Working directory
+  -t, --tui           Force TUI mode
+  -p, --prompt <text> Run single-shot mode with prompt
+  -h, --help          Show help message
+  -v, --version       Show version number
+`);
+    process.exit(0);
+  }
+
+  if (first === '-v' || first === '--version') {
+    try {
+      const pkg = JSON.parse(readFileSync(new URL('./package.json', import.meta.url), 'utf-8'));
+      console.log(`junecode v${pkg.version}`);
+    } catch {
+      console.log('junecode v1.0.0');
+    }
+    process.exit(0);
+  }
+
+  // Check subcommands and flags
+  if (first === 'open' || first === 'ui' || first === 'tui') {
+    isTui = true;
+    if (rawArgs.length > 1 && !rawArgs[1].startsWith('-')) {
+      targetDir = resolve(expandHome(rawArgs[1]));
+    }
+  } else if (first === '-t' || first === '--tui') {
+    isTui = true;
+    if (rawArgs.length > 1 && !rawArgs[1].startsWith('-')) {
+      const candidate = resolve(expandHome(rawArgs[1]));
+      if (existsSync(candidate) && statSync(candidate).isDirectory()) {
+        targetDir = candidate;
+      }
+    }
+  } else if (first === '-d' || first === '--dir' || first === '--cwd') {
+    if (rawArgs.length > 1) {
+      targetDir = resolve(expandHome(rawArgs[1]));
+      const rest = rawArgs.slice(2);
+      if (rest.length > 0) {
+        if (rest[0] === '-t' || rest[0] === '--tui') {
+          isTui = true;
+        } else if (rest[0] === '-p' || rest[0] === '--prompt') {
+          isTui = false;
+          promptInput = rest.slice(1).join(' ');
+        } else {
+          isTui = false;
+          promptInput = rest.join(' ');
+        }
+      } else {
+        isTui = true;
+      }
+    }
+  } else if (first === '-p' || first === '--prompt' || first === '-s' || first === '--single-shot') {
+    isTui = false;
+    promptInput = rawArgs.slice(1).join(' ');
+  } else {
+    // Check if the argument is a directory path or relative directory reference
+    const candidate = resolve(expandHome(first));
+    const isDirRef =
+      first === '.' ||
+      first === './' ||
+      first === '.\\' ||
+      first === '..' ||
+      first === '../' ||
+      first === '..\\' ||
+      first.startsWith('~') ||
+      (existsSync(candidate) && statSync(candidate).isDirectory());
+
+    if (isDirRef) {
+      isTui = true;
+      targetDir = candidate;
+      if (rawArgs.length > 1) {
+        const rest = rawArgs.slice(1);
+        if (rest[0] === '-p' || rest[0] === '--prompt') {
+          isTui = false;
+          promptInput = rest.slice(1).join(' ');
+        } else if (rest[0] === '-t' || rest[0] === '--tui') {
+          isTui = true;
+        } else {
+          isTui = false;
+          promptInput = rest.join(' ');
+        }
+      }
+    } else {
+      // Prompt text passed directly
+      isTui = false;
+      promptInput = rawArgs.join(' ');
+    }
+  }
+}
+
+// Change process working directory if targetDir is specified
+if (existsSync(targetDir) && statSync(targetDir).isDirectory()) {
+  process.chdir(targetDir);
+} else {
+  console.error(`Error: Working directory "${targetDir}" does not exist.`);
+  process.exit(1);
+}
+
+// Load config and API key
+const config = loadConfig();
+const apiKey = config.provider.apiKey || process.env.DEEPSEEK_API_KEY;
+
+if (!apiKey) {
+  console.error('Error: No API key found. Set DEEPSEEK_API_KEY in .env or in ~/.junecode/config.json.');
+  process.exit(1);
+}
+
+config.provider.apiKey = apiKey;
+
+// Create Agent instance with target cwd
+const agent = createAgent({
+  provider: config.provider,
+  config,
+  cwd: process.cwd(),
+  memory: { dir: memoryDir() },
+});
+
+if (!isTui) {
+  // Single-shot mode
+  if (!promptInput) {
+    console.error('Error: No prompt provided for single-shot execution.');
+    process.exit(1);
+  }
+
+  const { runAgent } = await import('./agent.mjs');
+  try {
+    const result = await runAgent(agent, promptInput, {
+      onToken: (t) => process.stdout.write(t),
+      onToolCall: (name) => process.stdout.write(`\n[tool: ${name}] `),
+    });
+    console.log('');
+  } catch (err) {
+    console.error('Error:', err.message);
+    process.exit(1);
+  }
+  process.exit(0);
+}
+
+// TUI mode
+if (!process.stdin.isTTY || !process.stdout.isTTY) {
+  console.error('Error: Terminal UI requires an interactive TTY.');
+  process.exit(1);
+}
+
+const restored = loadSession(agent.cwd);
+startTUI(agent, { projectDir: agent.cwd, restored });

package/config.mjs

@@ -0,0 +1,118 @@
+/**
+ * Configuration module — provides configDir path and default config factory.
+ *
+ * The config object is passed into createAgent() externally; this module
+ * provides the directory for config files and default values.
+ */
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { existsSync, readFileSync } from 'node:fs';
+
+// Load .env files before any code reads process.env.
+// Must happen here (not cli.mjs) because ESM static imports are hoisted —
+// this module's body runs before cli.mjs's body.
+for (const envPath of ['.env', join(homedir(), '.junecode', '.env')]) {
+  try {
+    if (existsSync(envPath)) {
+      const content = readFileSync(envPath, 'utf-8');
+      for (const line of content.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#')) continue;
+        const eq = trimmed.indexOf('=');
+        if (eq === -1) continue;
+        const key = trimmed.slice(0, eq).trim();
+        let val = trimmed.slice(eq + 1).trim();
+        if ((val.startsWith('"') && val.endsWith('"')) ||
+            (val.startsWith("'") && val.endsWith("'"))) {
+          val = val.slice(1, -1);
+        }
+        if (!process.env[key]) process.env[key] = val;
+      }
+    }
+  } catch { /* ignore missing/unreadable .env */ }
+}
+
+/** Default config directory: ~/.junecode */
+export const configDir = join(homedir(), '.junecode');
+
+/** Default configuration object. Callers can spread/override with user settings. */
+export function defaultConfig() {
+  return {
+    agent: {
+      maxTurns: 50,
+      subagentTurns: 20,
+      goalTurns: 30,
+      contextWindow: 1_000_000, // assumed model context window (estimated tokens)
+      compactThreshold: 750_000, // compress at 75% of contextWindow
+    },
+    provider: {
+      type: 'deepseek',
+      apiKey: process.env.DEEPSEEK_API_KEY || '',
+      model: 'deepseek-v4-pro',
+      baseURL: 'https://api.deepseek.com',
+      thinking: { type: 'enabled' },
+    },
+  };
+}
+
+/**
+ * Load user config from configDir/config.json.
+ * Returns merged config: defaults overridden by user settings.
+ */
+export function loadConfig(dir = configDir) {
+  const defaults = defaultConfig();
+  const configPath = join(dir, 'config.json');
+
+  if (!existsSync(configPath)) return defaults;
+
+  try {
+    const raw = readFileSync(configPath, 'utf-8');
+    const user = JSON.parse(raw);
+    return deepMerge(defaults, user);
+  } catch {
+    return defaults;
+  }
+}
+
+// ─── TUI support exports ──────────────────────────────────────────────────────
+
+/** Provider preset definitions for the TUI provider selector. */
+export const PROVIDER_PRESETS = {};
+
+/**
+ * Get the thinking API spec for a given model.
+ * @param {string} model
+ * @returns {{ thinkApi: string }}
+ */
+export function specForModel(model) {
+  return { thinkApi: 'default' };
+}
+
+/**
+ * Resolve the context compaction threshold for a provider/model pair.
+ * @param {string} provider
+ * @param {string} model
+ * @returns {{ value: number }}
+ */
+export function resolveCompactThreshold(provider, model) {
+  return { value: 100_000 };
+}
+
+/** Shallow-ish deep merge: only merges top-level objects. */
+function deepMerge(base, override) {
+  const result = { ...base };
+  for (const key of Object.keys(override)) {
+    if (
+      typeof base[key] === 'object' &&
+      base[key] !== null &&
+      !Array.isArray(base[key]) &&
+      typeof override[key] === 'object' &&
+      override[key] !== null
+    ) {
+      result[key] = { ...base[key], ...override[key] };
+    } else {
+      result[key] = override[key];
+    }
+  }
+  return result;
+}

package/context.mjs

@@ -0,0 +1,160 @@
+/**
+ * Context compression module.
+ *
+ * Handles history truncation when the conversation grows too long.
+ * Two strategies:
+ *   1. compressIfNeeded — LLM-based summarization (stub for now)
+ *   2. compressFallback — deterministic truncation when LLM summarization fails
+ */
+import { AUTO_REMINDER } from './agent.mjs';
+
+/** How many consecutive compression failures before triggering fallback. */
+export const COMPRESS_FAILURE_LIMIT = 3;
+
+/** Rough token estimate: ~4 characters per token for English text. */
+const CHARS_PER_TOKEN = 4;
+
+// ─── Token estimation ─────────────────────────────────────────────────────────
+
+/**
+ * Estimate token count from a message array.
+ * Uses char/4 heuristic — fast, deterministic, good enough for threshold checks.
+ */
+export function estimateTokens(messages) {
+  if (!messages || messages.length === 0) return 0;
+  let chars = 0;
+  for (const msg of messages) {
+    if (!msg) continue;
+    chars += String(msg.content || '').length;
+    if (msg.tool_calls) chars += JSON.stringify(msg.tool_calls).length;
+    if (msg.tool_call_id) chars += String(msg.tool_call_id).length;
+    if (msg.name) chars += String(msg.name).length;
+    if (msg.reasoning_content) chars += String(msg.reasoning_content).length;
+  }
+  return Math.ceil(chars / CHARS_PER_TOKEN);
+}
+
+// ─── LLM-based compression (stub) ─────────────────────────────────────────────
+
+/**
+ * Check if compression is needed and attempt LLM summarization.
+ * Currently stubbed: returns false to let the caller track failure count.
+ *
+ * When the stub is removed:
+ *   1. If estimated tokens < threshold, return false (no action needed).
+ *   2. Call LLM to generate a summary of the conversation so far.
+ *   3. Replace history with: system prompt + summary message + recent messages.
+ *
+ * @param {object} agent
+ * @param {number} threshold - token threshold to trigger compression
+ * @returns {Promise<boolean>} true if compression was performed, false if skipped/failed
+ */
+export async function compressIfNeeded(agent, threshold) {
+  const tokens = estimateTokens(agent.history);
+  if (tokens < threshold) return false;
+
+  // Stub: not implementing LLM summarization yet.
+  // Returns false so the caller increments _compressFailures and
+  // eventually triggers compressFallback.
+  return false;
+}
+
+// ─── Deterministic fallback truncation ────────────────────────────────────────
+
+/**
+ * Deterministic fallback: truncate old messages, keep system + recent context.
+ *
+ * Strategy:
+ *   1. System messages stay at the top, unmodified.
+ *   2. Keep the last `keepRecent` messages from history.
+ *   3. Drop everything else.
+ *   4. Insert a truncation note between system messages and kept messages.
+ *   5. Reset failure counter on success.
+ *
+ * @param {object} agent
+ * @param {number} [keepRecent=10] - number of recent non-system messages to keep
+ */
+export function compressFallback(agent, keepRecent = 10) {
+  const history = agent.history;
+  if (!history || history.length === 0) return;
+
+  // Separate system messages from the rest
+  const systemMsgs = [];
+  const otherMsgs = [];
+  for (const msg of history) {
+    if (msg && msg.role === 'system') {
+      systemMsgs.push(msg);
+    } else {
+      otherMsgs.push(msg);
+    }
+  }
+
+  // If the rest is already short enough, nothing to do
+  if (otherMsgs.length <= keepRecent) {
+    agent._compressFailures = 0;
+    return;
+  }
+
+  // Keep only the last keepRecent non-system messages
+  let kept = otherMsgs.slice(-keepRecent);
+  // Never start mid-tool-batch: leading "tool" messages whose assistant
+  // (tool_calls) parent was cut away are rejected by providers (400).
+  while (kept.length > 0 && kept[0].role === 'tool') kept = kept.slice(1);
+  const dropped = otherMsgs.length - kept.length;
+
+  // Build truncation note
+  const summaryLine = `[Context compressed: ${dropped} earlier messages were truncated. ` +
+    `The conversation continues from here. Please continue based on recent context.]`;
+
+  // Rebuild history: system + truncation note + kept recent messages
+  agent.history = [
+    ...systemMsgs,
+    { role: 'user', content: summaryLine, _transient: true },
+    ...kept,
+  ];
+
+  // Log a reminder about the compression
+  agent._pendingReminders = agent._pendingReminders || [];
+  agent._pendingReminders.push(AUTO_REMINDER);
+
+  // Reset failure counter
+  agent._compressFailures = 0;
+}
+
+// ─── Convenience: check + fallback ────────────────────────────────────────────
+
+/**
+ * Full compression check: try LLM summarization, fall back to truncation.
+ * Called once per turn from the main loop.
+ *
+ * @param {object} agent
+ * @param {number} threshold - token threshold
+ * @returns {Promise<boolean>} true if any compression action was taken
+ */
+export async function checkAndCompress(agent, threshold) {
+  // Don't compress if threshold is 0 (disabled)
+  if (!threshold || threshold <= 0) return false;
+
+  // Under threshold: nothing to do. This is NOT a compression failure —
+  // reset the counter so the fallback only fires after real over-threshold
+  // failures, not every COMPRESS_FAILURE_LIMIT turns.
+  if (estimateTokens(agent.history) < threshold) {
+    agent._compressFailures = 0;
+    return false;
+  }
+
+  // Try LLM-based compression
+  const compressed = await compressIfNeeded(agent, threshold);
+  if (compressed) return true;
+
+  // LLM compression didn't happen — track failures
+  agent._compressFailures = (agent._compressFailures || 0) + 1;
+
+  // If we've failed too many times, fall back to deterministic truncation
+  if (agent._compressFailures >= COMPRESS_FAILURE_LIMIT) {
+    compressFallback(agent);
+    return true;
+  }
+
+  return false;
+}

package/distill.mjs

@@ -0,0 +1,178 @@
+/**
+ * Knowledge distillation — extract reusable knowledge from conversations.
+ *
+ * Extracts candidate knowledge items (facts, patterns, decisions) from
+ * conversation transcripts for long-term memory.
+ *
+ * Extraction uses heuristics (keyword matching) by default. When a provider
+ * is available, extractCandidates can optionally use LLM-based extraction.
+ */
+
+import { createHash } from 'node:crypto';
+
+// ─── Candidate extraction heuristics ───────────────────────────────────────────
+
+/** Indicator words that suggest a line contains reusable knowledge. */
+const INDICATORS = [
+  // Decisions
+  /^(?:we|i|let'?s?)\s+(?:decided?|chose|went with|opted)\b/i,
+  /\b(?:decision|choice|prefer|policy)\s*(?::|is|was)\b/i,
+  // Conventions
+  /\b(?:convention|standard|rule|guideline|idiom|best practice)\s*(?::|is|was)\b/i,
+  /\b(?:always|never|should|must not|don't|do not)\s+\w+\s+(?:use|do|call|import|require|write)\b/i,
+  // Patterns
+  /\b(?:pattern|approach|strategy|workflow|recipe)\s*(?::|is|was|for)\b/i,
+  /\b(?:the pattern is|we follow|common pattern)\b/i,
+  // Facts
+  /\b(?:note|important|remember|key|tldr)\s*:/i,
+  /\b(?:this project uses|we use|configured to)\b/i,
+  /\b(?:because|since|due to|as a result)\b.*\b(?:so|therefore|thus|hence)\b/i,
+];
+
+/** Minimum length for extracted content snippet. */
+const MIN_LENGTH = 20;
+
+/** Categorize a candidate snippet based on its language. */
+function categorize(text) {
+  const t = text.toLowerCase();
+  if (/\b(?:decided?|chose|decision|choice)\b/.test(t)) return 'decision';
+  if (/\b(?:convention|standard|rule|must|should|always|never|guideline)\b/.test(t)) return 'rule';
+  if (/\b(?:pattern|approach|workflow|recipe|strategy)\b/.test(t)) return 'pattern';
+  return 'knowledge';
+}
+
+/** Extract a short title from a snippet. */
+function extractTitle(text) {
+  // First sentence, truncated
+  const cleaned = text.replace(/^[\s*\-–—:]+/, '').trim();
+  const sentence = cleaned.split(/[.!?]\s/)[0].trim();
+  if (sentence.length <= 80) return sentence;
+  return sentence.slice(0, 77) + '...';
+}
+
+// ─── Public API ────────────────────────────────────────────────────────────────
+
+/**
+ * Extract candidate knowledge items from a transcript.
+ * Uses heuristic pattern matching. When provider is available and enabled,
+ * can use LLM-based extraction for higher quality.
+ *
+ * @param {object|null} provider - LLM provider (optional, for LLM-based extraction)
+ * @param {string} transcript - conversation transcript
+ * @param {{ useLLM?: boolean }} [opts]
+ * @returns {Promise<object[]>} array of { type, title, content, tags }
+ */
+export async function extractCandidates(provider, transcript, opts = {}) {
+  if (!transcript) return [];
+
+  const lines = transcript.split('\n');
+  const candidates = [];
+  const seen = new Set();
+
+  // Process each line
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (!line || line.length < MIN_LENGTH) continue;
+
+    // Check against indicator patterns
+    let matched = false;
+    for (const re of INDICATORS) {
+      if (re.test(line)) {
+        matched = true;
+        break;
+      }
+    }
+
+    if (!matched) continue;
+
+    // Collect context: this line +- 1 surrounding lines
+    const start = Math.max(0, i - 1);
+    const end = Math.min(lines.length, i + 2);
+    const snippet = lines.slice(start, end).join(' ').trim();
+
+    // Deduplicate by content hash
+    const hash = createHash('sha256').update(snippet).digest('hex').slice(0, 12);
+    if (seen.has(hash)) continue;
+    seen.add(hash);
+
+    const type = categorize(snippet);
+    const title = extractTitle(snippet);
+
+    candidates.push({
+      type,
+      title,
+      content: snippet,
+      tags: [type],
+    });
+  }
+
+  return candidates;
+}
+
+/**
+ * Convert agent history array to a plain-text transcript.
+ * @param {object[]} history - array of { role, content, tool_calls? } messages
+ * @returns {string}
+ */
+export function historyToTranscript(history) {
+  if (!history || history.length === 0) return '';
+
+  return history
+    .filter((m) => m && m.role)
+    .map((m) => {
+      let body = '';
+      if (m.content) body = m.content;
+      if (m.tool_calls) {
+        const names = m.tool_calls.map((tc) => tc.function?.name || '?').join(', ');
+        body = body ? `${body} [tool_calls: ${names}]` : `[tool_calls: ${names}]`;
+      }
+      // For tool results, show preview
+      if (m.role === 'tool' && m.tool_call_id) {
+        const preview = (m.content || '').slice(0, 200);
+        return `[tool result: ${m.name || m.tool_call_id}]: ${preview}`;
+      }
+      return `[${m.role}]: ${body}`;
+    })
+    .join('\n\n');
+}
+
+/**
+ * Save a candidate knowledge item to memory.
+ * Converts candidate to a memory entry and persists it.
+ *
+ * @param {object} memory - memory instance
+ * @param {object} candidate - { type, title, content, tags }
+ * @param {{ autoApprove?: boolean }} [opts]
+ * @returns {Promise<string>} status message
+ */
+export async function saveCandidate(memory, candidate, opts = {}) {
+  if (!memory) return 'no memory store available';
+
+  const id = createHash('sha256')
+    .update(candidate.content || candidate.title || '')
+    .digest('hex')
+    .slice(0, 16);
+
+  const entry = {
+    id,
+    content: `[${candidate.type || 'knowledge'}] ${candidate.title}: ${candidate.content}`,
+    source: 'distill',
+    tags: [...(candidate.tags || []), candidate.type || 'knowledge', 'distilled'],
+    timestamp: Date.now(),
+  };
+
+  const { join } = await import('node:path');
+  const { mkdirSync, writeFileSync } = await import('node:fs');
+  const { homedir } = await import('node:os');
+
+  const dir = memory.dir || join(homedir(), '.junecode', 'memory');
+  try { mkdirSync(dir, { recursive: true }); } catch { /* dir exists */ }
+
+  writeFileSync(join(dir, entry.id + '.json'), JSON.stringify(entry, null, 2), 'utf-8');
+
+  if (memory.entries) {
+    memory.entries.push(entry);
+  }
+
+  return `saved: ${candidate.title || candidate.type || 'knowledge'}`;
+}