@moda-ai/cli 1.1.0 → 1.2.0

package/dist/prompts.js

@@ -0,0 +1,368 @@
+import { execFileSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, writeFileSync, } from 'node:fs';
+import { dirname, isAbsolute, join, relative, resolve } from 'node:path';
+import { callControlAPI } from './api-client.js';
+const MODA_DIR = '.moda';
+const MANIFEST_PATH = join(MODA_DIR, 'prompts.yml');
+const LOCK_PATH = join(MODA_DIR, 'prompts.lock.json');
+const DEFAULT_PROMPT_PATHS = [
+    'prompts/**/*.prompt.md',
+    'prompts/**/*.prompt.json',
+    'prompts/**/*.prompt.yaml',
+    'prompts/**/*.prompt.yml',
+];
+export async function runPromptsCommand(positionals, flags, profileOptions = { profile: flags.profile }) {
+    const subcommand = positionals[0] || 'status';
+    switch (subcommand) {
+        case 'init':
+            await initPrompts();
+            break;
+        case 'status':
+            printJson(await getPromptStatus());
+            break;
+        case 'diff':
+            printJson(await getPromptStatus());
+            break;
+        case 'sync':
+            await syncPrompts(flags, profileOptions);
+            break;
+        case 'promote':
+            await promotePrompt(positionals, flags, profileOptions);
+            break;
+        default:
+            throw new Error(`Unknown prompts command '${subcommand}'. Use init, status, diff, sync, or promote.`);
+    }
+}
+export async function initPrompts(options = {}) {
+    mkdirSync(MODA_DIR, { recursive: true });
+    if (!existsSync(MANIFEST_PATH)) {
+        writeFileSync(MANIFEST_PATH, [
+            'version: 1',
+            'prompt_paths:',
+            ...DEFAULT_PROMPT_PATHS.map((path) => `  - "${path}"`),
+            '',
+        ].join('\n'));
+    }
+    if (!options.silent) {
+        printJson({
+            manifest: MANIFEST_PATH,
+            lockfile: LOCK_PATH,
+            promptPaths: readManifest().promptPaths,
+        });
+    }
+}
+async function syncPrompts(flags, profileOptions) {
+    if (flags.watch === 'true') {
+        await watchPromptSync(flags, profileOptions);
+        return;
+    }
+    await syncPromptsOnce(flags, profileOptions);
+}
+async function syncPromptsOnce(flags, profileOptions) {
+    await initPrompts({ silent: true });
+    const prompts = discoverPrompts();
+    const sourceCommit = getGitCommit();
+    const manifestHash = hashFile(MANIFEST_PATH);
+    const dryRun = flags['dry-run'] === 'true';
+    const response = await callControlAPI('/prompts/sync', {
+        method: 'POST',
+        body: JSON.stringify({
+            prompts: prompts.map((prompt) => ({
+                ...prompt,
+                sourceCommit,
+                manifestHash,
+            })),
+            sourceCommit,
+            manifestHash,
+            dryRun,
+        }),
+    }, profileOptions);
+    if (!dryRun) {
+        writeLock(prompts, response.synced ?? []);
+    }
+    printJson({
+        synced: response.synced ?? [],
+        lockfile: dryRun ? undefined : LOCK_PATH,
+    });
+}
+async function watchPromptSync(flags, profileOptions) {
+    console.error('Watching prompt files. Press Ctrl+C to stop.');
+    let lastSignature = '';
+    const intervalMs = Math.max(1000, Number(flags.interval ?? 2500));
+    while (true) {
+        const status = await getPromptStatus();
+        const signature = stableJson(status.prompts);
+        if (signature !== lastSignature) {
+            lastSignature = signature;
+            if (status.changed > 0 || status.new > 0 || status.deleted > 0) {
+                await syncPromptsOnce({ ...flags, watch: 'false' }, profileOptions);
+            }
+        }
+        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+}
+async function promotePrompt(positionals, flags, profileOptions) {
+    const key = positionals[1];
+    const label = flags.label;
+    const versionId = flags.version || flags['version-id'];
+    if (!key)
+        throw new Error('Usage: moda prompts promote <prompt_key> --label=prod --version=<version_id>');
+    if (!label)
+        throw new Error('Missing required flag: --label=dev|staging|prod');
+    if (!versionId)
+        throw new Error('Missing required flag: --version=<version_id>');
+    const response = await callControlAPI(`/prompts/${encodeURIComponent(key)}/labels`, {
+        method: 'POST',
+        body: JSON.stringify({ label, versionId }),
+    }, profileOptions);
+    printJson(response);
+}
+async function getPromptStatus() {
+    await initPrompts({ silent: true });
+    const prompts = discoverPrompts();
+    const lock = readLock();
+    const rows = prompts.map((prompt) => {
+        const locked = lock?.prompts[prompt.key];
+        const state = !locked
+            ? 'new'
+            : locked.contentHash === prompt.contentHash
+                ? 'unchanged'
+                : 'changed';
+        return {
+            key: prompt.key,
+            sourcePath: prompt.sourcePath,
+            contentHash: prompt.contentHash,
+            lockedHash: locked?.contentHash ?? null,
+            versionId: locked?.versionId ?? null,
+            state,
+        };
+    });
+    const discoveredKeys = new Set(prompts.map((prompt) => prompt.key));
+    for (const [key, locked] of Object.entries(lock?.prompts ?? {})) {
+        if (!discoveredKeys.has(key)) {
+            rows.push({
+                key,
+                sourcePath: locked.sourcePath,
+                contentHash: null,
+                lockedHash: locked.contentHash,
+                versionId: locked.versionId ?? null,
+                state: 'deleted',
+            });
+        }
+    }
+    return {
+        manifest: MANIFEST_PATH,
+        lockfile: LOCK_PATH,
+        total: rows.length,
+        changed: rows.filter((row) => row.state === 'changed').length,
+        new: rows.filter((row) => row.state === 'new').length,
+        deleted: rows.filter((row) => row.state === 'deleted').length,
+        prompts: rows,
+    };
+}
+function discoverPrompts() {
+    const manifest = readManifest();
+    // A pattern like `src/prompts/**/*.prompt.md` should *only* match files under
+    // src/prompts. Extract both the base directory (everything up to the first
+    // glob segment) and the file suffix so we can scope `walk()` accordingly.
+    const rules = manifest.promptPaths
+        .map((pattern) => {
+        const suffixMatch = pattern.match(/\.prompt\.(md|json|ya?ml)$/i);
+        if (!suffixMatch)
+            return null;
+        const suffix = `.prompt.${suffixMatch[1]}`;
+        const globIndex = pattern.search(/[*?[]/);
+        const baseRaw = globIndex === -1 ? dirname(pattern) : pattern.slice(0, globIndex);
+        const base = baseRaw.replace(/[\\/]+$/, '') || '.';
+        const baseAbs = isAbsolute(base) ? base : resolve(process.cwd(), base);
+        return { baseAbs, suffix };
+    })
+        .filter((rule) => Boolean(rule));
+    const effectiveRules = rules.length
+        ? rules
+        : [
+            { baseAbs: process.cwd(), suffix: '.prompt.md' },
+            { baseAbs: process.cwd(), suffix: '.prompt.json' },
+        ];
+    const discovered = new Set();
+    for (const { baseAbs, suffix } of effectiveRules) {
+        if (!existsSync(baseAbs))
+            continue;
+        for (const file of walk(baseAbs)) {
+            if (file.endsWith(suffix))
+                discovered.add(file);
+        }
+    }
+    return [...discovered].sort().map(parsePromptFile);
+}
+function parsePromptFile(absPath) {
+    const sourcePath = relative(process.cwd(), absPath);
+    const raw = readFileSync(absPath, 'utf8');
+    if (absPath.endsWith('.json')) {
+        const parsed = JSON.parse(raw);
+        const key = parsed.key || keyFromPath(sourcePath);
+        const content = parsed.content || JSON.stringify(parsed.messages ?? [], null, 2);
+        return normalizePrompt({ ...parsed, key, name: parsed.name || key, sourcePath, content });
+    }
+    const { frontmatter, body } = parseFrontmatter(raw);
+    const key = frontmatter.key || keyFromPath(sourcePath);
+    return normalizePrompt({
+        key,
+        name: frontmatter.name || key,
+        description: frontmatter.description,
+        category: frontmatter.category,
+        systemPrompt: frontmatter.system_prompt || frontmatter.systemPrompt,
+        modelConfig: frontmatter.model ? { model: frontmatter.model } : undefined,
+        sourcePath,
+        content: body.trim(),
+    });
+}
+function normalizePrompt(prompt) {
+    const normalized = stableJson({
+        key: prompt.key,
+        content: prompt.content,
+        systemPrompt: prompt.systemPrompt ?? null,
+        messages: prompt.messages ?? [],
+        variables: prompt.variables ?? [],
+        variablesSchema: prompt.variablesSchema ?? {},
+        modelConfig: prompt.modelConfig ?? {},
+        toolRefs: prompt.toolRefs ?? [],
+        responseSchema: prompt.responseSchema ?? null,
+    });
+    return {
+        key: prompt.key,
+        name: prompt.name || prompt.key,
+        description: prompt.description,
+        sourcePath: prompt.sourcePath,
+        content: prompt.content,
+        systemPrompt: prompt.systemPrompt,
+        messages: prompt.messages,
+        variables: prompt.variables,
+        variablesSchema: prompt.variablesSchema,
+        modelConfig: prompt.modelConfig,
+        toolRefs: prompt.toolRefs,
+        responseSchema: prompt.responseSchema,
+        contentHash: sha256(normalized),
+    };
+}
+function readManifest() {
+    if (!existsSync(MANIFEST_PATH)) {
+        return { promptPaths: DEFAULT_PROMPT_PATHS };
+    }
+    const text = readFileSync(MANIFEST_PATH, 'utf8');
+    const promptPaths = [...text.matchAll(/^\s*-\s*["']?([^"'\n]+)["']?\s*$/gm)]
+        .map((match) => match[1])
+        .filter((path) => path.includes('.prompt.'));
+    return { promptPaths: promptPaths.length ? promptPaths : DEFAULT_PROMPT_PATHS };
+}
+function readLock() {
+    if (!existsSync(LOCK_PATH))
+        return null;
+    return JSON.parse(readFileSync(LOCK_PATH, 'utf8'));
+}
+function writeLock(prompts, synced) {
+    const syncedByKey = new Map(synced.map((item) => [item.key, item]));
+    const lock = {
+        version: 1,
+        generatedAt: new Date().toISOString(),
+        prompts: Object.fromEntries(prompts.map((prompt) => {
+            const result = syncedByKey.get(prompt.key);
+            return [prompt.key, {
+                    key: prompt.key,
+                    sourcePath: prompt.sourcePath,
+                    contentHash: prompt.contentHash,
+                    promptId: result?.promptId,
+                    versionId: result?.versionId,
+                }];
+        })),
+    };
+    mkdirSync(dirname(LOCK_PATH), { recursive: true });
+    writeFileSync(LOCK_PATH, `${JSON.stringify(lock, null, 2)}\n`);
+}
+function walk(dir) {
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    const files = [];
+    for (const entry of entries) {
+        if (entry === 'node_modules' || entry === '.git' || entry === 'dist' || entry === 'build')
+            continue;
+        const fullPath = join(dir, entry);
+        // lstatSync — never follow symlinks. A symlink in the tree could otherwise
+        // (a) loop into an ancestor and recurse forever, or (b) silently point at a
+        // sensitive file like .env that would then get uploaded as prompt content.
+        let stat;
+        try {
+            stat = lstatSync(fullPath);
+        }
+        catch {
+            continue;
+        }
+        if (stat.isSymbolicLink())
+            continue;
+        if (stat.isDirectory())
+            files.push(...walk(fullPath));
+        else if (stat.isFile())
+            files.push(fullPath);
+    }
+    return files;
+}
+function parseFrontmatter(raw) {
+    if (!raw.startsWith('---'))
+        return { frontmatter: {}, body: raw };
+    const end = raw.indexOf('\n---', 3);
+    if (end === -1)
+        return { frontmatter: {}, body: raw };
+    const frontmatterText = raw.slice(3, end).trim();
+    const frontmatter = Object.fromEntries(frontmatterText
+        .split('\n')
+        .map((line) => line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/))
+        .filter((match) => Boolean(match))
+        .map((match) => [match[1], match[2].replace(/^["']|["']$/g, '')]));
+    return { frontmatter, body: raw.slice(end + 4) };
+}
+function keyFromPath(path) {
+    return path
+        .replace(/^prompts\//, '')
+        .replace(/\.prompt\.(md|json|ya?ml)$/i, '')
+        .replace(/[\\/]/g, '.');
+}
+function hashFile(path) {
+    return existsSync(path) ? sha256(readFileSync(path, 'utf8')) : '';
+}
+function getGitCommit() {
+    try {
+        return execFileSync('git', ['rev-parse', 'HEAD'], {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
+    }
+    catch {
+        return undefined;
+    }
+}
+function stableJson(value) {
+    return JSON.stringify(sortJson(value));
+}
+function sortJson(value) {
+    if (Array.isArray(value))
+        return value.map(sortJson);
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([key, item]) => [key, sortJson(item)]));
+    }
+    return value;
+}
+function sha256(input) {
+    return createHash('sha256').update(input).digest('hex');
+}
+function printJson(value) {
+    console.log(JSON.stringify(value, null, 2));
+}
+//# sourceMappingURL=prompts.js.map

package/dist/schemas.d.ts

@@ -39,20 +39,20 @@ export declare const ConversationsSchema: z.ZodObject<{
     offset: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
 }, "strip", z.ZodTypeAny, {
     search?: string | undefined;
+    environment?: "staging" | "all" | "development" | "production" | undefined;
     time_range?: "all" | "1h" | "3d" | "7d" | "24h" | "30d" | "90d" | undefined;
     limit?: number | undefined;
     offset?: number | undefined;
     cluster_id?: string | undefined;
     user_id?: string | undefined;
-    environment?: "all" | "development" | "staging" | "production" | undefined;
 }, {
     search?: string | undefined;
+    environment?: "staging" | "all" | "development" | "production" | undefined;
     time_range?: "all" | "1h" | "3d" | "7d" | "24h" | "30d" | "90d" | undefined;
     limit?: number | undefined;
     offset?: number | undefined;
     cluster_id?: string | undefined;
     user_id?: string | undefined;
-    environment?: "all" | "development" | "staging" | "production" | undefined;
 }>;
 export declare const ContextSchema: z.ZodObject<{
     conversation_id: z.ZodString;
@@ -143,14 +143,14 @@ export declare const RunsSchema: z.ZodObject<{
     limit?: number | undefined;
     offset?: number | undefined;
     user_id?: string | undefined;
-    outcome?: "running" | "succeeded" | "partial" | "failed" | "loop" | "abandoned" | "unknown" | undefined;
+    outcome?: "unknown" | "running" | "failed" | "succeeded" | "partial" | "loop" | "abandoned" | undefined;
     class_id?: string | undefined;
 }, {
     time_range?: "all" | "1h" | "3d" | "7d" | "24h" | "30d" | "90d" | undefined;
     limit?: number | undefined;
     offset?: number | undefined;
     user_id?: string | undefined;
-    outcome?: "running" | "succeeded" | "partial" | "failed" | "loop" | "abandoned" | "unknown" | undefined;
+    outcome?: "unknown" | "running" | "failed" | "succeeded" | "partial" | "loop" | "abandoned" | undefined;
     class_id?: string | undefined;
 }>;
 /** moda run <runId> — single execution detail with side-effect receipts. */

package/dist/skills.d.ts

@@ -0,0 +1,25 @@
+import type { ParsedArgs } from './cli.js';
+interface PullSummary {
+    total: number;
+    pruned: number;
+    wrote: number;
+    updated: number;
+    unchanged: number;
+    failed: number;
+}
+/**
+ * Pull generated skills into the detected coding agents' skill directories.
+ * Exported so `moda init` can run it as a setup step. Best-effort and quiet on
+ * an empty store; never throws for "no skills yet".
+ */
+export declare function pullSkills(options?: {
+    status?: string;
+    cwd?: string;
+    silent?: boolean;
+}): Promise<PullSummary>;
+/**
+ * `moda skills <subcommand>` dispatcher.
+ */
+export declare function runSkillsCommand(args: ParsedArgs): Promise<number>;
+export {};
+//# sourceMappingURL=skills.d.ts.map