@syrin/cli 1.3.0

package/dist/events/store/memory-store.d.ts

@@ -0,0 +1,26 @@
+import type { EventEnvelope } from '../../events/types.js';
+import type { EventStore } from '../../events/store.js';
+import type { SessionID } from '../../types/ids.js';
+/**
+ * In-memory event store implementation.
+ * Suitable for testing and development.
+ * Events are lost when the process exits.
+ */
+export declare class MemoryEventStore implements EventStore {
+    private events;
+    append(event: EventEnvelope): void;
+    load(sessionId: SessionID): EventEnvelope[];
+    /**
+     * Get all events across all sessions (useful for testing/debugging).
+     */
+    getAllEvents(): EventEnvelope[];
+    /**
+     * Clear all events (useful for testing).
+     */
+    clear(): void;
+    /**
+     * Get all session IDs that have events.
+     */
+    getSessionIds(): SessionID[];
+}
+//# sourceMappingURL=memory-store.d.ts.map

package/dist/events/store/memory-store.js

@@ -0,0 +1,39 @@
+/**
+ * In-memory event store implementation.
+ * Suitable for testing and development.
+ * Events are lost when the process exits.
+ */
+export class MemoryEventStore {
+    events = new Map();
+    append(event) {
+        const sessionEvents = this.events.get(event.session_id) || [];
+        sessionEvents.push(event);
+        this.events.set(event.session_id, sessionEvents);
+    }
+    load(sessionId) {
+        return this.events.get(sessionId) || [];
+    }
+    /**
+     * Get all events across all sessions (useful for testing/debugging).
+     */
+    getAllEvents() {
+        const allEvents = [];
+        for (const events of this.events.values()) {
+            allEvents.push(...events);
+        }
+        return allEvents.sort((a, b) => a.sequence - b.sequence);
+    }
+    /**
+     * Clear all events (useful for testing).
+     */
+    clear() {
+        this.events.clear();
+    }
+    /**
+     * Get all session IDs that have events.
+     */
+    getSessionIds() {
+        return Array.from(this.events.keys());
+    }
+}
+//# sourceMappingURL=memory-store.js.map

package/dist/events/store.d.ts

@@ -0,0 +1,11 @@
+import type { EventEnvelope } from '../events/types.js';
+import type { SessionID } from '../types/ids.js';
+/**
+ * Event store interface.
+ * Implementations can be synchronous (MemoryStore) or asynchronous (FileStore).
+ */
+export interface EventStore {
+    append(event: EventEnvelope): void | Promise<void>;
+    load(sessionId: SessionID): EventEnvelope[] | Promise<EventEnvelope[]>;
+}
+//# sourceMappingURL=store.d.ts.map

package/dist/events/store.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=store.js.map

package/dist/events/types.d.ts

