@moda-ai/cli 1.6.0 → 1.8.0

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, 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,7 @@ Commands:
   clusters                         Browse topic cluster hierarchy
   cluster-conversations <node_id>  List conversations in a cluster
   conversations                    Search and filter conversations
+  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 +184,18 @@ 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)
+
+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)
@@ -198,6 +211,8 @@ Init flags:
   --no-sdk-integrate               Skip SDK integration (alias: --no-sdk-guide)
   --ci-cd                          Create GitHub Actions Moda validation workflow
   --no-ci-cd                       Skip CI/CD workflow creation
+  --autosync                       Create GitHub Actions workflow to sync prompts + skills to Moda on push to main
+  --no-autosync                    Skip autosync workflow creation
   --offline                        Run final validation offline (skip the online telemetry check)
 
 Examples:
@@ -228,9 +243,13 @@ Examples:
   moda harness scan --json
   moda harness explain --agent=agent_support
   moda init --ci-cd
+  moda init --autosync
   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 world-state <conversation_id> --summary-only
   moda frustrations --days-back=14 --limit=20
   moda context <conversation_id> --window=3
   moda workflows --time-range=7d
@@ -289,6 +308,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': {
@@ -354,12 +392,42 @@ 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 '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;
         }
@@ -581,7 +649,7 @@ export const commandRegistry = createCommandRegistry([
     {
         name: 'init',
         description: 'Set up Moda in your project',
-        examples: ['moda init', 'moda init --sdk-integrate', 'moda init --ci-cd'],
+        examples: ['moda init', 'moda init --sdk-integrate', 'moda init --ci-cd', 'moda init --autosync'],
         auth: 'none',
         outputModes: ['human', 'json', 'agent'],
         mutability: 'write',
@@ -781,7 +849,20 @@ 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: '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/init/index.d.ts

@@ -11,7 +11,7 @@ export interface InitPhaseResult {
     details?: string;
 }
 export interface InitSetupAction {
-    category: 'sdk' | 'harness' | 'hooks' | 'prompts' | 'skills' | 'ci-cd' | 'validation';
+    category: 'sdk' | 'harness' | 'hooks' | 'prompts' | 'skills' | 'ci-cd' | 'autosync' | 'validation';
     title: string;
     status: 'planned' | 'applied' | 'skipped' | 'manual';
     approved: boolean;

package/dist/init/index.js

@@ -13,6 +13,7 @@ import { runSkillSync } from '../skills.js';
 import { SDK_GUIDE_PATH, writeSdkIntegrationGuide } from './sdk-guide.js';
 import { runSdkIntegration } from './sdk-integration.js';
 import { createCommandContext } from '../command-context.js';
+import { VERSION } from '../config.js';
 import { CliInputError } from '../errors.js';
 import { runHarnessCommand } from '../harness.js';
 import { buildDoctorReport } from '../doctor.js';
@@ -136,6 +137,7 @@ export async function runInit(flags, options = {}) {
         installHooks: false,
         integrateSdk: await shouldIntegrateSdk(flags, yes),
         configureCiCd: await shouldConfigureCiCd(flags, yes),
+        configureAutosync: await shouldConfigureAutosync(flags, yes),
     });
     log(renderInitSetupPlan(setupPlan));
     emit('plan', 'Setup plan ready.', 'completed');
@@ -235,6 +237,12 @@ export async function runInit(flags, options = {}) {
         log(renderInitNote(`Wrote ${workflowPath}`));
         markApplied(setupPlan, 'ci-cd');
     }
+    const configureAutosync = setupPlan.find((action) => action.category === 'autosync')?.approved === true;
+    if (configureAutosync) {
+        const workflowPath = writeAutosyncWorkflow();
+        log(renderInitNote(`Wrote ${workflowPath}`));
+        markApplied(setupPlan, 'autosync');
+    }
     log(renderInitNote('Reusing approved Step 4 harness report; no second analyst run needed'));
     markApplied(setupPlan, 'harness');
     markApplied(setupPlan, 'hooks', ingestCodingAgentTraces ? undefined : 'Coding-agent trace capture is temporarily unavailable.');
@@ -337,6 +345,15 @@ function buildSetupPlan(options) {
             command: 'moda doctor --online --json',
             reason: options.configureCiCd ? undefined : 'No CI/CD files are changed until a project-specific plan is approved.',
         },
+        {
+            category: 'autosync',
+            title: 'Autosync prompts and skills to Moda on push to main',
+            status: options.configureAutosync ? 'planned' : 'manual',
+            approved: options.configureAutosync,
+            files: ['.github/workflows/moda-autosync.yml'],
+            command: 'moda prompts sync && moda skills sync',
+            reason: options.configureAutosync ? undefined : 'No autosync workflow is written until it is explicitly approved (--autosync).',
+        },
         {
             category: 'validation',
             title: 'Run Moda doctor online to confirm telemetry is reaching Moda',
@@ -364,6 +381,13 @@ function changedFiles(setupPlan) {
             .filter((action) => action.status === 'applied')
             .flatMap((action) => action.files))].filter((file) => !file.includes('.env'));
 }
+// The CLI version generated workflows pin to. Pinning (rather than `@latest`,
+// which resolves at CI run time) keeps a future compromised `@moda-ai/cli`
+// publish from silently executing in adopters' CI with their MODA_API_KEY /
+// MODA_TENANT_ID present — especially important for autosync, which *writes* to
+// the Moda registry. The pin tracks the CLI that generated the file, so each
+// `moda init` upgrade is an explicit, reviewable bump of the workflow.
+const GENERATED_WORKFLOW_CLI = `@moda-ai/cli@${VERSION}`;
 function writeCiCdWorkflow(cwd = process.cwd()) {
     const relativePath = '.github/workflows/moda-validation.yml';
     const path = join(cwd, relativePath);
@@ -376,6 +400,11 @@ function writeCiCdWorkflow(cwd = process.cwd()) {
         '  push:',
         '    branches: [main]',
         '',
+        '# Least privilege: these jobs only read the checked-out repo and talk to',
+        '# Moda over the API key; they never write back to the repository.',
+        'permissions:',
+        '  contents: read',
+        '',
         'jobs:',
         '  moda-doctor:',
         '    runs-on: ubuntu-latest',
@@ -388,7 +417,51 @@ function writeCiCdWorkflow(cwd = process.cwd()) {
         '        with:',
         '          node-version: 22',
         '      - name: Validate Moda setup',
-        '        run: npx -y @moda-ai/cli@latest moda doctor --online --json',
+        `        run: npx -y ${GENERATED_WORKFLOW_CLI} moda doctor --online --json`,
+        '',
+    ].join('\n')}`);
+    return relativePath;
+}
+// Generates a push-to-main autosync workflow that keeps the Moda registry in
+// sync with the repo: it pushes prompt and skill changes after they merge. It
+// only runs on `main` (never on pull_request) so unmerged versions are never
+// published. Keep its env in step with writeCiCdWorkflow().
+function writeAutosyncWorkflow(cwd = process.cwd()) {
+    const relativePath = '.github/workflows/moda-autosync.yml';
+    const path = join(cwd, relativePath);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${[
+        'name: Moda Autosync',
+        '',
+        'on:',
+        '  push:',
+        '    branches: [main]',
+        '',
+        '# Least privilege: this job only reads the checked-out repo and writes to',
+        '# Moda over the API key; it never writes back to the repository.',
+        'permissions:',
+        '  contents: read',
+        '',
+        '# A single in-flight sync at a time; newer pushes supersede older runs.',
+        'concurrency:',
+        '  group: moda-autosync',
+        '  cancel-in-progress: true',
+        '',
+        'jobs:',
+        '  moda-sync:',
+        '    runs-on: ubuntu-latest',
+        '    env:',
+        '      MODA_API_KEY: ${{ secrets.MODA_API_KEY }}',
+        '      MODA_TENANT_ID: ${{ secrets.MODA_TENANT_ID }}',
+        '    steps:',
+        '      - uses: actions/checkout@v4',
+        '      - uses: actions/setup-node@v4',
+        '        with:',
+        '          node-version: 22',
+        `      - name: Sync prompts to Moda`,
+        `        run: npx -y ${GENERATED_WORKFLOW_CLI} moda prompts sync`,
+        `      - name: Sync skills to Moda`,
+        `        run: npx -y ${GENERATED_WORKFLOW_CLI} moda skills sync`,
         '',
     ].join('\n')}`);
     return relativePath;
@@ -451,6 +524,19 @@ async function shouldConfigureCiCd(flags, yes) {
         default: false,
     });
 }
+async function shouldConfigureAutosync(flags, yes) {
+    const explicit = parseOptionalBoolean(flagValue(flags, 'autosync', 'auto-sync', 'auto_sync'));
+    if (explicit !== undefined)
+        return explicit;
+    if (isTruthyFlag(flagValue(flags, 'no-autosync', 'no_autosync', 'no-auto-sync', 'no_auto_sync')))
+        return false;
+    if (yes)
+        return false;
+    return confirm({
+        message: 'Create a GitHub Actions workflow to autosync prompts and skills to Moda on push to main?',
+        default: false,
+    });
+}
 async function shouldIntegrateSdk(flags, yes) {
     const explicit = parseOptionalBoolean(flagValue(flags, 'sdk-integrate', 'sdk_integrate', 'sdk-guide', 'sdk_guide', 'sdk'));
     if (explicit !== undefined)

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;

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(),

package/package.json

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