@moda-ai/cli 1.7.0 → 1.8.1

package/dist/cli.js

@@ -2,7 +2,7 @@
 import { z } from 'zod';
 import { validateConfig, VERSION, resolveApiKey } from './config.js';
 import { callDataAPI, ApiError, getApiRequestCount, resetApiRequestCount, } from './api-client.js';
-import { OverviewSchema, ClustersSchema, ClusterConversationsSchema, ConversationsSchema, ContextSchema, FrustrationsSchema, ToolFailuresSchema, ToolFailureDetailSchema, WorkflowsSchema, RunsSchema, RunDetailSchema, LoopsSchema, LoopDetailSchema, } from './schemas.js';
+import { OverviewSchema, ClustersSchema, ClusterConversationsSchema, ConversationsSchema, SearchSchema, WorldStateSchema, ContextSchema, FrustrationsSchema, ToolFailuresSchema, ToolFailureDetailSchema, WorkflowsSchema, RunsSchema, RunDetailSchema, LoopsSchema, LoopDetailSchema, } from './schemas.js';
 import { withFrustrationAnchors, withToolFailureAnchors, embeddedWindowSize, asRecord, asString, asNumber } from './transforms.js';
 import { runPromptsCommand } from './prompts.js';
 // Coding-agent capture (shadow workspace / Shadow Spark / trace hooks) is temporarily
@@ -137,6 +137,8 @@ Commands:
   clusters                         Browse topic cluster hierarchy
   cluster-conversations <node_id>  List conversations in a cluster
   conversations                    Search and filter conversations
+  search "<query>"                 Search conversation messages (keyword/semantic/hybrid)
+  world-state <conversation_id>    Get a conversation's world state (slots/threads/events)
   context <conversation_id>        Get windowed conversation context
   frustrations                     Get user frustration detections
   tool-failures                    Get tool failure overview
@@ -183,6 +185,24 @@ Common flags:
   --no-tui                         Show raw analyst stream instead of dashboard
   --no-update-check                Skip the daily new-version check (or MODA_CLI_UPDATE_CHECK=0)
 
+Conversations flags:
+  --search=TEXT                    Substring match on the conversation summary
+  --world-state=KEYWORDS           Match world-state content (slots + durable profile); comma = AND
+  --outcome=any|positive|negative  Filter by conversation outcome (trajectory + frustration)
+  --include-world-state            Attach each result's world-state summary
+  --user-id=ID                     Filter to a single user
+  --environment=ENV                Filter by environment (all|development|staging|production)
+
+Search flags:
+  --mode=keyword|semantic|hybrid   Search mode (default hybrid)
+  --user-id=ID                     Filter to a single user
+  --time-range=RANGE               Time range filter (all|1h|3d|7d|24h|30d|90d)
+  --limit=N                        Maximum results to return (1-100, default 20)
+
+World-state flags:
+  --summary-only                   Return segment summaries only (omit the event stream)
+  --event-limit=N                  Max world-state events to return (1-5000, default 2000)
+
 Runs flags:
   --outcome=OUTCOME                Filter by outcome (running|succeeded|partial|failed|loop|abandoned|unknown)
   --class-id=ID                    Filter to a single workflow class (e.g. cron:helpscout-triage-hourly)
@@ -234,6 +254,11 @@ Examples:
   moda overview --days-back=30
   moda clusters --time-range=7d
   moda conversations --search="error" --limit=5
+  moda conversations --world-state="enterprise" --outcome=positive
+  moda conversations --world-state="refund,billing" --include-world-state
+  moda search "billing error" --mode=hybrid
+  moda search "refund flow" --mode=semantic --time-range=7d --limit=10
+  moda world-state <conversation_id> --summary-only
   moda frustrations --days-back=14 --limit=20
   moda context <conversation_id> --window=3
   moda workflows --time-range=7d
