@tenex-chat/backend 0.9.5 → 0.9.6

package/src/daemon/ProjectRuntime.ts

@@ -301,26 +301,23 @@ export class ProjectRuntime {
 
         // Stop status publisher
         if (this.statusPublisher) {
-            process.stdout.write(chalk.gray("   Stopping status publisher..."));
+            logger.info(`[ProjectRuntime] Stopping status publisher: ${this.projectId}`);
             await this.statusPublisher.stopPublishing();
             this.statusPublisher = null;
-            console.log(chalk.gray(" done"));
         }
 
         // Stop operations status publisher
         if (this.operationsStatusPublisher) {
-            process.stdout.write(chalk.gray("   Stopping operations status..."));
+            logger.info(`[ProjectRuntime] Stopping operations status: ${this.projectId}`);
             this.operationsStatusPublisher.stop();
             this.operationsStatusPublisher = null;
-            console.log(chalk.gray(" done"));
         }
 
         // Cleanup event handler
         if (this.eventHandler) {
-            process.stdout.write(chalk.gray("   Cleaning up event handler..."));
+            logger.info(`[ProjectRuntime] Cleaning up event handler: ${this.projectId}`);
             await this.eventHandler.cleanup();
             this.eventHandler = null;
-            console.log(chalk.gray(" done"));
         }
 
         // Shutdown MCP subscription service
@@ -332,20 +329,17 @@ export class ProjectRuntime {
         }
 
         // Save conversation state
-        process.stdout.write(chalk.gray("   Saving conversations..."));
+        logger.info(`[ProjectRuntime] Saving conversations: ${this.projectId}`);
         await ConversationStore.cleanup();
-        console.log(chalk.gray(" done"));
 
         // Reset local report store
-        process.stdout.write(chalk.gray("   Resetting report store..."));
+        logger.info(`[ProjectRuntime] Resetting report store: ${this.projectId}`);
         this.localReportStore.reset();
-        console.log(chalk.gray(" done"));
 
         // Release our reference to the prefix KV store (but don't close it -
         // it's a daemon-global resource that outlives individual project runtimes)
-        process.stdout.write(chalk.gray("   Releasing storage..."));
+        logger.info(`[ProjectRuntime] Releasing storage: ${this.projectId}`);
         await prefixKVStore.close();
-        console.log(chalk.gray(" done"));
 
         // Clear context
         this.context = null;

package/src/daemon/SubscriptionManager.ts

@@ -288,6 +288,19 @@ export class SubscriptionManager {
                 eventId: event.id,
                 eventKind: event.kind,
             });
+            logger.writeToWarnLog({
+                timestamp: new Date().toISOString(),
+                level: "error",
+                component: "SubscriptionManager",
+                message: "Error handling incoming Nostr event",
+                context: {
+                    eventId: event.id,
+                    eventKind: event.kind,
+                    pubkey: event.pubkey,
+                },
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
         }
     }
 

package/src/daemon/index.ts

@@ -6,4 +6,3 @@
  */
 
 export { getDaemon } from "./Daemon";
-export { UnixSocketTransport } from "./UnixSocketTransport";

package/src/event-handler/index.ts

