mixdog 0.7.17 → 0.8.0

package/src/output-styles/default.md

@@ -0,0 +1,38 @@
+---
+name: default
+description: Default concise engineering replies
+keep-coding-instructions: true
+---
+
+# Output Style
+
+Default concise engineering replies. Technical substance stays; fluff dies.
+Uniformity beats local cleverness.
+
+- Answer first. No pleasantries, hedging, task restatement, or tool narration.
+- One answer only. Do not repeat the conclusion in a second paragraph or trailing
+  sentence.
+- Tool work: one short intent line, then batch silently. For long chains, one
+  checkpoint only: learned + next.
+- Default final: one sentence. If crowded, max 2 flat bullets. Code-change final:
+  max 3 flat bullets, but prefer one sentence with semicolons. Omit empty fields.
+- Hard cap user-visible replies at 2 short sentences unless the user asks for
+  detail. If a previous reply was too long, answer with one short sentence.
+- Keep the same shape for the same task type: explanation = one sentence;
+  implementation = changed + verified in one sentence; diagnosis = cause +
+  evidence + fix in one sentence.
+- No report headings/labels, nested bullets, tables, numbered lists, tool traces,
+  searched-path lists, agent/model/session metadata, timings, or token counts
+  unless user asks or it is decisive evidence.
+- Do not use label prefixes such as `Changed:`, `Verified:`, `변경:`, `검증:`,
+  `원인:`, or `결론:`. Use plain clauses instead.
+- Bridge/agent results: synthesize outcome; never forward full report.
+- Explore/retrieval results are evidence only; do not paste their bullets or file
+  lists into the answer unless the user explicitly asked for candidates/details.
+- Keep paths, commands, symbols, API names, code, and exact errors verbatim.
+  Localize prose only.
+- Quote only the shortest decisive error. No raw logs or long file lists unless
+  asked.
+- Relax compression for security, destructive actions, ambiguity, or user
+  confusion.
+- Never name this style unless asked.

package/src/output-styles/extreme-simple.md

@@ -0,0 +1,17 @@
+---
+name: extreme-simple
+title: Extreme Simple
+description: Ultra-short completion sentence
+aliases: extreme, extreme simple
+keep-coding-instructions: true
+---
+
+# Output Style
+
+Extreme simple completion replies.
+
+- Reply with one ultra-short completion sentence whenever possible.
+- Preferred completion pattern: `<target> 변경되었습니다. <verification> 통과 완료입니다.`
+- If verification was not run, use one short sentence that says the change is done and verification was not run.
+- Avoid headings, bullets, labels, explanations, tool traces, and metadata unless the user explicitly asks.
+- Preserve exact paths, commands, symbols, API names, code, and errors when they are the only decisive detail.

package/src/output-styles/simple.md

@@ -0,0 +1,17 @@
+---
+name: simple
+title: Simple
+description: 1-2 concise sentences
+keep-coding-instructions: true
+---
+
+# Output Style
+
+Simple concise replies.
+
+- Answer in 1-2 concise sentences by default.
+- Keep technical substance, paths, commands, symbols, API names, code, and exact errors verbatim.
+- Use bullets only when a sentence would become crowded.
+- Avoid headings, labels, nested bullets, tool traces, and metadata unless the user asks.
+- For code changes, say what changed and the decisive verification in one short sentence when possible.
+- If verification was not run, say so briefly.

package/src/repl.mjs