@@ -0,0 +1,14 @@
+import type { SessionID, EventID, WorkflowID, PromptID, ISO8601Timestamp } from '../types/ids.js';
+import type { EventType } from './event-type.js';
+export interface EventEnvelope<TPayload = unknown> {
+    readonly event_id: EventID;
+    readonly event_type: EventType;
+    readonly session_id: SessionID;
+    readonly workflow_id: WorkflowID | null;
+    readonly prompt_id: PromptID | null;
+    readonly timestamp: ISO8601Timestamp;
+    readonly sequence: number;
+    readonly source: 'runtime';
+    readonly payload: TPayload;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/events/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * Syrin main entry point.
+ * Exports the CLI runner.
+ */
+export { run } from './cli/index.js';
+export * from './cli/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+/**
+ * Syrin main entry point.
+ * Exports the CLI runner.
+ */
+import { run } from './cli/index.js';
+import { pathToFileURL } from 'node:url';
+import { realpathSync } from 'node:fs';
+// Run CLI when this file is executed directly
+// ESM equivalent of require.main === module
+const isMainModule = (() => {
+    try {
+        if (!process.argv[1]) {
+            return false;
+        }
+        // Resolve symlinks to get the actual file path
+        // This is necessary when running via npm global bin symlinks
+        const resolvedPath = realpathSync(process.argv[1]);
+        return import.meta.url === pathToFileURL(resolvedPath).href;
+    }
+    catch {
+        return false;
+    }
+})();
+if (isMainModule) {
+    run();
+}
+export { run } from './cli/index.js';
+export * from './cli/index.js';
+//# sourceMappingURL=index.js.map

package/dist/presentation/analysis-ui.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Analysis output presentation.
+ * Handles formatting of analysis results for CLI, JSON, and CI modes.
+ */
+import type { AnalysisResult } from '../runtime/analysis/types.js';
+export interface AnalysisOutputOptions {
+    ci?: boolean;
+    json?: boolean;
+    graph?: boolean;
+}
+/**
+ * Display CLI output.
+ */
+export declare function displayCLIOutput(result: AnalysisResult, options: AnalysisOutputOptions): void;
+export declare function generateJSONOutput(result: AnalysisResult, _options: AnalysisOutputOptions): string;
+/**
+ * Display CI output (minimal).
+ */
+export declare function displayCIOutput(result: AnalysisResult, options: AnalysisOutputOptions): void;
+/**
+ * Main entry point for displaying analysis results.
+ */
+export declare function displayAnalysisResult(result: AnalysisResult, options: AnalysisOutputOptions): void;
+//# sourceMappingURL=analysis-ui.d.ts.map

package/dist/presentation/analysis-ui.js

@@ -0,0 +1,158 @@
+/**
+ * Analysis output presentation.
+ * Handles formatting of analysis results for CLI, JSON, and CI modes.
+ */
+import { log } from '../utils/logger.js';
+import { Messages } from '../constants/index.js';
+/**
+ * Format dependency graph as text.
+ */
+function formatDependencyGraph(dependencies) {
+    if (dependencies.length === 0) {
+        return 'No dependencies detected.';
+    }
+    const lines = [];
+    lines.push(`\nDependency Graph (${dependencies.length} edges):`);
+    lines.push('');
+    // Group by confidence levels
+    const highConf = dependencies.filter(d => d.confidence >= 0.8);
+    const mediumConf = dependencies.filter(d => d.confidence >= 0.6 && d.confidence < 0.8);
+    if (highConf.length > 0) {
+        lines.push('High Confidence (≥0.8):');
+        for (const dep of highConf) {
+            lines.push(`  ${dep.fromTool}.${dep.fromField} → ${dep.toTool}.${dep.toField} (${dep.confidence.toFixed(2)})`);
+        }
+        lines.push('');
+    }
+    if (mediumConf.length > 0) {
+        lines.push('Medium Confidence (0.6-0.8):');
+        for (const dep of mediumConf) {
+            lines.push(`  ${dep.fromTool}.${dep.fromField} → ${dep.toTool}.${dep.toField} (${dep.confidence.toFixed(2)})`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+/**
+ * Format diagnostic for CLI output.
+ */
+function formatDiagnostic(diagnostic) {
+    const icon = diagnostic.severity === 'error' ? '❌' : '⚠️';
+    const severity = diagnostic.severity === 'error' ? 'ERROR' : 'WARNING';
+    let message = `${icon} ${severity}: ${diagnostic.message}`;
+    if (diagnostic.tool) {
+        message += `\n   Tool: ${diagnostic.tool}`;
+    }
+    if (diagnostic.field) {
+        message += `\n   Field: ${diagnostic.field}`;
+    }
+    if (diagnostic.suggestion) {
+        message += `\n\n   Suggestion:\n   ${diagnostic.suggestion}`;
+    }
+    return message;
+}
+/**
+ * Display CLI output.
+ */
+export function displayCLIOutput(result, options) {
+    // Verdict
+    if (result.errors.length > 0) {
+        log.error(Messages.ANALYSE_VERDICT_FAIL(result.errors.length, result.warnings.length));
+    }
+    else if (result.warnings.length > 0) {
+        log.warning(Messages.ANALYSE_VERDICT_PASS_WARNINGS(result.warnings.length));
+    }
+    else {
+        log.success(Messages.ANALYSE_VERDICT_PASS);
+    }
+    log.blank();
+    // Errors
+    if (result.errors.length > 0) {
+        log.plain(Messages.ANALYSE_ERRORS_HEADER);
+        log.blank();
+        for (const error of result.errors) {
+            log.plain(formatDiagnostic(error));
+            log.blank();
+        }
+    }
+    // Warnings
+    if (result.warnings.length > 0) {
+        log.plain(Messages.ANALYSE_WARNINGS_HEADER);
+        log.blank();
+        for (const warning of result.warnings) {
+            log.plain(formatDiagnostic(warning));
+            log.blank();
+        }
+    }
+    // Graph (if requested)
+    if (options.graph) {
+        log.plain(formatDependencyGraph(result.dependencies));
+        log.blank();
+    }
+    // Summary
+    log.plain(`Analyzed ${result.toolCount} tool${result.toolCount !== 1 ? 's' : ''}.`);
+}
+export function generateJSONOutput(result, _options) {
+    const output = {
+        verdict: result.verdict,
+        toolCount: result.toolCount,
+        errors: result.errors.length,
+        warnings: result.warnings.length,
+        diagnostics: result.diagnostics.map(d => ({
+            code: d.code,
+            severity: d.severity,
+            message: d.message,
+            tool: d.tool,
+            field: d.field,
+            suggestion: d.suggestion,
+            context: d.context,
+        })),
+    };
+    // Always include dependencies in JSON output (not just when --graph is set)
+    output.dependencies = result.dependencies.map(d => ({
+        fromTool: d.fromTool,
+        fromField: d.fromField,
+        toTool: d.toTool,
+        toField: d.toField,
+        confidence: d.confidence,
+    }));
+    return JSON.stringify(output, null, 2);
+}
+/**
+ * Display CI output (minimal).
+ */
+export function displayCIOutput(result, options) {
+    // CI mode: minimal output, exit codes handled by caller
+    if (result.errors.length > 0) {
+        console.log(`✗ Analysis failed: ${result.errors.length} error(s), ${result.warnings.length} warning(s)`);
+        // Print errors only (no warnings in CI)
+        for (const error of result.errors) {
+            console.log(`${error.code}: ${error.message}`);
+        }
+    }
+    else {
+        console.log(`✓ Analysis passed: ${result.toolCount} tool(s) analyzed`);
+        if (result.warnings.length > 0) {
+            console.log(`  ${result.warnings.length} warning(s) (non-blocking)`);
+        }
+    }
+    // Show graph if requested
+    if (options.graph) {
+        console.log(formatDependencyGraph(result.dependencies));
+    }
+}
+/**
+ * Main entry point for displaying analysis results.
+ */
+export function displayAnalysisResult(result, options) {
+    if (options.json) {
+        console.log(generateJSONOutput(result, options));
+        return;
+    }
+    if (options.ci) {
+        displayCIOutput(result, options);
+        return;
+    }
+    displayCLIOutput(result, options);
+}
+//# sourceMappingURL=analysis-ui.js.map

package/dist/presentation/dev/chat-ui-types.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Type definitions for Chat UI components.
+ */
+export interface ChatMessage {
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+    timestamp?: Date;
+    largeData?: {
+        type: 'json';
+        rawData: string;
+        size: number;
+        summary?: string;
+    };
+}
+export interface WelcomeBannerInfo {
+    versionDisplay: string;
+    llmProvider: string;
+    toolCount: number;
+    transport: string;
+    mcpUrl?: string;
+    command?: string;
+}
+export interface ChatUIOptions {
+    /** Agent name for the prompt */
+    agentName?: string;
+    /** LLM provider name (e.g., "OpenAI", "Claude", "Ollama") */
+    llmProviderName?: string;
+    /** Whether to show timestamps in messages */
+    showTimestamps?: boolean;
+    /** Initial messages to display */
+    initialMessages?: Array<{
+        role: 'user' | 'assistant' | 'system';
+        content: string;
+    }>;
+    /** Welcome banner information (persistent, not cleared by /clear) */
+    welcomeBanner?: WelcomeBannerInfo;
+    /** Callback when user submits a message */
+    onMessage?: (message: string) => Promise<void>;
+    /** Callback when user exits */
+    onExit?: () => Promise<void>;
+    /** Callback to get session state for goodbye messages */
+    getSessionState?: () => {
+        totalToolCalls: number;
+        toolCalls: Array<{
+            name: string;
+            timestamp: Date;
+        }>;
+        startTime: Date;
+    };
+    /** LLM provider for generating goodbye messages */
+    llmProvider?: {
+        chat: (request: {
+            messages: Array<{
+                role: string;
+                content: string;
+            }>;
+            temperature?: number;
+            maxTokens?: number;
+        }) => Promise<{
+            content: string;
+        }>;
+    } | null;
+    /** History file path for persisting command history */
+    historyFile?: string;
+    /** Maximum number of history entries to keep */
+    maxHistorySize?: number;
+}
+//# sourceMappingURL=chat-ui-types.d.ts.map

package/dist/presentation/dev/chat-ui-types.js

@@ -0,0 +1,5 @@
+/**
+ * Type definitions for Chat UI components.
+ */
+export {};
+//# sourceMappingURL=chat-ui-types.js.map

package/dist/presentation/dev/chat-ui.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Chat UI for Dev Mode using Ink (React for terminal UIs).
+ * Provides a ChatGPT-like terminal interface with message history and input panel.
+ *
+ * Note: React and Ink are dynamically imported to avoid ESM/CommonJS issues.
+ * The component is created inline using React.createElement to avoid separate module imports.
+ *
+ * ESLint warnings for dynamic imports and React.createElement are disabled as they are
+ * necessary for this approach to work with ESM modules in a CommonJS context.
+ */
+import type { ChatMessage, ChatUIOptions } from './chat-ui-types.js';
+export type { ChatMessage, ChatUIOptions } from './chat-ui-types.js';
+export declare class ChatUI {
+    private options;
+    private instance;
+    private addMessageRef;
+    private updateLastAssistantMessageRef;
+    private updateLastSystemMessageRef;
+    private getMessagesRef;
+    private clearMessagesRef;
+    private getLastLargeDataMessageRef;
+    constructor(options: ChatUIOptions);
+    start(): Promise<void>;
+    /**
+     * Add a message to the chat.
+     */
+    addMessage(role: 'user' | 'assistant' | 'system', content: string): void;
+    /**
+     * Add a message with large data reference.
+     */
+    addMessageWithData(role: 'user' | 'assistant' | 'system', content: string, largeData: ChatMessage['largeData']): void;
+    /**
+     * Get the last message with large data.
+     */
+    getLastLargeDataMessage(): ChatMessage | null;
+    /**
+     * Update the last assistant message (for streaming).
+     */
+    updateLastAssistantMessage(content: string): void;
+    /**
+     * Update the last system message (for live updates like waiting indicators).
+     */
+    updateLastSystemMessage(content: string): void;
+    /**
+     * Get all messages.
+     */
+    getMessages(): ChatMessage[];
+    /**
+     * Clear all messages.
+     */
+    clearMessages(): void;
+    /**
+     * Stop the chat UI (same as exit).
+     */
+    stop(): void;
+    /**
+     * Exit the chat UI.
+     */
+    exit(): void;
+}
+//# sourceMappingURL=chat-ui.d.ts.map