@tenex-chat/backend 0.9.4 → 0.9.6

package/src/events/NDKProjectStatus.ts

@@ -1,384 +0,0 @@
-import { NDKKind } from "@/nostr/kinds";
-import type NDK from "@nostr-dev-kit/ndk";
-import { NDKEvent, type NDKRawEvent } from "@nostr-dev-kit/ndk";
-
-/**
- * NDKProjectStatus represents a TenexProjectStatus event
- * Used to indicate project status including online agents and model configurations
- */
-export class NDKProjectStatus extends NDKEvent {
-    static kind = NDKKind.TenexProjectStatus;
-    static kinds = [NDKKind.TenexProjectStatus];
-
-    constructor(ndk?: NDK, event?: NDKEvent | NDKRawEvent) {
-        super(ndk, event);
-        this.kind ??= NDKKind.TenexProjectStatus;
-    }
-
-    static from(event: NDKEvent): NDKProjectStatus {
-        return new NDKProjectStatus(event.ndk, event);
-    }
-
-    /**
-     * Get the project this status refers to
-     * Returns the value of the "a" tag (replaceable event reference)
-     */
-    get projectReference(): string | undefined {
-        return this.tagValue("a");
-    }
-
-    /**
-     * Set the project this status refers to
-     * @param projectTagId The tag ID of the NDKProject event (format: kind:pubkey:dTag)
-     */
-    set projectReference(projectTagId: string | undefined) {
-        this.removeTag("a");
-        if (projectTagId) {
-            this.tags.push(["a", projectTagId]);
-        }
-    }
-
-    /**
-     * Get all agent entries from this status event
-     * Returns an array of {pubkey, slug} objects
-     */
-    get agents(): Array<{ pubkey: string; slug: string }> {
-        const agentTags = this.tags.filter((tag) => tag[0] === "agent" && tag[1] && tag[2]);
-        return agentTags.map((tag) => ({
-            pubkey: tag[1],
-            slug: tag[2],
-        }));
-    }
-
-    /**
-     * Add an agent to the status
-     * @param pubkey The agent's public key
-     * @param slug The agent's slug/identifier
-     */
-    addAgent(pubkey: string, slug: string): void {
-        this.tags.push(["agent", pubkey, slug]);
-    }
-
-    /**
-     * Remove an agent from the status
-     * @param pubkey The agent's public key to remove
-     */
-    removeAgent(pubkey: string): void {
-        this.tags = this.tags.filter((tag) => !(tag[0] === "agent" && tag[1] === pubkey));
-    }
-
-    /**
-     * Clear all agents from the status
-     */
-    clearAgents(): void {
-        this.tags = this.tags.filter((tag) => tag[0] !== "agent");
-    }
-
-    /**
-     * Check if a specific agent is in the status
-     * @param pubkey The agent's public key
-     */
-    hasAgent(pubkey: string): boolean {
-        return this.tags.some((tag) => tag[0] === "agent" && tag[1] === pubkey);
-    }
-
-    /**
-     * Get all model configurations from this status event
-     * Returns an array of {modelSlug, agents} objects where agents is an array of agent slugs
-     */
-    get models(): Array<{ modelSlug: string; agents: string[] }> {
-        const modelTags = this.tags.filter((tag) => tag[0] === "model" && tag[1]);
-        return modelTags.map((tag) => ({
-            modelSlug: tag[1],
-            agents: tag.slice(2).filter((a) => a), // Get all agent slugs from index 2 onwards
-        }));
-    }
-
-    /**
-     * Add a model with its agent access list
-     * @param modelSlug The model slug identifier (e.g., "gpt-4", "claude-3")
-     * @param agentSlugs Array of agent slugs that use this model
-     */
-    addModel(modelSlug: string, agentSlugs: string[]): void {
-        // Remove existing model tag if it exists
-        this.removeModel(modelSlug);
-        // Add new model tag with all agent slugs
-        this.tags.push(["model", modelSlug, ...agentSlugs]);
-    }
-
-    /**
-     * Remove a model from the status
-     * @param modelSlug The model slug to remove
-     */
-    removeModel(modelSlug: string): void {
-        this.tags = this.tags.filter((tag) => !(tag[0] === "model" && tag[1] === modelSlug));
-    }
-
-    /**
-     * Clear all model configurations from the status
-     */
-    clearModels(): void {
-        this.tags = this.tags.filter((tag) => tag[0] !== "model");
-    }
-
-    /**
-     * Check if a specific model exists
-     * @param modelSlug The model slug
-     */
-    hasModel(modelSlug: string): boolean {
-        return this.tags.some((tag) => tag[0] === "model" && tag[1] === modelSlug);
-    }
-
-    /**
-     * Get agents that use a specific model
-     * @param modelSlug The model slug
-     * @returns Array of agent slugs that use this model
-     */
-    getModelAgents(modelSlug: string): string[] {
-        const modelTag = this.tags.find((tag) => tag[0] === "model" && tag[1] === modelSlug);
-        return modelTag ? modelTag.slice(2).filter((a) => a) : [];
-    }
-
-    /**
-     * Check if a specific agent uses a model
-     * @param modelSlug The model slug
-     * @param agentSlug The agent slug
-     */
-    agentUsesModel(modelSlug: string, agentSlug: string): boolean {
-        const agents = this.getModelAgents(modelSlug);
-        return agents.includes(agentSlug);
-    }
-
-    /**
-     * Get all models used by a specific agent
-     * @param agentSlug The agent slug
-     * @returns Array of model slugs used by this agent
-     */
-    getAgentModels(agentSlug: string): string[] {
-        return this.models
-            .filter((model) => model.agents.includes(agentSlug))
-            .map((model) => model.modelSlug);
-    }
-
-    /**
-     * Get the status message/content
-     */
-    get status(): string {
-        return this.content;
-    }
-
-    /**
-     * Set the status message/content
-     */
-    set status(value: string) {
-        this.content = value;
-    }
-
-    /**
-     * Get all tools with their agent access information
-     * Returns an array of {toolName, agents} objects where agents is an array of agent slugs
-     */
-    get tools(): Array<{ toolName: string; agents: string[] }> {
-        const toolTags = this.tags.filter((tag) => tag[0] === "tool" && tag[1]);
-        return toolTags.map((tag) => ({
-            toolName: tag[1],
-            agents: tag.slice(2).filter((a) => a), // Get all agent slugs from index 2 onwards
-        }));
-    }
-
-    /**
-     * Add a tool with its agent access list
-     * @param toolName The name of the tool
-     * @param agentSlugs Array of agent slugs that have access to this tool
-     */
-    addTool(toolName: string, agentSlugs: string[]): void {
-        // Remove existing tool tag if it exists
-        this.removeTool(toolName);
-        // Add new tool tag with all agent slugs
-        this.tags.push(["tool", toolName, ...agentSlugs]);
-    }
-
-    /**
-     * Remove a tool from the status
-     * @param toolName The tool name to remove
-     */
-    removeTool(toolName: string): void {
-        this.tags = this.tags.filter((tag) => !(tag[0] === "tool" && tag[1] === toolName));
-    }
-
-    /**
-     * Clear all tools from the status
-     */
-    clearTools(): void {
-        this.tags = this.tags.filter((tag) => tag[0] !== "tool");
-    }
-
-    /**
-     * Check if a specific tool exists
-     * @param toolName The tool name
-     */
-    hasTool(toolName: string): boolean {
-        return this.tags.some((tag) => tag[0] === "tool" && tag[1] === toolName);
-    }
-
-    /**
-     * Get agents that have access to a specific tool
-     * @param toolName The tool name
-     * @returns Array of agent slugs that have access to this tool
-     */
-    getToolAgents(toolName: string): string[] {
-        const toolTag = this.tags.find((tag) => tag[0] === "tool" && tag[1] === toolName);
-        return toolTag ? toolTag.slice(2).filter((a) => a) : [];
-    }
-
-    /**
-     * Check if a specific agent has access to a tool
-     * @param toolName The tool name
-     * @param agentSlug The agent slug
-     */
-    agentHasTool(toolName: string, agentSlug: string): boolean {
-        const agents = this.getToolAgents(toolName);
-        return agents.includes(agentSlug);
-    }
-
-    /**
-     * Get all tools accessible by a specific agent
-     * @param agentSlug The agent slug
-     * @returns Array of tool names accessible by this agent
-     */
-    getAgentTools(agentSlug: string): string[] {
-        return this.tools
-            .filter((tool) => tool.agents.includes(agentSlug))
-            .map((tool) => tool.toolName);
-    }
-
-    /**
-     * Get all worktrees from this status event
-     * Returns an array of branch names, with the first being the default branch
-     */
-    get worktrees(): string[] {
-        const worktreeTags = this.tags.filter((tag) => tag[0] === "branch" && tag[1]);
-        return worktreeTags.map((tag) => tag[1]);
-    }
-
-    /**
-     * Add a worktree to the status
-     * @param branchName The branch name
-     */
-    addWorktree(branchName: string): void {
-        this.tags.push(["branch", branchName]);
-    }
-
-    /**
-     * Get the default worktree (first worktree in the list)
-     */
-    get defaultWorktree(): string | undefined {
-        return this.worktrees[0];
-    }
-
-    // ========================================================================
-    // Scheduled Tasks
-    // ========================================================================
-
-    /**
-     * Get all scheduled tasks from this status event
-     * Tag format: ["scheduled-task", id, title, schedule, targetAgent, type, lastRunTimestamp]
-     */
-    get scheduledTasks(): Array<{
-        id: string;
-        title: string;
-        schedule: string;
-        /** Agent slug when resolvable, otherwise a truncated pubkey prefix */
-        targetAgent: string;
-        type: "cron" | "oneoff";
-        lastRun?: number;
-    }> {
-        const taskTags = this.tags.filter((tag) => tag[0] === "scheduled-task" && tag[1]);
-        return taskTags.map((tag) => {
-            const rawType = tag[5];
-            const type = rawType === "cron" || rawType === "oneoff" ? rawType : "cron";
-            const parsedLastRun = tag[6] ? Number(tag[6]) : NaN;
-            const lastRun = Number.isFinite(parsedLastRun) ? parsedLastRun : undefined;
-
-            return {
-                id: tag[1],
-                title: tag[2] || "",
-                schedule: tag[3] || "",
-                targetAgent: tag[4] || "",
-                type,
-                lastRun,
-            };
-        });
-    }
-
-    /**
-     * Add a scheduled task to the status
-     * @param id Task identifier
-     * @param title Human-readable task title
-     * @param schedule Cron expression or ISO timestamp
-     * @param targetAgent Agent slug or pubkey-prefix label for the target agent
-     * @param type Task type: "cron" or "oneoff"
-     * @param lastRun Optional last run Unix timestamp in seconds
-     */
-    addScheduledTask(
-        id: string,
-        title: string,
-        schedule: string,
-        targetAgent: string,
-        type: "cron" | "oneoff",
-        lastRun?: number
-    ): void {
-        this.tags.push([
-            "scheduled-task",
-            id,
-            title,
-            schedule,
-            targetAgent,
-            type,
-            lastRun !== undefined ? String(lastRun) : "",
-        ]);
-    }
-
-    /**
-     * Remove a scheduled task from the status
-     * @param id The task ID to remove
-     */
-    removeScheduledTask(id: string): void {
-        this.tags = this.tags.filter(
-            (tag) => !(tag[0] === "scheduled-task" && tag[1] === id)
-        );
-    }
-
-    /**
-     * Clear all scheduled tasks from the status
-     */
-    clearScheduledTasks(): void {
-        this.tags = this.tags.filter((tag) => tag[0] !== "scheduled-task");
-    }
-
-    /**
-     * Check if a specific scheduled task exists
-     * @param id The task ID
-     */
-    hasScheduledTask(id: string): boolean {
-        return this.tags.some((tag) => tag[0] === "scheduled-task" && tag[1] === id);
-    }
-
-    /**
-     * Get all scheduled tasks targeting a specific agent
-     * @param agentIdentifier The agent slug or truncated pubkey prefix
-     */
-    getScheduledTasksForAgent(agentIdentifier: string): Array<{
-        id: string;
-        title: string;
-        schedule: string;
-        /** Agent slug when resolvable, otherwise a truncated pubkey prefix */
-        targetAgent: string;
-        type: "cron" | "oneoff";
-        lastRun?: number;
-    }> {
-        return this.scheduledTasks.filter(
-            (task) => task.targetAgent === agentIdentifier
-        );
-    }
-}