@@ -0,0 +1,322 @@
+/**
+ * mixdog REPL — styled inline terminal loop over the ported mixdog brain.
+ *
+ * Drives the *ported mixdog brain* through mixdog-session-runtime.mjs:
+ * createSession + askSession own agentLoop/provider/tools/compaction, while
+ * this module stays presentation-only: markdown-rendered replies, tool-call
+ * cards, a per-turn statusline footer, slash commands, and arrow-key history.
+ *
+ * Flow:  stdin line → runtime.ask(prompt) → onTextDelta streams tokens to
+ *        stdout live → tool calls render as cards → on turn end we re-render
+ *        the assistant text as markdown → statusline footer.
+ *
+ * STREAMING DECISION (approach (a) from the brief):
+ *   Live token streaming via onTextDelta conflicts with post-hoc markdown
+ *   rendering (you can't style a heading until you've seen the whole line).
+ *   We choose: stream raw tokens live so the turn FEELS alive, then on turn
+ *   end clear the streamed raw block and re-print the markdown-rendered text.
+ *   Rationale: the alternative (buffer silently, render once) loses all live
+ *   feedback on slow turns, which is the worse UX. The re-render is cheap and
+ *   only runs when stdout is a TTY (so piped/non-TTY output stays clean and is
+ *   never clobbered by cursor-movement escapes).
+ */
+import { createInterface } from 'node:readline';
+import { stdin, stdout } from 'node:process';
+import { basename } from 'node:path';
+
+import { bold, dim, cyan, green, red, yellow, colorEnabled } from './ui/ansi.mjs';
+import { renderMarkdown } from './ui/markdown.mjs';
+import { renderToolCard } from './ui/tool-card.mjs';
+import { createSessionStats, applyUsageDelta, renderStatusline } from './ui/statusline.mjs';
+import { createMixdogSessionRuntime } from './mixdog-session-runtime.mjs';
+import { installProcessSignalCleanup } from './runtime/shared/process-shutdown.mjs';
+
+/** Help text shared by `--help` and the `/help` slash command. */
+const HELP_LINES = [
+  'mixdog — standalone mixdog CLI/TUI coding agent.',
+  '',
+  'Usage:',
+  '  mixdog [--provider <name>] [--model <name>] [--readonly]',
+  '  mixdog --help',
+  '',
+  'Slash commands (inside the REPL):',
+  '  /help              show this help',
+  '  /clear             reset the conversation and clear the screen',
+  '  /compact           compact older conversation context',
+  '  /model <name>      switch model/preset for subsequent turns',
+  '  /OutputStyle [name] show or switch Lead output style',
+  '  /mode <name>       switch tool surface: full | readonly',
+  '  /exit              quit',
+  '',
+  'History: use ↑ / ↓ to recall previous inputs.',
+];
+
+/** Print the `--help` text. Routed here so app.mjs stays untouched. */
+export function printHelp(write = (s) => stdout.write(s)) {
+  write(HELP_LINES.join('\n') + '\n');
+}
+
+export async function runRepl({ provider: providerName, model, toolMode = 'full' } = {}) {
+  // `--help` short-circuits before any provider init so the smoke test (which
+  // invokes `src/cli.mjs --help`) gets clean help output and a 0 exit. We read
+  // argv here rather than editing app.mjs, keeping changes confined to the REPL.
+  if (process.argv.slice(2).some((a) => a === '--help' || a === '-h')) {
+    printHelp();
+    return 0;
+  }
+
+  const runtime = await createMixdogSessionRuntime({ provider: providerName, model, toolMode });
+  const stats = createSessionStats();
+  const cwd = process.cwd();
+  let rl = null;
+  let closed = false;
+  const closeRuntime = async (reason = 'cli-exit') => {
+    if (closed) return;
+    closed = true;
+    try { rl?.close(); } catch {}
+    await runtime.close(reason);
+  };
+
+  printBanner(runtime.provider, runtime.model, cwd, runtime.toolMode);
+
+  rl = createInterface({
+    input: stdin,
+    output: stdout,
+    prompt: promptText(),
+    // historySize > 0 enables readline's built-in ↑/↓ recall of prior inputs.
+    historySize: 200,
+  });
+  const signalCleanup = installProcessSignalCleanup({
+    name: 'mixdog-repl',
+    timeoutMs: 6500,
+    beforeCleanup: () => { try { stdout.write('\n'); } catch {} },
+    cleanup: closeRuntime,
+  });
+  rl.on('SIGINT', () => {
+    void signalCleanup.run('SIGINT', { code: 130, shouldExit: true });
+  });
+
+  try {
+    rl.prompt();
+
+    for await (const rawLine of rl) {
+      const line = rawLine.trim();
+      if (!line) {
+        rl.prompt();
+        continue;
+      }
+
+      // --- Slash commands ---------------------------------------------------
+      if (line.startsWith('/')) {
+        const handled = await handleSlash(line, {
+          rl,
+          runtime,
+          stats,
+          cwd,
+          closeRuntime,
+        });
+        if (handled === 'exit') {
+          return 0;
+        }
+        rl.setPrompt(promptText());
+        rl.prompt();
+        continue;
+      }
+
+      stdout.write('\n');
+
+      let streamedText = '';
+      let printedAny = false;
+      try {
+        const { result } = await runtime.ask(
+          line,
+          {
+            onToolCall: async (_iter, calls) => {
+            for (const c of calls || []) stdout.write('\n' + renderToolCard(c) + '\n');
+          },
+            onTextDelta: (chunk) => {
+              printedAny = true;
+              streamedText += chunk;
+              stdout.write(chunk);
+            },
+            onUsageDelta: (delta) => applyUsageDelta(stats, delta),
+          },
+        );
+
+        const finalText = (result?.content != null && String(result.content)) || streamedText;
+
+        // Approach (a): clear the raw streamed block and re-print as markdown.
+        // Only when we're on a TTY and actually streamed something — otherwise the
+        // raw text already on screen is fine (and we must not emit cursor escapes
+        // into a pipe).
+        if (finalText) {
+          if (printedAny && colorEnabled()) {
+            eraseStreamedBlock(streamedText);
+            stdout.write(renderMarkdown(finalText) + '\n');
+          } else if (!printedAny) {
+            // Nothing streamed live (provider without onTextDelta) — render once.
+            stdout.write(renderMarkdown(finalText) + '\n');
+          } else {
+            // Non-TTY / NO_COLOR: leave the raw stream, just terminate the line.
+            stdout.write('\n');
+          }
+        }
+
+        // Per-turn statusline footer.
+        stdout.write('\n' + (await renderStatusline({
+          provider: runtime.provider,
+          model: runtime.model,
+          cwd,
+          stats,
+          contextWindow: runtime.contextWindow,
+          rawContextWindow: runtime.rawContextWindow,
+        })) + '\n');
+      } catch (error) {
+        stdout.write('\n' + red(`[error] ${error?.message || error}`) + '\n');
+      }
+
+      stdout.write('\n');
+      rl.setPrompt(promptText());
+      rl.prompt();
+    }
+  } finally {
+    signalCleanup.uninstall();
+    await closeRuntime('cli-eof');
+  }
+
+  return 0;
+}
+
+// --- UI bits -----------------------------------------------------------------
+
+function promptText() {
+  return colorEnabled() ? cyan(bold('› ')) : '› ';
+}
+
+function printBanner(providerName, model, cwd, toolMode) {
+  const title = bold('mixdog');
+  const id = cyan(`${providerName}/${model}`);
+  stdout.write(`${title} ${dim('—')} ${id} ${dim('·')} ${dim(toolMode)} ${dim('·')} ${dim(basename(cwd))}\n`);
+  stdout.write(dim('Type a message, or /help for commands. Ctrl+C to exit.') + '\n\n');
+}
+
+/**
+ * Erase the raw streamed assistant block so we can re-print it as markdown.
+ * Computes how many terminal rows the streamed text + tool-card lines consumed.
+ * Conservative: if the math is off we still leave a readable transcript.
+ */
+function eraseStreamedBlock(streamedText) {
+  const cols = (stdout.columns && stdout.columns > 0) ? stdout.columns : 80;
+  let rows = 0;
+  for (const seg of String(streamedText).split('\n')) {
+    rows += Math.max(1, Math.ceil((seg.length || 1) / cols));
+  }
+  // Move to column 0, then for each consumed row move up and clear it.
+  stdout.write('\r');
+  for (let i = 0; i < rows; i++) {
+    stdout.write('\x1b[2K'); // clear current line
+    if (i < rows - 1) stdout.write('\x1b[1A'); // cursor up
+  }
+  stdout.write('\r');
+}
+
+// --- Slash commands ----------------------------------------------------------
+
+/**
+ * Handle a `/command` line. Returns 'exit' to quit, otherwise undefined.
+ */
+async function handleSlash(line, ctx) {
+  const [rawCmd, ...rest] = line.slice(1).split(/\s+/);
+  const cmd = String(rawCmd || '').toLowerCase();
+  const arg = rest.join(' ').trim();
+
+  switch (cmd) {
+    case 'help':
+      printHelp();
+      return;
+
+    case 'clear':
+      await ctx.runtime.clear();
+      {
+        const fresh = createSessionStats();
+        for (const k of Object.keys(fresh)) ctx.stats[k] = fresh[k];
+      }
+      // Clear screen + scrollback and home the cursor.
+      stdout.write(colorEnabled() ? '\x1b[2J\x1b[3J\x1b[H' : '\n');
+      stdout.write(dim('conversation reset.') + '\n');
+      stdout.write((await renderStatusline({
+        provider: ctx.runtime.provider,
+        model: ctx.runtime.model,
+        cwd: ctx.cwd,
+        stats: ctx.stats,
+        contextWindow: ctx.runtime.contextWindow,
+        rawContextWindow: ctx.runtime.rawContextWindow,
+      })) + '\n');
+      return;
+
+    case 'compact':
+      {
+        const r = await ctx.runtime.compact();
+        if (!r) {
+          stdout.write(yellow('compact failed') + '\n');
+          return;
+        }
+        if (r.changed === false && r.reason) {
+          stdout.write(yellow(r.reason) + '\n');
+          return;
+        }
+        stdout.write(green(`✓ compacted context: ${r.beforeMessages}→${r.afterMessages} messages, context ${r.beforeTokens}→${r.afterTokens}`) + '\n');
+      }
+      return;
+
+    case 'model':
+      if (!arg) {
+        stdout.write(yellow(`current model: ${ctx.runtime.provider}/${ctx.runtime.model}`) + '\n');
+        stdout.write(dim('usage: /model <preset-or-model>') + '\n');
+        return;
+      }
+      await ctx.runtime.setRoute({ model: arg });
+      stdout.write(green(`✓ model → ${ctx.runtime.provider}/${ctx.runtime.model}`) + '\n');
+      return;
+
+    case 'outputstyle':
+    case 'output-style':
+    case 'style':
+      {
+        const lower = arg.toLowerCase();
+        if (!arg || lower === 'status' || lower === 'current' || lower === 'show') {
+          const status = ctx.runtime.getOutputStyle?.() || ctx.runtime.listOutputStyles?.();
+          const label = status?.current?.label || status?.current?.id || status?.configured || 'Default';
+          const available = (status?.styles || []).map((style) => style.label || style.id).join(', ');
+          stdout.write(yellow(`current output style: ${label}`) + '\n');
+          if (available) stdout.write(dim(`available: ${available}`) + '\n');
+          return;
+        }
+        const result = await ctx.runtime.setOutputStyle(arg);
+        const label = result?.current?.label || result?.current?.id || arg;
+        const suffix = result?.appliedToCurrentSession === false ? ' (use /clear to apply to this chat)' : '';
+        stdout.write(green(`✓ output style → ${label}${suffix}`) + '\n');
+      }
+      return;
+
+    case 'mode':
+      if (!arg) {
+        stdout.write(yellow(`current mode: ${ctx.runtime.toolMode}`) + '\n');
+        stdout.write(dim('usage: /mode full|readonly') + '\n');
+        return;
+      }
+      await ctx.runtime.setToolMode(arg);
+      stdout.write(green(`✓ mode → ${ctx.runtime.toolMode}`) + '\n');
+      return;
+
+    case 'exit':
+    case 'quit':
+      await ctx.closeRuntime?.('cli-exit');
+      stdout.write(dim('bye.') + '\n');
+      return 'exit';
+
+    default:
+      stdout.write(red(`unknown command: /${cmd}`) + dim('  (try /help)') + '\n');
+      return;
+  }
+}