@@ -292,6 +317,25 @@ async function printWithOptionalWindows(enriched, listKey, includeWindow, window
     const withWindows = await attachWindows(list, windowSize);
     output.writeData({ ...enriched, [listKey]: withWindows });
 }
+// Hydrate each conversation row with its world-state summary (slots + segment
+// summaries, no event stream) via the drill-in endpoint. Mirrors attachWindows:
+// best-effort per row, never throws.
+async function attachWorldState(rows) {
+    return Promise.all(rows.map(async (row) => {
+        const conv_id = asString(row.conversation_id) ?? '';
+        if (!conv_id) {
+            return { ...row, world_state: null };
+        }
+        try {
+            const data = await callDataAPI(`/conversations/${conv_id}/world-state?summary_only=1`);
+            return { ...row, world_state: data };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return { ...row, world_state: { error: message } };
+        }
+    }));
+}
 export async function runCommand(command, positional, flags, positionals = positional ? [positional] : [], context = createCommandContext({ command, positional, positionals, flags })) {
     switch (command) {
         case 'prompts': {
@@ -357,12 +401,65 @@ export async function runCommand(command, positional, flags, positionals = posit
                 query.set('time_range', params.time_range);
             if (params.environment)
                 query.set('environment', params.environment);
+            if (params.world_state)
+                query.set('world_state', params.world_state);
+            if (params.outcome && params.outcome !== 'any')
+                query.set('outcome', params.outcome);
             if (params.limit)
                 query.set('limit', params.limit.toString());
             if (params.offset !== undefined)
                 query.set('offset', params.offset.toString());
             const queryString = query.toString() ? `?${query.toString()}` : '';
             const data = await callDataAPI(`/conversations${queryString}`);
+            if (params.include_world_state === true) {
+                const enriched = asRecord(data) ?? {};
+                const list = Array.isArray(enriched.conversations)
+                    ? enriched.conversations
+                    : [];
+                const withState = await attachWorldState(list);
+                context.output.writeData({ ...enriched, conversations: withState });
+            }
+            else {
+                context.output.writeData(data);
+            }
+            break;
+        }
+        case 'search': {
+            // Positional query mirrors world-state/context/cluster-conversations:
+            // reject an empty/whitespace query with the shared CLI input error before
+            // it reaches the schema (which also guards via q.min(1)).
+            if (!positional || positional.trim() === '') {
+                throw new CliInputError('<query> is required', 'Usage: moda search "<query>" [--mode=keyword|semantic|hybrid] [--user-id=ID] [--time-range=RANGE] [--limit=N]');
+            }
+            const args = flagsToArgs(flags, 'q', positional);
+            const params = SearchSchema.parse(args);
+            const query = new URLSearchParams();
+            query.set('q', params.q);
+            if (params.mode)
+                query.set('mode', params.mode);
+            if (params.user_id)
+                query.set('user_id', params.user_id);
+            if (params.time_range)
+                query.set('time_range', params.time_range);
+            if (params.limit)
+                query.set('limit', params.limit.toString());
+            const data = await callDataAPI(`/search?${query.toString()}`);
+            context.output.writeData(data);
+            break;
+        }
+        case 'world-state': {
+            if (!positional) {
+                throw new CliInputError('<conversation_id> is required', 'Usage: moda world-state <conversation_id> [--summary-only] [--event-limit=N]');
+            }
+            const args = flagsToArgs(flags, 'conversation_id', positional);
+            const params = WorldStateSchema.parse(args);
+            const query = new URLSearchParams();
+            if (params.summary_only === true)
+                query.set('summary_only', '1');
+            if (params.event_limit)
+                query.set('event_limit', params.event_limit.toString());
+            const queryString = query.toString() ? `?${query.toString()}` : '';
+            const data = await callDataAPI(`/conversations/${params.conversation_id}/world-state${queryString}`);
             context.output.writeData(data);
             break;
         }
@@ -784,7 +881,29 @@ export const commandRegistry = createCommandRegistry([
     legacyCommand({
         name: 'conversations',
         description: 'Search and filter conversations',
-        examples: ['moda conversations --search="error" --limit=5'],
+        examples: [
+            'moda conversations --search="error" --limit=5',
+            'moda conversations --world-state="enterprise" --outcome=positive',
+            'moda conversations --world-state="refund,enterprise" --include-world-state',
+        ],
+        ...dataApiDefaults,
+    }),
+    legacyCommand({
+        name: 'search',
+        description: 'Search conversation messages (keyword, semantic, or hybrid)',
+        examples: [
+            'moda search "billing error"',
+            'moda search "refund flow" --mode=semantic --time-range=7d --limit=10',
+        ],
+        ...dataApiDefaults,
+    }),
+    legacyCommand({
+        name: 'world-state',
+        description: "Get a conversation's world state (slots, threads, events)",
+        examples: [
+            'moda world-state <conversation_id>',
+            'moda world-state <conversation_id> --summary-only',
+        ],
         ...dataApiDefaults,
     }),
     legacyCommand({

package/dist/schemas.d.ts

@@ -35,6 +35,9 @@ export declare const ConversationsSchema: z.ZodObject<{
     user_id: z.ZodOptional<z.ZodString>;
     time_range: z.ZodOptional<z.ZodDefault<z.ZodEnum<["all", "1h", "3d", "24h", "7d", "30d", "90d"]>>>;
     environment: z.ZodOptional<z.ZodDefault<z.ZodEnum<["all", "development", "staging", "production"]>>>;
+    world_state: z.ZodOptional<z.ZodString>;
+    outcome: z.ZodOptional<z.ZodDefault<z.ZodEnum<["any", "positive", "negative"]>>>;
+    include_world_state: z.ZodOptional<z.ZodEffects<z.ZodBoolean, boolean, unknown>>;
     limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
     offset: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
 }, "strip", z.ZodTypeAny, {
@@ -45,6 +48,9 @@ export declare const ConversationsSchema: z.ZodObject<{
     offset?: number | undefined;
     cluster_id?: string | undefined;
     user_id?: string | undefined;
+    world_state?: string | undefined;
+    outcome?: "any" | "positive" | "negative" | undefined;
+    include_world_state?: boolean | undefined;
 }, {
     search?: string | undefined;
     environment?: "staging" | "all" | "development" | "production" | undefined;
@@ -53,6 +59,23 @@ export declare const ConversationsSchema: z.ZodObject<{
     offset?: number | undefined;
     cluster_id?: string | undefined;
     user_id?: string | undefined;
+    world_state?: string | undefined;
+    outcome?: "any" | "positive" | "negative" | undefined;
+    include_world_state?: unknown;
+}>;
+/** moda world-state <conversationId> — per-conversation world-state drill-in. */
+export declare const WorldStateSchema: z.ZodObject<{
+    conversation_id: z.ZodString;
+    summary_only: z.ZodOptional<z.ZodEffects<z.ZodBoolean, boolean, unknown>>;
+    event_limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    conversation_id: string;
+    summary_only?: boolean | undefined;
+    event_limit?: number | undefined;
+}, {
+    conversation_id: string;
+    summary_only?: unknown;
+    event_limit?: number | undefined;
 }>;
 export declare const ContextSchema: z.ZodObject<{
     conversation_id: z.ZodString;
@@ -118,6 +141,30 @@ export declare const ToolFailureDetailSchema: z.ZodObject<{
     include_window?: unknown;
     subtype?: string | undefined;
 }>;
+/**
+ * moda search "<query>" — keyword/semantic/hybrid search across conversation
+ * messages. `q` arrives as a positional arg; the runCommand handler rejects an
+ * empty/whitespace query before parsing, and min(1) guards the schema path too.
+ */
+export declare const SearchSchema: z.ZodObject<{
+    q: z.ZodString;
+    mode: z.ZodOptional<z.ZodDefault<z.ZodEnum<["keyword", "semantic", "hybrid"]>>>;
+    user_id: z.ZodOptional<z.ZodString>;
+    time_range: z.ZodOptional<z.ZodDefault<z.ZodEnum<["all", "1h", "3d", "7d", "24h", "30d", "90d"]>>>;
+    limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    q: string;
+    mode?: "keyword" | "semantic" | "hybrid" | undefined;
+    time_range?: "all" | "1h" | "3d" | "7d" | "24h" | "30d" | "90d" | undefined;
+    limit?: number | undefined;
+    user_id?: string | undefined;
+}, {
+    q: string;
+    mode?: "keyword" | "semantic" | "hybrid" | undefined;
+    time_range?: "all" | "1h" | "3d" | "7d" | "24h" | "30d" | "90d" | undefined;
+    limit?: number | undefined;
+    user_id?: string | undefined;
+}>;
 /** moda workflows — recurring workflow catalog (read from agent_job_classes). */
 export declare const WorkflowsSchema: z.ZodObject<{
     time_range: z.ZodOptional<z.ZodDefault<z.ZodEnum<["all", "1h", "3d", "7d", "24h", "30d", "90d"]>>>;

package/dist/schemas.js

@@ -25,9 +25,23 @@ export const ConversationsSchema = z.object({
     user_id: z.string().optional(),
     time_range: z.enum(['all', '1h', '3d', '24h', '7d', '30d', '90d']).default('all').optional(),
     environment: z.enum(['all', 'development', 'staging', 'production']).default('all').optional(),
+    // Keyword(s) matched against conversation world-state content (segment slots
+    // + carried-in durable profile slots). Comma-separated terms are ANDed.
+    // max(200) mirrors the backend ConversationsQueryDto @MaxLength(200) so an
+    // over-long value fails locally instead of round-tripping a 400.
+    world_state: z.string().max(200).optional(),
+    // Filter by conversation outcome (trajectory + frustration).
+    outcome: z.enum(['any', 'positive', 'negative']).default('any').optional(),
+    include_world_state: boolFlag(),
     limit: z.number().min(1).max(100).default(20).optional(),
     offset: z.number().min(0).default(0).optional(),
 });
+/** moda world-state <conversationId> — per-conversation world-state drill-in. */
+export const WorldStateSchema = z.object({
+    conversation_id: z.string(),
+    summary_only: boolFlag(),
+    event_limit: z.number().min(1).max(5000).default(2000).optional(),
+});
 export const ContextSchema = z.object({
     conversation_id: z.string(),
     msg_index: z.number().min(0).optional(),
@@ -62,6 +76,19 @@ export const ToolFailureDetailSchema = z.object({
 // `moda workflows` lists the catalog; `moda runs` lists executions.
 const RUN_OUTCOMES = ['running', 'succeeded', 'partial', 'failed', 'loop', 'abandoned', 'unknown'];
 const TIME_RANGES = ['all', '1h', '3d', '7d', '24h', '30d', '90d'];
+const SEARCH_MODES = ['keyword', 'semantic', 'hybrid'];
+/**
+ * moda search "<query>" — keyword/semantic/hybrid search across conversation
+ * messages. `q` arrives as a positional arg; the runCommand handler rejects an
+ * empty/whitespace query before parsing, and min(1) guards the schema path too.
+ */
+export const SearchSchema = z.object({
+    q: z.string().min(1).max(500),
+    mode: z.enum(SEARCH_MODES).default('hybrid').optional(),
+    user_id: z.string().optional(),
+    time_range: z.enum(TIME_RANGES).default('all').optional(),
+    limit: z.number().min(1).max(100).default(20).optional(),
+});
 /** moda workflows — recurring workflow catalog (read from agent_job_classes). */
 export const WorkflowsSchema = z.object({
     time_range: z.enum(TIME_RANGES).default('all').optional(),

package/package.json

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