package/src/events/index.ts

@@ -1,4 +0,0 @@
-export { NDKAgentDefinition } from "./NDKAgentDefinition";
-export { NDKAgentLesson } from "./NDKAgentLesson";
-export { NDKMCPTool } from "./NDKMCPTool";
-export { NDKProjectStatus } from "./NDKProjectStatus";

package/src/lib/json-parser.ts

@@ -1,30 +0,0 @@
-/**
- * Safely parse JSON with markdown code block cleanup
- * @param text The text to parse, potentially containing markdown code blocks
- * @param context Optional context for error logging
- * @returns Parsed object or null if parsing fails
- */
-export function safeParseJSON<T = unknown>(text: string, context?: string): T | null {
-    try {
-        // Clean up response - remove markdown code blocks if present
-        let cleanText = text.trim();
-
-        // Remove ```json or ``` wrapper if present
-        if (cleanText.startsWith("```json")) {
-            cleanText = cleanText.replace(/^```json\s*/, "").replace(/```\s*$/, "");
-        } else if (cleanText.startsWith("```")) {
-            cleanText = cleanText.replace(/^```\s*/, "").replace(/```\s*$/, "");
-        }
-
-        return JSON.parse(cleanText);
-    } catch (error) {
-        if (context) {
-            // Use console.error since lib/ should not depend on TENEX logger
-            console.error(`[JSON Parser] Failed to parse JSON in ${context}`, {
-                error: error instanceof Error ? error.message : String(error),
-                text: text.substring(0, 200),
-            });
-        }
-        return null;
-    }
-}