package/src/rules/bridge/00-common.md

@@ -0,0 +1,5 @@
+# Bridge Constraints
+
+- Use English for bridge-agent communication.
+- Do not touch git/Ship. Even when the brief instructs `git add` / `commit` /
+  `push` / `stash`, refuse with `git operations deferred to Lead`.

package/src/rules/bridge/20-skip-protocol.md

@@ -0,0 +1,11 @@
+# Skip Protocol
+
+For inbound-event bridge reports (`webhook-handler`, `scheduler-task`):
+if Lead has nothing actionable to relay
+(label-only, duplicate/dedup, no action needed, nothing to report),
+prefix the whole response with:
+
+```
+[meta:silent]
+```
+

package/src/rules/bridge/30-explorer.md

@@ -0,0 +1,4 @@
+# Role: explorer
+
+Explore locates relevant code surfaces and quickly summarizes what is there
+with coordinates. Stay rough and descriptive: do not debug, decide, or judge.

package/src/rules/bridge/40-cycle1-agent.md

@@ -0,0 +1,28 @@
+# Role: cycle1-agent
+
+Turn numbered chat rows into memory chunks.
+
+Output only pipe-separated lines, starting with a digit:
+
+`<idx_csv>|<element>|<category>|<summary>`
+
+- `idx_csv`: input row numbers included in this chunk, comma-separated, no `@`.
+- `element`: short recall key, about 5-10 words.
+- `category`: exactly one of `rule`, `constraint`, `decision`, `fact`,
+  `goal`, `preference`, `task`, `issue`.
+  Meanings: rule=standing policy, constraint=hard limit, decision=agreed
+  choice, fact=verified truth, goal=open target, preference=style/taste,
+  task=pending work, issue=broken state.
+- `summary`: 1-3 complete sentences. Keep important names, paths, ids,
+  versions, numbers, errors, causes, and outcomes verbatim. Match the input
+  language.
+
+Coverage rules:
+
+- Every input row must appear exactly once.
+- Group nearby rows about the same topic; split only on real topic changes.
+- Keep clarifications with the topic they clarify.
+- Do not mix different `[sess:XXX]` markers in one chunk.
+- Replace literal `|` with `/`; do not put newlines inside fields.
+
+Do not output JSON, fences, prose, preamble, or tool calls.

