@crouton-kit/crouter 0.3.20 → 0.3.22

package/dist/core/render.js

@@ -1,14 +1,18 @@
 // Default stdout rendering: the result a leaf returns is written FOR the model
 // to act on, not as data to parse. Output is a continuation of the agent's
-// prompt — light XML fences around markdown, prose where prose belongs. The
-// raw JSON object is still available behind the `--json` global for tooling.
+// prompt — PLAIN MARKDOWN, no XML wrapper. Scalars list as `- name: value`
+// bullets in output-schema order, prose fields render as paragraphs, and arrays
+// become a count lead-in plus a markdown table (objects) or bullets (scalars).
+// The raw JSON object is still available behind the `--json` global for tooling.
 //
 // A leaf may hand `defineLeaf` a bespoke `render(result)` for instruction-shaped
-// output (see `node new`, `push`, `feed read`). Everything else falls through to
-// the schema-driven generic renderer here, so every command obeys the paradigm
-// without a hand-written renderer.
+// output that leads with the outcome (see `node new`, `push`, `feed read`).
+// Everything else falls through to the schema-driven generic renderer here, so
+// every command obeys the markdown paradigm without a hand-written renderer.
+// `renderError` is the one sanctioned exception: a failure is a different domain
+// from a result, so it keeps its `<error>` block.
 // Field names whose value is prose the agent reads, not a scalar it keys on —