package/src/llm/RecordingState.ts

@@ -1,37 +0,0 @@
-import { EventEmitter } from "tseep";
-
-/**
- * Global recording state singleton.
- * Controls whether the flight recorder middleware saves LLM interactions.
- */
-class RecordingStateManager extends EventEmitter<{
-    "state-changed": (isRecording: boolean) => void;
-}> {
-    private _isRecording = false;
-
-    get isRecording(): boolean {
-        return this._isRecording;
-    }
-
-    toggle(): boolean {
-        this._isRecording = !this._isRecording;
-        this.emit("state-changed", this._isRecording);
-        return this._isRecording;
-    }
-
-    start(): void {
-        if (!this._isRecording) {
-            this._isRecording = true;
-            this.emit("state-changed", true);
-        }
-    }
-
-    stop(): void {
-        if (this._isRecording) {
-            this._isRecording = false;
-            this.emit("state-changed", false);
-        }
-    }
-}
-
-export const recordingState = new RecordingStateManager();

package/src/llm/StreamPublisher.ts

@@ -1,40 +0,0 @@
-import { logger } from "@/utils/logger";
-import type { LocalStreamChunk } from "./types";
-
-/**
- * Interface for stream transports (Unix socket, future Nostr ephemeral)
- */
-export interface StreamTransport {
-    write(chunk: LocalStreamChunk): void;
-    isConnected(): boolean;
-}
-
-/**
- * Publishes AI SDK chunks to connected transports
- * Fire-and-forget: silently drops if no transport connected
- */
-export class StreamPublisher {
-    private transport: StreamTransport | null = null;
-
-    setTransport(transport: StreamTransport | null): void {
-        this.transport = transport;
-    }
-
-    write(chunk: LocalStreamChunk): void {
-        logger.debug("[StreamPublisher] write called", {
-            hasTransport: !!this.transport,
-            isConnected: this.transport?.isConnected() ?? false,
-            chunkType: (chunk.data as { type?: string })?.type,
-        });
-        if (this.transport?.isConnected()) {
-            this.transport.write(chunk);
-        }
-    }
-
-    isConnected(): boolean {
-        return this.transport?.isConnected() ?? false;
-    }
-}
-
-/** Singleton instance */
-export const streamPublisher = new StreamPublisher();