package/src/rules/bridge/41-cycle2-agent.md

@@ -0,0 +1,59 @@
+# Role: cycle2-agent
+
+Backend re-scorer for `is_root` long-term memory. Input has phase,
+core memory, and candidates (`id`/`category`/`score`/`element`/
+`summary`). Output pipe-separated lines starting with a digit. No JSON,
+fences, prose, or preamble.
+
+## Long-Term Essential
+
+Promote only entries that clearly fit exactly one concept:
+1. Identity: stable non-derivable user facts.
+2. Preference: durable taste/style/interaction preference.
+3. Goal: long-running committed goal.
+4. Principle: cross-session behavior directive.
+5. Policy: standing team decision.
+6. Procedure: recurring trigger + steps + caveats.
+7. Event: rare foundational change not reconstructible from its rule.
+8. System constant: durable path/schema/model/channel invariant needed
+   later and not already in rules.
+
+Anything unclear or outside these concepts -> `archived`. Promotion is
+exceptional.
+
+## Phase Verbs
+
+- `phase1_new_chunks`: `active` if clearly essential, else `archived`.
+- `phase2_reevaluate`: `active` to promote, else `archived`.
+- `phase3_active_review`: verdict mandatory for every row:
+  `archived` default, or `active`, `update`, `merge`. Silence is not
+  keep.
+
+## Rejects
+
+Archive work narratives, static facts without behavior/user value,
+rule-system meta, resolved bug/fix logs, duplicates of rule files,
+single-run measurements/counts/versions, and session-scoped or
+in-progress decisions.
+
+## Output
+
+```
+<id>|<verb>
+<id>|update|<element>|<summary>
+<id>|merge|<target_id>|<source_ids_csv>|<element>|<summary>
+```
+
+## Field Rules
+
+- Use only input IDs; never invent IDs.
+- `update`: write a fresh `element` and a 3-sentence `summary`.
+- `merge`: keep `target_id`, absorb `source_ids_csv`, and merge only rows
+  from the same `project_id`.
+- `summary`: complete sentences, input language, important specifics verbatim,
+  no actor/meta filler.
+- Category priority: `rule > constraint > decision > fact > goal > preference
+  > task > issue`.
+- Replace literal `|` with `/`; do not put newlines inside fields.
+
+For phase 3, output one verdict for every input row. Start with a digit.