-// these always render as their own fenced block, never as a tag attribute.
+// these always render as their own paragraph, never as a `- name: value` bullet.
 const PROSE_FIELDS = new Set([
     'follow_up', 'digest', 'message', 'next', 'result', 'content', 'body', 'guide',
     'summary', 'note', 'reason', 'detail', 'details', 'hint', 'instruction',
@@ -37,20 +41,17 @@ function isProse(name, v) {
         return true;
     return v.includes('\n') || v.length > 80;
 }
-/** Short, space-free scalars ride as attributes on the open tag (ids, statuses,
- *  counts); everything else that isn't prose lists as a markdown bullet. */
-function isAttr(v) {
-    if (typeof v === 'number' || typeof v === 'boolean')
-        return true;
-    return typeof v === 'string' && v.length <= 40 && !v.includes(' ') && !v.includes('\n');
-}
-/** Root element name = the command path with spaces hyphenated. */
-function rootTag(help) {
-    return help.name.trim().split(/\s+/).join('-').replace(/[^a-zA-Z0-9_-]/g, '') || 'result';
+/** Keep a value safe inside a markdown table cell: pipes would split columns,
+ *  newlines would break the row. */
+function cellEsc(v) {
+    return scalarStr(v).replace(/\|/g, '\\|').replace(/\n/g, ' ');
 }
+/** An array renders as a count lead-in followed by the collection: a markdown
+ *  table when every element is an object, plain bullets otherwise. */
 function renderArray(name, arr) {
     if (arr.length === 0)
-        return `<${name} count="0"></${name}>`;
+        return `0 ${name}.`;
+    const lead = `${arr.length} ${name}:`;
     const allObjects = arr.every((x) => x !== null && typeof x === 'object' && !Array.isArray(x));
     if (allObjects) {
         const rows = arr;
@@ -61,55 +62,51 @@ function renderArray(name, arr) {
                     cols.push(k);
         const head = `| ${cols.join(' | ')} |`;
         const sep = `| ${cols.map(() => '---').join(' | ')} |`;
-        const body = rows.map((r) => `| ${cols.map((c) => scalarStr(r[c])).join(' | ')} |`).join('\n');
-        return `<${name} count="${arr.length}">\n${head}\n${sep}\n${body}\n</${name}>`;
+        const body = rows.map((r) => `| ${cols.map((c) => cellEsc(r[c])).join(' | ')} |`).join('\n');
+        return `${lead}\n\n${head}\n${sep}\n${body}`;
     }
     const items = arr.map((x) => `- ${scalarStr(x)}`).join('\n');
-    return `<${name} count="${arr.length}">\n${items}\n</${name}>`;
+    return `${lead}\n${items}`;
 }
-/** Schema-driven fallback: turn a result object into agent-ready XML+markdown.
+/** Schema-driven fallback: turn a result object into agent-ready plain markdown.
  *  Field order follows the leaf's declared output schema; any extra keys append
- *  after. Scalars become attributes or a bullet list, prose and collections
- *  become their own fenced blocks. */
+ *  after. Scalars (and nested objects) list as `- name: value` bullets, prose
+ *  fields render as paragraphs, and arrays become a count lead-in plus a table
+ *  or bullets. No root tag — the result is read as a continuation of the prompt. */
 export function renderResult(result, help) {
     const order = help.output.map((f) => f.name);
     for (const k of Object.keys(result))
         if (!order.includes(k))
             order.push(k);
-    const attrs = [];
     const bullets = [];
-    const blocks = [];
+    const proseFields = [];
+    const arrays = [];
     for (const name of order) {
         const v = result[name];
         if (v === undefined || v === null)
             continue;
         if (Array.isArray(v)) {
-            blocks.push(renderArray(name, v));
-            continue;
-        }
-        if (typeof v === 'object') {
-            blocks.push(`<${name}>\n${JSON.stringify(v, null, 2)}\n</${name}>`);
+            arrays.push(renderArray(name, v));
             continue;
         }
         if (isProse(name, v)) {
-            blocks.push(`<${name}>\n${v}\n</${name}>`);
-            continue;
-        }
-        if (isAttr(v)) {
-            attrs.push(`${name}="${attrEsc(v)}"`);
+            proseFields.push({ name, text: v });
             continue;
         }
+        // Scalars and nested objects alike list as a bullet (objects via compact JSON).
         bullets.push(`- ${name}: ${scalarStr(v)}`);
     }
-    const tag = rootTag(help);
-    const open = attrs.length > 0 ? `<${tag} ${attrs.join(' ')}>` : `<${tag}>`;
     const parts = [];
     if (bullets.length > 0)
         parts.push(bullets.join('\n'));
-    if (blocks.length > 0)
-        parts.push(blocks.join('\n\n'));
-    const inner = parts.join('\n\n');
-    return inner !== '' ? `${open}\n${inner}\n</${tag}>` : `${open}</${tag}>`;
+    // Label prose only when more than one block would otherwise blur together.
+    const labelProse = proseFields.length > 1;
+    for (const { name, text } of proseFields) {
+        parts.push(labelProse ? `**${name}:** ${text}` : text);
+    }
+    for (const block of arrays)
+        parts.push(block);
+    return parts.join('\n\n');
 }
 /** Render a structured failure as an instruction-shaped block: what broke, what
  *  was received, and the recovery road sign — the same recovery info the JSON

package/dist/core/resolver.d.ts

@@ -1,25 +1,7 @@
-import type { InstalledMarketplace, InstalledPlugin, Scope, ScopeConfig, Skill } from '../types.js';
+import type { InstalledMarketplace, InstalledPlugin, Scope } from '../types.js';
 export declare function listInstalledPlugins(scope: Scope): InstalledPlugin[];
 export declare function listAllPlugins(): InstalledPlugin[];
 export declare function findPluginByName(name: string, scope?: Scope): InstalledPlugin | null;
-interface ScopeConfigs {
-    project?: ScopeConfig;
-    user: ScopeConfig;
-}
-export declare function effectiveSkillEnabled(pluginName: string, skillName: string, cfgs: ScopeConfigs): {
-    enabled: boolean;
-    disabledIn?: Scope;
-};
-export declare function listSkillsInPlugin(plugin: InstalledPlugin, cfgs?: ScopeConfigs): Skill[];
-export declare function listScopeRootSkills(scope: Scope, cfgs?: ScopeConfigs): Skill[];
-export declare function listAllSkills(scopeFilter?: Scope): Skill[];
-export declare function listSkillSiblings(skill: Skill): Skill[];
-export declare function listSkillChildren(skill: Skill): Skill[];
-export interface SkillResolutionOpts {
-    scope?: Scope;
-    pluginFilter?: string;
-}
-export declare function resolveSkill(rawName: string, opts?: SkillResolutionOpts): Skill;
 export interface ParsedSkillQualifier {
     scope?: Scope;
     segments: string[];
@@ -28,15 +10,4 @@ export declare function parseSkillQualifier(raw: string): ParsedSkillQualifier;
 export declare function listInstalledMarketplaces(scope: Scope): InstalledMarketplace[];
 export declare function listAllMarketplaces(): InstalledMarketplace[];
 export declare function findMarketplaceByName(name: string, scope?: Scope): InstalledMarketplace | null;
-export interface CategoryResolution {
-    id: string;
-    plugin: string | undefined;
-    scope: Scope | undefined;
-    dir: string;
-    indexPath: string | undefined;
-    skills: Skill[];
-}
-export declare function resolveCategory(name: string, opts?: SkillResolutionOpts): CategoryResolution | null;
-export declare function buildCategoryIndex(cat: CategoryResolution): string;
 export declare function scopeRootsLabel(): string;
-export {};