package/src/llm/middleware/flight-recorder.ts

@@ -1,188 +0,0 @@
-import type { LanguageModelMiddleware } from "ai";
-import { mkdir, writeFile } from "fs/promises";
-import { join } from "path";
-import { getTenexBasePath } from "@/constants";
-import { recordingState } from "../RecordingState";
-
-type WrapGenerateParams = Parameters<NonNullable<LanguageModelMiddleware["wrapGenerate"]>>[0];
-type WrapStreamParams = Parameters<NonNullable<LanguageModelMiddleware["wrapStream"]>>[0];
-
-// Recording types - using unknown for SDK types that may change between versions
-interface RecordingResponse {
-    content: unknown;
-    finishReason: unknown;
-    usage: unknown;
-}
-
-interface RecordingError {
-    message: string;
-}
-
-interface ToolCallRecord {
-    toolCallId: string;
-    toolName: string;
-    args: unknown;
-}
-
-/**
- * Flight recorder configuration
- */
-export interface FlightRecorderConfig {
-    /** Base directory for recordings (defaults to ~/.tenex/recordings) */
-    baseDir?: string;
-}
-
-/**
- * Creates a flight recorder middleware that records LLM interactions when enabled.
- * Recording is controlled by the global recordingState - toggle with Ctrl+R in daemon.
- *
- * Recordings are saved to: {baseDir}/YYYY-MM-DD/{timestamp}-{hash}.json
- * Respects TENEX_BASE_DIR environment variable for instance isolation.
- */
-export function createFlightRecorderMiddleware(
-    config: FlightRecorderConfig = {}
-): LanguageModelMiddleware {
-    const baseDir = config.baseDir || join(getTenexBasePath(), "recordings");
-
-    return {
-        specificationVersion: "v3" as const,
-
-        async wrapGenerate({ doGenerate, params, model }: WrapGenerateParams) {
-            if (!recordingState.isRecording) {
-                return doGenerate();
-            }
-
-            const startTime = Date.now();
-            const hash = createSimpleHash(JSON.stringify(params.prompt));
-
-            const recording = {
-                timestamp: new Date().toISOString(),
-                type: "generate",
-                model: { provider: model.provider, modelId: model.modelId },
-                request: {
-                    prompt: params.prompt,
-                    temperature: params.temperature,
-                    maxOutputTokens: params.maxOutputTokens,
-                    tools: params.tools,
-                    toolChoice: params.toolChoice,
-                },
-                response: null as RecordingResponse | null,
-                error: null as RecordingError | null,
-                duration: 0,
-            };
-
-            try {
-                const result = await doGenerate();
-                recording.response = {
-                    content: result.content,
-                    finishReason: result.finishReason,
-                    usage: result.usage,
-                };
-                recording.duration = Date.now() - startTime;
-                await saveRecording(baseDir, hash, recording);
-                return result;
-            } catch (error) {
-                recording.error = {
-                    message: error instanceof Error ? error.message : String(error),
-                };
-                recording.duration = Date.now() - startTime;
-                await saveRecording(baseDir, hash, recording);
-                throw error;
-            }
-        },
-
-        wrapStream({ doStream, params, model }: WrapStreamParams) {
-            if (!recordingState.isRecording) {
-                return doStream();
-            }
-
-            const startTime = Date.now();
-            const hash = createSimpleHash(JSON.stringify(params.prompt));
-
-            // Buffer to collect stream content
-            const textParts: string[] = [];
-            const toolCalls: ToolCallRecord[] = [];
-            let finishReason: string | undefined;
-            let usage: unknown;
-
-            // Wrap the stream with a TransformStream to intercept chunks
-            return doStream().then((result) => {
-                const transform = new TransformStream({
-                    transform(chunk, controller) {
-                        // Pass through the chunk
-                        controller.enqueue(chunk);
-
-                        // Collect data for recording
-                        if (chunk.type === "text-delta" && chunk.textDelta) {
-                            textParts.push(chunk.textDelta);
-                        }
-                        if (chunk.type === "tool-call") {
-                            toolCalls.push({
-                                toolCallId: chunk.toolCallId,
-                                toolName: chunk.toolName,
-                                args: chunk.args,
-                            });
-                        }
-                        if (chunk.type === "finish") {
-                            finishReason = chunk.finishReason;
-                            usage = chunk.usage;
-                        }
-                    },
-                    flush() {
-                        // Stream finished - save the recording
-                        const recording = {
-                            timestamp: new Date().toISOString(),
-                            type: "stream",
-                            model: { provider: model.provider, modelId: model.modelId },
-                            request: {
-                                prompt: params.prompt,
-                                temperature: params.temperature,
-                                maxOutputTokens: params.maxOutputTokens,
-                                tools: params.tools,
-                                toolChoice: params.toolChoice,
-                            },
-                            response: {
-                                content: [{ type: "text", text: textParts.join("") }],
-                                toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
-                                finishReason,
-                                usage,
-                            },
-                            duration: Date.now() - startTime,
-                        };
-                        saveRecording(baseDir, hash, recording).catch(() => {});
-                    },
-                });
-
-                return {
-                    ...result,
-                    stream: result.stream.pipeThrough(transform),
-                };
-            });
-        },
-    };
-}
-
-async function saveRecording(baseDir: string, hash: string, recording: Record<string, unknown>): Promise<void> {
-    try {
-        const now = new Date();
-        const dateStr = now.toISOString().split("T")[0];
-        const dirPath = join(baseDir, dateStr);
-        await mkdir(dirPath, { recursive: true });
-
-        const timestamp = now.toISOString().replace(/[:.]/g, "-");
-        const filename = `${timestamp}-${hash}.json`;
-        await writeFile(join(dirPath, filename), JSON.stringify(recording, null, 2), "utf-8");
-    } catch (error) {
-        console.error("[FlightRecorder] Failed to save recording:", error);
-    }
-}
-
-function createSimpleHash(input: string): string {
-    let hash = 0;
-    for (let i = 0; i < input.length; i++) {
-        const char = input.charCodeAt(i);
-        hash = (hash << 5) - hash + char;
-        hash = hash & hash;
-    }
-    return Math.abs(hash).toString(16).substring(0, 8);
-}