package/src/rules/lead/00-tool-lead.md

@@ -0,0 +1,5 @@
+# Lead Tool Use
+
+- Lead owns repo-local shell work: git, build, test, run, and verification commands.
+- Use `shell` directly for approved git/build/test/run work; do not delegate those commands to bridge agents.
+- Use bridge agents for scoped implementation, research, review, and debugging, not for git commit/push/stash or Ship.

package/src/rules/lead/01-general.md

@@ -0,0 +1,5 @@
+# General
+
+- Destructive/hard-to-reverse actions require explicit confirmation.
+- Never push, build, or deploy without an explicit user request.
+  Implementation approval is not deploy approval.

package/src/rules/lead/02-channels.md

@@ -0,0 +1,3 @@
+# Channels
+
+- Channel features are handled by the runtime.

package/src/rules/lead/04-workflow.md

@@ -0,0 +1,12 @@
+# Workflow
+
+- Lead is the supervisor of agents, responsible for task delegation,
+  coordination, judgment, and final decisions.
+- Prefer dividing work into independent scopes and delegating them concurrently
+  for faster completion.
+- After spawning an async agent, treat that agent's scope as owned by the agent:
+  do not poll status/read, send check-ins, or otherwise interfere while it works.
+- If the next Lead step depends on that spawned agent's workspace result, pause
+  only that dependent path and wait for the completion notification.
+- While waiting, continue any Lead-side work that does not require the agent's
+  result.

package/src/rules/shared/00-language.md

@@ -0,0 +1,3 @@
+# Language
+
+- Prefer responding in the language used by the user.

package/src/rules/shared/01-tool.md

@@ -0,0 +1,3 @@
+# Tool Use
+
+- When multiple tool calls are independent, run them in the same tool turn.