@moda-ai/cli 1.15.0 → 1.16.0

package/dist/ask-stream.js

@@ -13,6 +13,7 @@
 // failure: it is returned as an outcome (`errorMessage`) and rendered the same
 // way buffered agent errors render.
 import { resolveApiKey, resolveModaBaseUrl } from './config.js';
+import { stripAnsi } from './markdown-terminal.js';
 /** Signals "fall back to the buffered ask endpoint" — never surfaced raw. */
 export class AskStreamError extends Error {
     constructor(message) {
@@ -116,8 +117,10 @@ export class AskStreamCollector {
             case 'tool_start': {
                 const tool = event.tool;
                 const id = typeof tool?.id === 'string' ? tool.id : '';
-                const name = typeof tool?.tool === 'string' ? tool.tool : 'tool';
-                const title = typeof tool?.title === 'string' ? tool.title : name;
+                // Backend-controlled strings — strip ANSI so a rogue/compromised backend
+                // (or prompt-injected LLM output) can't inject terminal control sequences.
+                const name = stripAnsi(typeof tool?.tool === 'string' ? tool.tool : 'tool');
+                const title = stripAnsi(typeof tool?.title === 'string' ? tool.title : name);
                 if (id)
                     this.toolNames.set(id, name);
                 this.onProgress(`• ${name} — ${title}…`);
@@ -191,7 +194,9 @@ export class AskStreamCollector {
  */
 const TOOL_CARD_DETAIL_MAX = 100;
 function oneLine(text) {
-    const collapsed = text.replace(/\s+/g, ' ').trim();
+    // Strip ANSI first: the source is backend-controlled tool summaries/errors,
+    // and ESC bytes survive the whitespace collapse below.
+    const collapsed = stripAnsi(text).replace(/\s+/g, ' ').trim();
     return collapsed.length > TOOL_CARD_DETAIL_MAX
         ? `${collapsed.slice(0, TOOL_CARD_DETAIL_MAX - 1)}…`
         : collapsed;

package/dist/harness-report.js

@@ -907,6 +907,12 @@ function normalizeGraphItemFieldAliases(collection, item) {
             else if (typeof item.target === 'string')
                 item.to = item.target;
         }
+        // Pre-1.14 analysts (e.g. a hosted container whose baked CLI predates the
+        // rename) emit the relationship type as `kind`. Observed in production:
+        // hosted reports failing validation with "relationships.<id> must include
+        // string type" while carrying the value under `kind`.
+        if (typeof item.type !== 'string' && typeof item.kind === 'string')
+            item.type = item.kind;
     }
 }
 /** Canonical evidence path for graph items: prefer explicit sourcePath, then evidence. */

package/dist/markdown-terminal.d.ts

@@ -0,0 +1,49 @@
+export interface MarkdownTerminalOptions {
+    /** When false, all structural fixes still apply but zero ANSI codes are emitted. */
+    color: boolean;
+}
+/** Minimal ANSI styling helpers shared by the renderer and ask chrome. */
+export interface TerminalStyles {
+    bold(text: string): string;
+    italic(text: string): string;
+    dim(text: string): string;
+    code(text: string): string;
+    /** Section heading: bold + underline. */
+    heading(text: string): string;
+}
+/**
+ * The CLI's color convention (mirrors `src/tui.ts` / `src/analyst-tui.ts`):
+ * color only for a human at a TTY, honoring `NO_COLOR` (present with ANY value,
+ * including the empty string, disables — per the no-color.org spec) and
+ * `TERM=dumb`.
+ */
+export declare function shouldColorTerminalOutput(opts?: {
+    isTTY?: boolean;
+    env?: NodeJS.ProcessEnv;
+}): boolean;
+/**
+ * ANSI style constructors. Closers restore the specific attribute (22/23/39)
+ * rather than a full reset so nested styles (code inside bold, bold inside a
+ * heading) survive. When `color` is false every helper is the identity.
+ */
+export declare function terminalStyles(color: boolean): TerminalStyles;
+/** Remove ANSI/OSC control sequences from untrusted content. */
+export declare function stripAnsi(text: string): string;
+/**
+ * Render an agent markdown answer for direct terminal display.
+ *
+ * - Headers lose their `#` sigils; h1/h2 render bold+underlined, h3+ bold,
+ *   with a blank line before.
+ * - `**bold**`, `*italic*`/`_italic_`, and backtick `code` spans lose their
+ *   sigils and gain ANSI styling (bold / italic / cyan) when `color` is on.
+ * - List items are re-indented to consistent 2-space-per-level steps based on
+ *   their original RELATIVE nesting (odd indents round to the nearest level; a
+ *   top-level-looking item after deeper items stays top-level). Bullets render
+ *   `•` at level 0 and `-` deeper; ordered items keep their numbers.
+ * - `|` table rows and fenced code blocks pass through untouched (only ANSI
+ *   control sequences are stripped, since that content is backend-controlled).
+ * - Runs of 3+ blank lines collapse to a single blank line.
+ * - Prose is never reflowed or wrapped.
+ */
+export declare function renderMarkdownForTerminal(markdown: string, opts: MarkdownTerminalOptions): string;
+//# sourceMappingURL=markdown-terminal.d.ts.map

package/dist/markdown-terminal.js

@@ -0,0 +1,212 @@
+// src/markdown-terminal.ts
+//
+// Pure markdown -> terminal renderer for human-mode output (`moda ask`).
+// The cloud agent answers in markdown; printing it raw leaves literal `##`
+// header sigils, `**bold**` asterisks, and the model's erratic list
+// indentation on screen. This module strips the sigils, applies ANSI styling
+// when the terminal supports it, and normalizes list nesting to consistent
+// 2-space steps — WITHOUT reflowing prose (terminals wrap themselves) and
+// WITHOUT touching `|` tables or fenced code blocks.
+//
+// No dependencies: raw ANSI escape constants only (the CLI has no color lib).
+/**
+ * The CLI's color convention (mirrors `src/tui.ts` / `src/analyst-tui.ts`):
+ * color only for a human at a TTY, honoring `NO_COLOR` (present with ANY value,
+ * including the empty string, disables — per the no-color.org spec) and
+ * `TERM=dumb`.
+ */
+export function shouldColorTerminalOutput(opts = {}) {
+    const env = opts.env ?? process.env;
+    const isTTY = opts.isTTY ?? process.stdout.isTTY === true;
+    if (!isTTY)
+        return false;
+    if (env.NO_COLOR !== undefined)
+        return false;
+    if (env.TERM === 'dumb')
+        return false;
+    return true;
+}
+/**
+ * ANSI style constructors. Closers restore the specific attribute (22/23/39)
+ * rather than a full reset so nested styles (code inside bold, bold inside a
+ * heading) survive. When `color` is false every helper is the identity.
+ */
+export function terminalStyles(color) {
+    const paint = (open, close) => (text) => color ? `\u001b[${open}m${text}\u001b[${close}m` : text;
+    return {
+        bold: paint('1', '22'),
+        italic: paint('3', '23'),
+        dim: paint('2', '22'),
+        code: paint('36', '39'),
+        heading: paint('1;4', '22;24'),
+    };
+}
+const FENCE_RE = /^\s*(`{3,}|~{3,})/;
+const FENCE_CLOSE_RE = /^\s*(`{3,}|~{3,})\s*$/;
+const TABLE_ROW_RE = /^\s*\|.*\S/;
+// Matches ANSI/OSC control sequences: CSI (ESC [ … final byte), OSC (ESC ] …
+// BEL or ST), and other two-byte escapes. Backend-controlled content (table
+// cells, code-fence bodies, streamed tool names/titles) is passed through
+// verbatim, so any escape sequences an LLM or a compromised backend emits must
+// be stripped before they reach the terminal — otherwise they could clear the
+// screen, spoof UI, or trigger OSC side-effects in some emulators.
+const ANSI_RE = /\u001b(?:\[[0-9;?]*[ -/]*[@-~]|\][^\u0007\u001b]*(?:\u0007|\u001b\\)|[@-Z\\-_])/g;
+/** Remove ANSI/OSC control sequences from untrusted content. */
+export function stripAnsi(text) {
+    return text.replace(ANSI_RE, '');
+}
+/**
+ * A fenced code block's opening marker: the fence character (`` ` `` or `~`)
+ * and its length. CommonMark closes a fence only with the same character and at
+ * least as many markers, so tracking these prevents a `~~~` line from closing a
+ * ` ``` ` block (and a 3-backtick line from closing a 4-backtick opener).
+ */
+function parseFenceOpen(line) {
+    const match = FENCE_RE.exec(line);
+    if (!match)
+        return null;
+    return { char: match[1][0], len: match[1].length };
+}
+/** Whether `line` closes an open fence per the CommonMark same-char/length rule. */
+function isFenceClose(line, fence) {
+    const match = FENCE_CLOSE_RE.exec(line);
+    return match !== null && match[1][0] === fence.char && match[1].length >= fence.len;
+}
+const HEADER_RE = /^(#{1,6})\s+(.*?)\s*#*\s*$/;
+const BULLET_RE = /^(\s*)([-*+])\s+(.*)$/;
+const ORDERED_RE = /^(\s*)(\d+)[.)]\s+(.*)$/;
+/**
+ * Render an agent markdown answer for direct terminal display.
+ *
+ * - Headers lose their `#` sigils; h1/h2 render bold+underlined, h3+ bold,
+ *   with a blank line before.
+ * - `**bold**`, `*italic*`/`_italic_`, and backtick `code` spans lose their
+ *   sigils and gain ANSI styling (bold / italic / cyan) when `color` is on.
+ * - List items are re-indented to consistent 2-space-per-level steps based on
+ *   their original RELATIVE nesting (odd indents round to the nearest level; a
+ *   top-level-looking item after deeper items stays top-level). Bullets render
+ *   `•` at level 0 and `-` deeper; ordered items keep their numbers.
+ * - `|` table rows and fenced code blocks pass through untouched (only ANSI
+ *   control sequences are stripped, since that content is backend-controlled).
+ * - Runs of 3+ blank lines collapse to a single blank line.
+ * - Prose is never reflowed or wrapped.
+ */
+export function renderMarkdownForTerminal(markdown, opts) {
+    const style = terminalStyles(opts.color);
+    const out = [];
+    // Original indent width backing each active list level; index == level.
+    const listStack = [];
+    // The open fence's char + length, or null outside a fenced code block.
+    let fence = null;
+    for (const raw of markdown.replace(/\r\n/g, '\n').split('\n')) {
+        if (fence) {
+            out.push(stripAnsi(raw));
+            if (isFenceClose(raw, fence))
+                fence = null;
+            continue;
+        }
+        const opened = parseFenceOpen(raw);
+        if (opened) {
+            fence = opened;
+            listStack.length = 0;
+            out.push(stripAnsi(raw));
+            continue;
+        }
+        if (TABLE_ROW_RE.test(raw)) {
+            // Tables depend on exact column spacing — pass through monospaced.
+            out.push(stripAnsi(raw));
+            continue;
+        }
+        const line = raw.replace(/\s+$/, '');
+        if (line === '') {
+            out.push('');
+            continue;
+        }
+        const header = HEADER_RE.exec(line);
+        if (header) {
+            listStack.length = 0;
+            // Strip inline sigils inside the header text (plain), then style the
+            // whole line so nested `**bold**` can't fight the heading attributes.
+            const text = renderInline(header[2], terminalStyles(false));
+            if (out.length > 0 && out[out.length - 1] !== '')
+                out.push('');
+            out.push(header[1].length <= 2 ? style.heading(text) : style.bold(text));
+            continue;
+        }
+        const bullet = BULLET_RE.exec(line);
+        const ordered = bullet ? null : ORDERED_RE.exec(line);
+        if (bullet || ordered) {
+            const match = (bullet ?? ordered);
+            const level = resolveListLevel(match[1].length, listStack);
+            const indent = '  '.repeat(level);
+            const text = renderInline(match[3], style);
+            if (bullet) {
+                out.push(`${indent}${level === 0 ? '•' : '-'} ${text}`);
+            }
+            else {
+                out.push(`${indent}${match[2]}. ${text}`);
+            }
+            continue;
+        }
+        // Unindented prose ends any open list; indented non-list lines are treated
+        // as continuations and keep the current nesting context.
+        if (!/^\s{2,}/.test(line))
+            listStack.length = 0;
+        out.push(renderInline(line, style));
+    }
+    return collapseBlankRuns(out).join('\n');
+}
+/**
+ * Map an item's original indent width onto a consistent nesting level.
+ * `stack[level]` remembers the original indent that opened that level:
+ * meaningfully shallower indents pop back out, meaningfully deeper indents
+ * open a new level, and anything within +/-1 space sticks to the current
+ * level (rounding the model's odd 3/5/7-space indents to the nearest level).
+ */
+function resolveListLevel(indent, stack) {
+    while (stack.length > 0 && indent < stack[stack.length - 1] - 1)
+        stack.pop();
+    if (stack.length === 0 || indent > stack[stack.length - 1] + 1)
+        stack.push(indent);
+    return stack.length - 1;
+}
+/**
+ * Strip/style inline markdown sigils: `code` spans first (protected via
+ * placeholders so asterisks/underscores inside them are never re-parsed),
+ * then `**bold**`/`__bold__`, then word-boundary `*italic*`/`_italic_`
+ * (mid-word underscores as in `silent_empty_result` never match).
+ */
+function renderInline(text, style) {
+    const codeSpans = [];
+    // Strip any ANSI escapes already in the (backend-controlled) text BEFORE we
+    // add our own styling, so this only removes injected sequences — never the
+    // codes the style helpers emit below.
+    let result = stripAnsi(text).replace(/`([^`]+)`/g, (_, code) => {
+        codeSpans.push(code);
+        return `\u0000${codeSpans.length - 1}\u0000`;
+    });
+    result = result.replace(/\*\*([^\s*](?:[^*]*[^\s*])?)\*\*/g, (_, inner) => style.bold(inner));
+    result = result.replace(/__([^\s_](?:[^_]*[^\s_])?)__/g, (_, inner) => style.bold(inner));
+    result = result.replace(/(?<![\w*])\*([^\s*](?:[^*\n]*[^\s*])?)\*(?![\w*])/g, (_, inner) => style.italic(inner));
+    result = result.replace(/(?<![\w_])_([^\s_](?:[^_\n]*[^\s_])?)_(?![\w_])/g, (_, inner) => style.italic(inner));
+    return result.replace(/\u0000(\d+)\u0000/g, (_, index) => style.code(codeSpans[Number(index)]));
+}
+/** Collapse runs of 3+ blank lines down to a single blank line. */
+function collapseBlankRuns(lines) {
+    const collapsed = [];
+    let blanks = 0;
+    for (const line of lines) {
+        if (line === '') {
+            blanks += 1;
+            continue;
+        }
+        if (blanks > 0)
+            collapsed.push('', ...(blanks === 2 ? [''] : []));
+        blanks = 0;
+        collapsed.push(line);
+    }
+    if (blanks > 0)
+        collapsed.push('', ...(blanks === 2 ? [''] : []));
+    return collapsed;
+}
+//# sourceMappingURL=markdown-terminal.js.map

package/dist/production-intelligence.d.ts

@@ -166,6 +166,8 @@ export declare function shouldStreamAsk(context: Pick<CommandContext, 'outputMod
  * confidence — the buffered endpoint also returns HTTP 200 in that case).
  */
 export declare function askResultFromStreamOutcome(outcome: AskStreamOutcome, question: string): ProductionAskResult;
-export declare function renderAskHuman(result: ProductionAskResult): string;
+export declare function renderAskHuman(result: ProductionAskResult, options?: {
+    color?: boolean;
+}): string;
 export {};
 //# sourceMappingURL=production-intelligence.d.ts.map

package/dist/production-intelligence.js

@@ -5,6 +5,7 @@ import { streamAsk } from './ask-stream.js';
 import { resolveModaBaseUrl } from './config.js';
 import { CliAuthError, CliInputError } from './errors.js';
 import { EXIT_DEGRADED, EXIT_OK, safeWriteStderr } from './output.js';
+import { renderMarkdownForTerminal, shouldColorTerminalOutput, stripAnsi, terminalStyles, } from './markdown-terminal.js';
 import { asNumber, asRecord, asString } from './transforms.js';
 import { INTELLIGENCE_SCHEMA_VERSION, } from './intelligence-schema.js';
 const INVESTIGATION_SCHEMA_VERSION = 'production_investigation.v0.1';
@@ -262,6 +263,9 @@ export function shouldStreamAsk(context, isTTY = process.stdout.isTTY === true)
  */
 async function askModaForContext(context, question, daysBack) {
     if (shouldStreamAsk(context)) {
+        // Progress lines go to stderr, so key color off the stderr TTY. Tool cards
+        // (`• …`) are dimmed subtly; phase lines (`▸ …`) stay at full strength.
+        const progressStyle = terminalStyles(shouldColorTerminalOutput({ isTTY: process.stderr.isTTY === true }));
         try {
             const outcome = await streamAsk({
                 question,
@@ -269,7 +273,7 @@ async function askModaForContext(context, question, daysBack) {
                 profile: context.profile,
                 harness: localHarnessSummary(context.cwd),
                 timeoutMs: askTimeoutMs(),
-                onProgress: (line) => safeWriteStderr(`${line}\n`),
+                onProgress: (line) => safeWriteStderr(`${line.startsWith('•') ? progressStyle.dim(line) : line}\n`),
             });
             return askResultFromStreamOutcome(outcome, question);
         }
@@ -1023,22 +1027,26 @@ function renderInvestigationHuman(investigation) {
     }
     return lines.join('\n');
 }
-export function renderAskHuman(result) {
+export function renderAskHuman(result, options = {}) {
+    // Same convention as the rest of the CLI: color only for a human at a TTY,
+    // honoring NO_COLOR and TERM=dumb. All information is identical either way.
+    const color = options.color ?? shouldColorTerminalOutput();
+    const style = terminalStyles(color);
     const lines = [];
-    lines.push('Moda ask');
-    lines.push(`Question: ${result.question}`);
+    lines.push(style.heading('Moda ask'));
+    lines.push(`${style.dim('Question:')} ${result.question}`);
     if (result.degraded) {
         lines.push('');
         lines.push('[degraded] Moda Cloud was unavailable — this answer is synthesized from local Data API evidence (lower trust).');
     }
     lines.push('');
-    lines.push(result.answer);
+    lines.push(renderMarkdownForTerminal(result.answer, { color }));
     lines.push('');
-    lines.push(`Confidence: ${result.confidence}`);
+    lines.push(`Confidence: ${style.bold(result.confidence)}`);
     lines.push(`Source: ${result.source}${result.degraded ? ' (degraded)' : ''}`);
     if (result.evidenceRefs.length > 0) {
         lines.push('');
-        lines.push('Evidence');
+        lines.push(style.bold('Evidence'));
         // Subtle grounding marker: flag model-inferred evidence so a human reader
         // can weight it. Ids/anchors stay hidden in the human projection.
         const grounding = new Map(result.intelligence.evidence_refs.map((ref) => [ref.id, ref.grounding]));
@@ -1047,8 +1055,11 @@ export function renderAskHuman(result) {
             const marker = grounding.get(ref.id) === 'inferred' ? ' (inferred)' : '';
             // Backend hrefs are root-relative dashboard paths; print the absolute
             // URL so terminals auto-linkify it and the reader can click through.
-            const link = ref.href ? `\n    ${dashboardBase}${ref.href}` : '';
-            lines.push(`  - ${ref.label}${ref.path ? ` (${ref.path})` : ''}${marker}${link}`);
+            // Strip ANSI from all backend-controlled fields before printing.
+            const label = stripAnsi(ref.label);
+            const path = ref.path ? ` (${stripAnsi(ref.path)})` : '';
+            const link = ref.href ? `\n    ${style.dim(`${dashboardBase}${stripAnsi(ref.href)}`)}` : '';
+            lines.push(`  - ${label}${path}${marker}${link}`);
         }
     }
     const unverifiedClaims = result.intelligence.answer_claims.filter((claim) => claim.status !== 'grounded').length;
@@ -1058,15 +1069,15 @@ export function renderAskHuman(result) {
     }
     if (result.nextCommands.length > 0) {
         lines.push('');
-        lines.push('Next commands');
+        lines.push(style.bold('Next commands'));
         for (const command of result.nextCommands.slice(0, 5))
-            lines.push(`  ${command}`);
+            lines.push(`  ${stripAnsi(command)}`);
     }
     if (result.warnings.length > 0) {
         lines.push('');
-        lines.push('Warnings');
+        lines.push(style.bold('Warnings'));
         for (const warning of result.warnings.slice(0, 3))
-            lines.push(`  - ${warning}`);
+            lines.push(`  - ${stripAnsi(warning)}`);
     }
     return lines.join('\n');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moda-ai/cli",
-  "version": "1.15.0",
+  "version": "1.16.0",
   "description": "CLI for Moda - AI agent analytics and observability",
   "type": "module",
   "bin": {

package/skills/integration/index.json

@@ -1,7 +1,7 @@
 {
   "schema_version": "moda.skill_index.v1",
-  "bundled_at": "2026-07-08T14:05:25.151Z",
-  "cli_version": "1.15.0",
+  "bundled_at": "2026-07-08T20:47:23.985Z",
+  "cli_version": "1.16.0",
   "skills": [
     {
       "id": "integration-node-anthropic",