@claude-flow/cli 3.32.3 → 3.32.4

package/dist/src/memory/structured-distill.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Structured Distillation for trajectory content (#2241 §SOTA — arXiv:2603.13017).
+ *
+ * The arXiv paper compresses agent exchanges from ~371 to ~38 tokens (11×) using
+ * a four-field schema, and reports retrieval MRR going from 0.745 (raw) to
+ * 0.759 (distilled) on a 214 K-pair consensus-graded corpus. The schema is
+ * domain-portable; we adopt it for trajectory step content so SONA's recall
+ * works against a denser, higher-signal representation.
+ *
+ * This module is the RULE-BASED extractor. A future round can plug in a
+ * learned distiller (cross-encoder / LLM); the schema and the harness stay
+ * the same so the swap is drop-in.
+ *
+ * Schema:
+ *   summary  — first sentence (capped); the headline of the exchange
+ *   detail   — the rest of the content (capped); kept for fidelity
+ *   labels   — domain tokens: verbs, nouns, and recognised actions
+ *   paths    — file paths and file:line references (high-signal anchors)
+ */
+/** Distilled trajectory content. */
+export interface DistilledContent {
+    summary: string;
+    detail: string;
+    labels: string[];
+    paths: string[];
+}
+/**
+ * Distill a raw trajectory step's content into the 4-field schema.
+ * Deterministic, dependency-free, sub-millisecond.
+ */
+export declare function distillTrajectoryContent(raw: string): DistilledContent;
+/**
+ * Serialise a distilled object into a compact embedding-ready string. The
+ * resulting form is what gets embedded for retrieval — labels and paths come
+ * first so they get high attention weight in the embedding.
+ *
+ * The paper's MRR uplift comes from the ordering: high-signal tokens (labels,
+ * paths) lead, so the embedder allocates more probability mass to them.
+ */
+export declare function serialiseDistilled(d: DistilledContent): string;
+/** Convenience: distill then serialise. */
+export declare function distillAndSerialise(raw: string): string;
+/**
+ * Compression ratio: raw bytes / distilled bytes. >1 means distilled is
+ * smaller. Used by the benchmark harness.
+ */
+export declare function compressionRatio(raw: string): number;
+//# sourceMappingURL=structured-distill.d.ts.map

package/dist/src/memory/structured-distill.js

@@ -0,0 +1,125 @@
+/**
+ * Structured Distillation for trajectory content (#2241 §SOTA — arXiv:2603.13017).
+ *
+ * The arXiv paper compresses agent exchanges from ~371 to ~38 tokens (11×) using
+ * a four-field schema, and reports retrieval MRR going from 0.745 (raw) to
+ * 0.759 (distilled) on a 214 K-pair consensus-graded corpus. The schema is
+ * domain-portable; we adopt it for trajectory step content so SONA's recall
+ * works against a denser, higher-signal representation.
+ *
+ * This module is the RULE-BASED extractor. A future round can plug in a
+ * learned distiller (cross-encoder / LLM); the schema and the harness stay
+ * the same so the swap is drop-in.
+ *
+ * Schema:
+ *   summary  — first sentence (capped); the headline of the exchange
+ *   detail   — the rest of the content (capped); kept for fidelity
+ *   labels   — domain tokens: verbs, nouns, and recognised actions
+ *   paths    — file paths and file:line references (high-signal anchors)
+ */
+const SUMMARY_MAX = 200;
+const DETAIL_MAX = 1024;
+// Imperative verbs typical of code-work trajectories (Reflexion / ReasoningBank
+// vocabulary). Order-preserving for stable deduplication.
+const ACTION_VOCAB = [
+    'refactor', 'fix', 'add', 'remove', 'rename', 'extract', 'inline',
+    'split', 'merge', 'delete', 'rewrite', 'simplify', 'optimize',
+    'test', 'mock', 'stub', 'verify', 'assert', 'expect',
+    'document', 'explain', 'comment',
+    'debug', 'trace', 'log', 'diagnose',
+    'wire', 'route', 'dispatch', 'register', 'unregister',
+    'parse', 'validate', 'sanitize', 'normalize',
+    'cache', 'invalidate', 'flush', 'persist', 'load',
+    'embed', 'distill', 'train', 'consolidate', 'recall',
+];
+// A trajectory step might contain code blocks, file refs, or natural prose;
+// these regexes catch the high-signal anchors without false positives on
+// general English.
+const PATH_REGEX = /\b([a-zA-Z0-9_./-]+\.(?:ts|tsx|js|jsx|mjs|cjs|py|go|rs|java|kt|swift|c|cpp|h|hpp|rb|md|json|yaml|yml|toml|sql))(?::(\d+))?\b/g;
+const SENTENCE_END = /([.!?])\s+(?=[A-Z(])/;
+function firstSentence(text) {
+    const m = text.match(SENTENCE_END);
+    if (!m || m.index === undefined)
+        return text.slice(0, SUMMARY_MAX);
+    return text.slice(0, m.index + 1).slice(0, SUMMARY_MAX);
+}
+function extractPaths(text) {
+    const found = new Set();
+    for (const m of text.matchAll(PATH_REGEX)) {
+        found.add(m[2] ? `${m[1]}:${m[2]}` : m[1]);
+    }
+    return [...found];
+}
+function extractLabels(text) {
+    const lower = text.toLowerCase();
+    const labels = new Set();
+    // Action vocabulary
+    for (const v of ACTION_VOCAB) {
+        if (lower.includes(v))
+            labels.add(v);
+    }
+    // High-signal nouns (camelCase / PascalCase identifiers, ALL_CAPS constants).
+    // Cap to the top 5 most-frequent so labels stay short.
+    const counts = new Map();
+    for (const m of text.matchAll(/\b([A-Z][a-zA-Z0-9]{3,}|[A-Z][A-Z0-9_]{3,}|[a-z][a-zA-Z0-9]{4,}[A-Z][a-zA-Z0-9]{1,})\b/g)) {
+        const t = m[1];
+        if (/^[a-zA-Z]+$/.test(t) && t.length > 20)
+            continue; // skip very long words
+        counts.set(t, (counts.get(t) ?? 0) + 1);
+    }
+    const top = [...counts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5);
+    for (const [t] of top)
+        labels.add(t);
+    return [...labels];
+}
+/**
+ * Distill a raw trajectory step's content into the 4-field schema.
+ * Deterministic, dependency-free, sub-millisecond.
+ */
+export function distillTrajectoryContent(raw) {
+    const text = String(raw ?? '').trim();
+    if (!text)
+        return { summary: '', detail: '', labels: [], paths: [] };
+    const paths = extractPaths(text);
+    const labels = extractLabels(text);
+    const summary = firstSentence(text);
+    // detail = everything after the first sentence, up to cap
+    const rest = text.slice(summary.length).trim();
+    const detail = rest.slice(0, DETAIL_MAX);
+    return { summary, detail, labels, paths };
+}
+/**
+ * Serialise a distilled object into a compact embedding-ready string. The
+ * resulting form is what gets embedded for retrieval — labels and paths come
+ * first so they get high attention weight in the embedding.
+ *
+ * The paper's MRR uplift comes from the ordering: high-signal tokens (labels,
+ * paths) lead, so the embedder allocates more probability mass to them.
+ */
+export function serialiseDistilled(d) {
+    const parts = [];
+    if (d.labels.length)
+        parts.push(`[${d.labels.join(', ')}]`);
+    if (d.paths.length)
+        parts.push(`paths: ${d.paths.join(' ')}`);
+    if (d.summary)
+        parts.push(d.summary);
+    if (d.detail)
+        parts.push(d.detail);
+    return parts.join('\n');
+}
+/** Convenience: distill then serialise. */
+export function distillAndSerialise(raw) {
+    return serialiseDistilled(distillTrajectoryContent(raw));
+}
+/**
+ * Compression ratio: raw bytes / distilled bytes. >1 means distilled is
+ * smaller. Used by the benchmark harness.
+ */
+export function compressionRatio(raw) {
+    const distilled = distillAndSerialise(raw);
+    if (distilled.length === 0)
+        return 1;
+    return raw.length / distilled.length;
+}
+//# sourceMappingURL=structured-distill.js.map

package/dist/src/output.d.ts

@@ -0,0 +1,9 @@
+/**
+ * V3 CLI Output Formatter — re-export shim (ADR-100, alpha.5).
+ *
+ * Authoritative source: @claude-flow/cli-core/output. Was a byte-identical
+ * 640-line copy. The OutputFormatter class and `output` instance plus all
+ * helper exports flow through unchanged. Edit cli-core for behavior changes.
+ */
+export * from '@claude-flow/cli-core/output';
+//# sourceMappingURL=output.d.ts.map

package/dist/src/output.js

@@ -0,0 +1,9 @@
+/**
+ * V3 CLI Output Formatter — re-export shim (ADR-100, alpha.5).
+ *
+ * Authoritative source: @claude-flow/cli-core/output. Was a byte-identical
+ * 640-line copy. The OutputFormatter class and `output` instance plus all
+ * helper exports flow through unchanged. Edit cli-core for behavior changes.
+ */
+export * from '@claude-flow/cli-core/output';
+//# sourceMappingURL=output.js.map

package/dist/src/parser.d.ts

@@ -0,0 +1,89 @@
+/**
+ * V3 CLI Command Parser
+ * Advanced argument parsing with validation and type coercion
+ */
+import type { Command, CommandOption, ParsedFlags } from './types.js';
+export interface ParseResult {
+    command: string[];
+    flags: ParsedFlags;
+    positional: string[];
+    raw: string[];
+}
+export interface ParserOptions {
+    stopAtFirstNonFlag?: boolean;
+    allowUnknownFlags?: boolean;
+    booleanFlags?: string[];
+    stringFlags?: string[];
+    arrayFlags?: string[];
+    aliases?: Record<string, string>;
+    defaults?: Record<string, unknown>;
+}
+export declare class CommandParser {
+    private options;
+    private commands;
+    private lazyCommandNames;
+    private globalOptions;
+    constructor(options?: ParserOptions);
+    private initializeGlobalOptions;
+    registerCommand(command: Command): void;
+    /**
+     * Register a lazy-loaded command's name so Pass 1/Pass 2 can recognize it as
+     * a command position even though its full definition hasn't been loaded yet.
+     * Fix for #1596: without this, lazy commands like `daemon start` were
+     * mis-routed because Pass 1 walked past `daemon` and greedy-matched `start`.
+     */
+    registerLazyCommandName(name: string): void;
+    /**
+     * #1791.2 — true when `name` is a lazy command that hasn't been promoted
+     * to a fully registered Command yet. The CLI uses this to eagerly load
+     * the module before parsing so its subcommand flags (e.g. `-d` for
+     * `hive-mind task --description`) are scoped into the alias map. Without
+     * this, lazy commands' short flags silently fall through to global
+     * resolution and the action handler sees an empty `flags.description`.
+     */
+    isLazyOnly(name: string): boolean;
+    private isKnownCommandName;
+    getCommand(name: string): Command | undefined;
+    getAllCommands(): Command[];
+    parse(args: string[]): ParseResult;
+    private parseFlag;
+    /**
+     * Decide whether `arg` should be consumed as the VALUE of the preceding flag,
+     * rather than treated as the next flag.
+     *
+     * Bug fix (audit #1, follow-up to #2222): a negative numeric value such as
+     * `-1.0` starts with '-', so the old `!arg.startsWith('-')` test rejected it
+     * as a value and parsed it as a (bogus) short flag. For `route feedback
+     * -r -1.0` this silently dropped the value and coerced reward to `true` → 1.0,
+     * so NEGATIVE feedback REINFORCED the agent. Only `--reward=-1.0` worked.
+     *
+     * Anything not starting with '-' is a value (unchanged). Anything that starts
+     * with '-' is a value ONLY if it is a pure negative number (e.g. `-1`, `-1.0`,
+     * `-3.14`, `-1e3`). Real flags like `-r`, `--reward`, `-abc` are never numeric
+     * after the leading dash, so they are still correctly treated as flags.
+     */
+    private isFlagValue;
+    /** True for the literal tokens `true`/`false` (case-insensitive). Used so a
+     * boolean flag can take an explicit value in the space form, e.g.
+     * `--explore false` / `-e true`. */
+    private isBooleanLiteral;
+    private parseValue;
+    private normalizeKey;
+    private buildAliases;
+    /**
+     * Build aliases scoped to a specific command/subcommand.
+     * The resolved command's short flags take priority over global ones,
+     * fixing collisions where multiple subcommands use the same short flag (e.g. -t).
+     */
+    private buildScopedAliases;
+    /**
+     * Get boolean flags scoped to a specific command/subcommand.
+     */
+    private getScopedBooleanFlags;
+    private getBooleanFlags;
+    private applyDefaults;
+    validateFlags(flags: ParsedFlags, command?: Command): string[];
+    getGlobalOptions(): CommandOption[];
+}
+export declare const commandParser: CommandParser;
+//# sourceMappingURL=parser.d.ts.map