@@ -57,6 +57,7 @@ const IGNORED_EVENT_KINDS = [
     NDKKind.Contacts,
     NDKKind.TenexProjectStatus,
     NDKKind.TenexOperationsStatus,
+    NDKKind.TenexStreamTextDelta,
 ];
 
 export class EventHandler {

package/src/index.ts

@@ -8,6 +8,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { fileURLToPath } from "node:url";
 import { initializeTelemetry } from "@/telemetry/setup";
 
 /**
@@ -25,6 +26,24 @@ interface TelemetryConfig {
     endpoint: string;
 }
 
+function getCliVersion(): string {
+    if (process.env.npm_package_version) {
+        return process.env.npm_package_version;
+    }
+
+    try {
+        const packageJsonPath = fileURLToPath(new URL("../package.json", import.meta.url));
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+        if (typeof packageJson.version === "string" && packageJson.version.length > 0) {
+            return packageJson.version;
+        }
+    } catch {
+        // Fall through to default when package metadata is unavailable.
+    }
+
+    return "0.0.0";
+}
+
 function getTelemetryConfig(): TelemetryConfig {
     const configPath = join(getBasePath(), "config.json");
     const defaults: TelemetryConfig = {
@@ -89,7 +108,7 @@ async function main(): Promise<void> {
     program
         .name("tenex")
         .description("TENEX Command Line Interface")
-        .version(process.env.npm_package_version || "0.8.0");
+        .version(getCliVersion());
 
     // Register subcommands
     program.addCommand(daemonCommand);

package/src/llm/ChunkHandler.ts

@@ -40,7 +40,7 @@ export class ChunkHandler {
             return;
         }
 
-        // Emit raw-chunk event for consumers (e.g., local streaming)
+        // Emit raw-chunk event for low-level stream observers.
         logger.debug("[LLMService] emitting raw-chunk", { chunkType: chunk.type });
         this.emitter.emit("raw-chunk", { chunk: event.chunk });
 

package/src/llm/FinishHandler.ts

@@ -56,24 +56,32 @@ export function createFinishHandler(
             // This creates intentional duplication (conversation + completion both have same text)
             // but ensures delegated agents receive the full response via p-tag on completion.
             //
-            // Three-level fallback for finalMessage:
-            // 1. Use cachedContent if available (normal case)
-            // 2. Use e.text if cachedContent is empty AND e.text is non-empty (fallback when content was already published)
-            // 3. Use error message if both are empty (edge case where no content was captured)
+            // Multi-level fallback for finalMessage:
+            // 1. Use cachedContent if available (normal case: text is still buffered)
+            // 2. Use e.text if non-empty (text was already published via chunk-type-change,
+            //    but we still re-publish for delegations - see comment above)
+            // 3. Use accumulated steps text if non-empty (handles multi-step flows where
+            //    the final step has no text - e.g., last step processed a tool result and
+            //    stopped immediately; e.text = finalStep.text which is "" in that case,
+            //    but the real response text is in an earlier step)
+            // 4. Use error message if all sources are empty
             const ERROR_FALLBACK_MESSAGE =
                 "There was an error capturing the work done, please review the conversation for the results";
 
             const cachedContent = state.getCachedContent();
             const text = e.text ?? "";
+            const stepsText = e.steps.reduce((acc, step) => acc + step.text, "");
 
             const fallbackLevel =
                 cachedContent.length > 0 ? "cached" :
                 text.length > 0 ? "text" :
+                stepsText.length > 0 ? "steps" :
                 "error";
 
             const finalMessage =
                 fallbackLevel === "cached" ? cachedContent :
                 fallbackLevel === "text" ? text :
+                fallbackLevel === "steps" ? stepsText :
                 ERROR_FALLBACK_MESSAGE;
 
             const usedFallbackToText = fallbackLevel === "text";
@@ -108,6 +116,8 @@ export function createFinishHandler(
                 "complete.message_length": finalMessage.length,
                 "complete.cached_content_length": cachedContent.length,
                 "complete.e_text_length": text.length,
+                "complete.steps_text_length": stepsText.length,
+                "complete.fallback_level": fallbackLevel,
                 "complete.used_fallback_to_e_text": usedFallbackToText,
                 "complete.used_error_fallback": usedErrorFallback,
                 "complete.usage_input_tokens": usage.inputTokens,
@@ -173,6 +183,20 @@ export function createFinishHandler(
             logger.error("[LLMService] Error in onFinish handler", {
                 error: error instanceof Error ? error.message : String(error),
             });
+            logger.writeToWarnLog({
+                timestamp: new Date().toISOString(),
+                level: "error",
+                component: "FinishHandler",
+                message: "Error in LLM onFinish handler",
+                context: {
+                    provider: config.provider,
+                    model: config.model,
+                    finishReason: e.finishReason,
+                    stepsCount: e.steps.length,
+                },
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
             throw error;
         }
     };

package/src/llm/LLMConfigEditor.ts

@@ -1,137 +1,255 @@
 import { config } from "@/services/ConfigService";
 import type { TenexLLMs } from "@/services/config/types";
+import {
+    createPrompt,
+    useState,
+    useEffect,
+    useRef,
+    useKeypress,
+    usePrefix,
+    isEnterKey,
+    isUpKey,
+    isDownKey,
+    makeTheme,
+} from "@inquirer/core";
+import { cursorHide } from "@inquirer/ansi";
 import chalk from "chalk";
-import inquirer from "inquirer";
+import { inquirerTheme } from "@/utils/cli-theme";
+import * as display from "@/commands/setup/display";
 import { llmServiceFactory } from "./LLMServiceFactory";
 import { ConfigurationManager } from "./utils/ConfigurationManager";
 import { ConfigurationTester } from "./utils/ConfigurationTester";
+import type { TestResult } from "./utils/ConfigurationTester";
 import { ProviderConfigUI } from "./utils/ProviderConfigUI";
-import { runProviderSetup } from "./utils/provider-setup";
 
-/**
- * Internal type used by editor to work with providers
- * Merges providers with llms for internal convenience
- */
 type LLMConfigWithProviders = TenexLLMs & {
     providers: Record<string, { apiKey: string | string[] }>;
 };
 
-/**
- * LLM Configuration Editor - Simple menu orchestrator
- * Note: LLM configs are now global only (no project-level llms.json)
- */
-export class LLMConfigEditor {
-    constructor() {}
+type ListItem = { name: string; value: string; configName?: string };
+type ActionItem = { name: string; value: string; key: string };
 
-    async showMainMenu(): Promise<void> {
-        const llmsConfig = await this.loadConfig();
+type MenuConfig = {
+    message: string;
+    items: ListItem[];
+    actions: ActionItem[];
+    onTest?: (configName: string) => Promise<TestResult>;
+};
+
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+const menuTheme = {
+    icon: { cursor: inquirerTheme.icon.cursor },
+    style: {
+        highlight: inquirerTheme.style.highlight,
+    },
+};
+
+const selectWithFooter = createPrompt<string, MenuConfig>((config, done) => {
+    const { items, actions } = config;
+    const theme = makeTheme(menuTheme);
+    // items + actions + Done
+    const doneIndex = items.length + actions.length;
+    const totalNavigable = doneIndex + 1;
+
+    const [active, setActive] = useState(0);
+    const resultsRef = useRef<Record<string, TestResult>>({});
+    const [testing, setTesting] = useState<string | null>(null);
+    const [spinnerFrame, setSpinnerFrame] = useState(0);
+    const prefix = usePrefix({ status: "idle", theme });
+
+    const timerRef = useRef<ReturnType<typeof setInterval> | null>(null);
+
+    useEffect(() => {
+        if (testing && !timerRef.current) {
+            timerRef.current = setInterval(() => {
+                setSpinnerFrame(spinnerFrame + 1);
+            }, 80);
+        }
+        if (!testing && timerRef.current) {
+            clearInterval(timerRef.current);
+            timerRef.current = null;
+        }
+        return () => {
+            if (timerRef.current) {
+                clearInterval(timerRef.current);
+                timerRef.current = null;
+            }
+        };
+    }, [testing != null, spinnerFrame]);
+
+    useKeypress((key, rl) => {
+        if (testing) return;
 
-        console.log(chalk.cyan("\n=== LLM Configuration ===\n"));
-        ProviderConfigUI.displayCurrentConfig(llmsConfig);
-
-        const { action } = await inquirer.prompt([
-            {
-                type: "select",
-                name: "action",
-                message: "What would you like to do?",
-                choices: [
-                    { name: "Add new configuration", value: "add" },
-                    { name: "Create meta model", value: "addMeta" },
-                    { name: "Delete configuration", value: "delete" },
-                    {
-                        name: `Default agents' model: ${llmsConfig.default || "none"}`,
-                        value: "default",
-                    },
-                    {
-                        name: `Summarization model: ${llmsConfig.summarization || "none"}`,
-                        value: "summarization",
-                    },
-                    {
-                        name: `Supervision model: ${llmsConfig.supervision || "none"}`,
-                        value: "supervision",
-                    },
-                    {
-                        name: `Search model: ${llmsConfig.search || "none"}`,
-                        value: "search",
-                    },
-                    {
-                        name: `Prompt compilation model: ${llmsConfig.promptCompilation || "none"}`,
-                        value: "promptCompilation",
-                    },
-                    {
-                        name: `Compression model: ${llmsConfig.compression || "none"}`,
-                        value: "compression",
-                    },
-                    { name: "Test configuration", value: "test" },
-                    { name: "Exit", value: "exit" },
-                ],
-            },
-        ]);
-
-        if (action === "exit") process.exit(0);
-
-        if (action === "test") {
-            await ConfigurationTester.test(llmsConfig);
+        if (isEnterKey(key)) {
+            if (active < items.length) {
+                done(items[active]!.value);
+            } else if (active < doneIndex) {
+                done(actions[active - items.length]!.value);
+            } else {
+                done("done");
+            }
+        } else if (isUpKey(key) || isDownKey(key)) {
+            rl.clearLine(0);
+            const offset = isUpKey(key) ? -1 : 1;
+            setActive((active + offset + totalNavigable) % totalNavigable);
+        } else if (key.name === "t" && active < items.length) {
+            const item = items[active];
+            if (item?.configName && config.onTest) {
+                if (resultsRef.current[item.configName]) return;
+                setTesting(item.configName);
+                config.onTest(item.configName).then((result) => {
+                    resultsRef.current[item.configName!] = result;
+                    setTesting(null);
+                });
+            }
+        } else if (key.name === "d" && active < items.length) {
+            const configValue = items[active]?.value;
+            if (configValue?.startsWith("config:")) {
+                const configName = configValue.slice("config:".length);
+                done(`delete:${configName}`);
+            }
         } else {
-            // All other actions use ConfigurationManager
-            if (action === "add") await ConfigurationManager.add(llmsConfig);
-            if (action === "addMeta") await ConfigurationManager.addMetaModel(llmsConfig);
-            if (action === "delete") await ConfigurationManager.delete(llmsConfig);
-            if (action === "default") await ConfigurationManager.setDefault(llmsConfig);
-            if (action === "summarization") await ConfigurationManager.setSummarizationModel(llmsConfig);
-            if (action === "supervision") await ConfigurationManager.setSupervisionModel(llmsConfig);
-            if (action === "search") await ConfigurationManager.setSearchModel(llmsConfig);
-            if (action === "promptCompilation") await ConfigurationManager.setPromptCompilationModel(llmsConfig);
-            if (action === "compression") await ConfigurationManager.setCompressionModel(llmsConfig);
-            await this.saveConfig(llmsConfig);
+            const match = actions.find((a) => a.key === key.name);
+            if (match) {
+                done(match.value);
+            }
         }
+    });
 
-        await this.showMainMenu();
+    const message = theme.style.message(config.message, "idle");
+    const cursor = theme.icon.cursor;
+    const lines: string[] = [];
+
+    lines.push(`${prefix} ${message}`);
+
+    if (items.length === 0) {
+        lines.push(chalk.dim("  No configurations yet"));
+    } else {
+        for (let i = 0; i < items.length; i++) {
+            const item = items[i]!;
+            const isActive = i === active;
+            const pfx = isActive ? `${cursor} ` : "  ";
+            const color = isActive ? theme.style.highlight : (x: string) => x;
+            const name = item.configName;
+
+            if (name && testing === name) {
+                const frame = SPINNER_FRAMES[spinnerFrame % SPINNER_FRAMES.length];
+                lines.push(`${pfx}${chalk.yellow(frame)} ${color(item.name)}`);
+            } else {
+                const result = name ? resultsRef.current[name] : undefined;
+                if (result) {
+                    const icon = result.success ? chalk.green("✓") : chalk.red("✗");
+                    const errorHint = !result.success ? ` ${chalk.dim(result.error)}` : "";
+                    lines.push(`${pfx}${icon} ${color(item.name)}${errorHint}`);
+                } else {
+                    lines.push(`${pfx}  ${color(item.name)}`);
+                }
+            }
+        }
+    }
+
+    lines.push(`  ${"─".repeat(40)}`);
+
+    for (let i = 0; i < actions.length; i++) {
+        const action = actions[i]!;
+        const idx = items.length + i;
+        const isActive = active === idx;
+        const pfx = isActive ? `${cursor} ` : "  ";
+        lines.push(`${pfx}${chalk.cyan(action.name)}`);
     }
 
-    async runOnboardingFlow(): Promise<void> {
-        console.log(chalk.green("\n🚀 Welcome to TENEX LLM Setup!\n"));
+    const donePfx = active === doneIndex ? `${cursor} ` : "  ";
+    lines.push(`${donePfx}${display.doneLabel()}`);
 
+    const helpParts = [
+        `${chalk.bold("↑↓")} ${chalk.dim("navigate")}`,
+        `${chalk.bold("⏎")} ${chalk.dim("select")}`,
+        `${chalk.bold("t")} ${chalk.dim("test")}`,
+        `${chalk.bold("d")} ${chalk.dim("delete")}`,
+    ];
+    lines.push(chalk.dim(`  ${helpParts.join(chalk.dim(" • "))}`));
+
+    return `${lines.join("\n")}${cursorHide}`;
+});
+
+export class LLMConfigEditor {
+    private advanced: boolean;
+
+    constructor(options: { advanced?: boolean } = {}) {
+        this.advanced = options.advanced ?? false;
+    }
+
+    async showMainMenu(): Promise<void> {
         const llmsConfig = await this.loadConfig();
-        const globalPath = config.getGlobalPath();
 
-        // Step 1: Configure providers
-        console.log(chalk.cyan("Step 1: Configure Provider API Keys"));
-        const existingProviders = await config.loadTenexProviders(globalPath);
-        const updatedProviders = await runProviderSetup(existingProviders);
-        llmsConfig.providers = updatedProviders.providers;
-        await this.saveConfig(llmsConfig);
+        display.blank();
+        display.step(0, 0, "LLM Configuration");
+        ProviderConfigUI.displayProviders(llmsConfig);
 
-        // Step 2: Create first configuration
-        console.log(chalk.cyan("\nStep 2: Create Your First Configuration"));
-        await ConfigurationManager.add(llmsConfig, true);
-        await this.saveConfig(llmsConfig);
+        const configNames = Object.keys(llmsConfig.configurations);
+        const items: ListItem[] = configNames.map((name) => {
+            const cfg = llmsConfig.configurations[name];
+            const detail =
+                cfg.provider === "meta"
+                    ? `multi-modal, ${Object.keys((cfg as { variants: Record<string, unknown> }).variants).length} variants`
+                    : `${"model" in cfg ? cfg.model : "unknown"}`;
+            return {
+                name: `${name} ${chalk.dim(detail)}`,
+                value: `config:${name}`,
+                configName: name,
+            };
+        });
+
+        const actions: ActionItem[] = [
+            { name: `Add new configuration ${chalk.dim("(a)")}`, value: "add", key: "a" },
+            { name: `Add multi-modal configuration ${chalk.dim("(m)")}`, value: "addMultiModal", key: "m" },
+        ];
+
+        const action = await selectWithFooter({
+            message: "Configurations",
+            items,
+            actions,
+            onTest: (configName) => ConfigurationTester.runTest(llmsConfig, configName),
+        });
 
-        // Step 3: Offer to test
-        const { shouldTest } = await inquirer.prompt([
-            {
-                type: "confirm",
-                name: "shouldTest",
-                message: "Would you like to test your configuration?",
-                default: true,
-            },
-        ]);
-
-        if (shouldTest) {
-            await ConfigurationTester.test(llmsConfig);
+        if (action.startsWith("delete:")) {
+            const configName = action.slice("delete:".length);
+            await this.deleteConfig(llmsConfig, configName);
+        } else if (action === "add") {
+            await ConfigurationManager.add(llmsConfig, this.advanced);
+            await this.saveConfig(llmsConfig);
+        } else if (action === "addMultiModal") {
+            await ConfigurationManager.addMultiModal(llmsConfig);
+            await this.saveConfig(llmsConfig);
+        } else if (action === "done") {
+            return;
         }
 
-        console.log(chalk.green("\n✅ LLM configuration complete!"));
+        await this.showMainMenu();
+    }
+
+    private async deleteConfig(llmsConfig: LLMConfigWithProviders, configName: string): Promise<void> {
+        delete llmsConfig.configurations[configName];
+
+        if (llmsConfig.default === configName) {
+            const remaining = Object.keys(llmsConfig.configurations);
+            llmsConfig.default = remaining.length > 0 ? remaining[0] : undefined;
+            if (llmsConfig.default) {
+                display.hint(`Default changed to "${llmsConfig.default}"`);
+            }
+        }
+
+        display.success(`Configuration "${configName}" deleted`);
+        await this.saveConfig(llmsConfig);
     }
 
     private async loadConfig(): Promise<LLMConfigWithProviders> {
         const globalPath = config.getGlobalPath();
 
-        // Load providers and llms separately
         const providersConfig = await config.loadTenexProviders(globalPath);
         const llmsConfig = await config.loadTenexLLMs(globalPath);
 
-        // Merge for internal editor use
         return {
             ...llmsConfig,
             providers: providersConfig.providers,
@@ -139,16 +257,10 @@ export class LLMConfigEditor {
     }
 
     private async saveConfig(llmsConfig: LLMConfigWithProviders): Promise<void> {
-        // Split providers and llms for separate storage
         const { providers, ...llmsWithoutProviders } = llmsConfig;
 
-        // Save providers to providers.json
         await config.saveGlobalProviders({ providers });
-
-        // Save llms to llms.json
         await config.saveGlobalLLMs(llmsWithoutProviders as TenexLLMs);
-
-        // Re-initialize factory with updated providers
         await llmServiceFactory.initializeProviders(providers);
     }
 }

package/src/llm/index.ts

@@ -4,9 +4,5 @@ export { LLMService } from "./service";
 // Export factory
 export { LLMServiceFactory, llmServiceFactory } from "./LLMServiceFactory";
 
-// Export stream publisher
-export { StreamPublisher, streamPublisher, type StreamTransport } from "./StreamPublisher";
-export type { LocalStreamChunk } from "./types";
-
 // Export types
 export * from "./types";

package/src/llm/meta/MetaModelResolver.ts

@@ -134,8 +134,8 @@ export class MetaModelResolver {
     }
 
     /**
-     * Select the winning variant from a set of matches using tier-based resolution.
-     * Highest tier wins. If tiers are equal, first match wins.
+     * Select the winning variant from a set of matches using position-based resolution.
+     * First keyword match wins (earliest position in message).
      */
     private static selectWinningVariant(
         matches: Array<{ keyword: string; variantName: string; variant: MetaModelVariant; position: number }>
@@ -144,16 +144,7 @@ export class MetaModelResolver {
             return null;
         }
 
-        // Sort by tier (descending), then by position (ascending for first match)
-        const sorted = [...matches].sort((a, b) => {
-            const tierA = a.variant.tier ?? 0;
-            const tierB = b.variant.tier ?? 0;
-            if (tierB !== tierA) {
-                return tierB - tierA; // Higher tier wins
-            }
-            return a.position - b.position; // Earlier position wins if tiers equal
-        });
-
+        const sorted = [...matches].sort((a, b) => a.position - b.position);
         return sorted[0];
     }
 
@@ -256,7 +247,6 @@ export class MetaModelResolver {
         logger.debug("[MetaModelResolver] Resolved variant", {
             variantName: winner.variantName,
             matchedKeywords,
-            tier: winner.variant.tier ?? 0,
             configName: winner.variant.model,
         });
 
@@ -314,11 +304,6 @@ export class MetaModelResolver {
     static generateSystemPromptFragment(config: MetaModelConfiguration): string {
         const lines: string[] = [];
 
-        if (config.description) {
-            lines.push(config.description);
-            lines.push("");
-        }
-
         lines.push("You have access to the following models via change_model() tool:");
 
         for (const [variantName, variant] of Object.entries(config.variants)) {