@tenex-chat/backend 0.9.4 → 0.9.6

package/dist/tenex-backend-wrapper.cjs

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-import("./src/index.js").catch(e => { console.error(e); process.exit(1); });

package/src/agents/execution/constants.ts

@@ -1,16 +0,0 @@
-/**
- * Configuration constants for agent execution
- */
-export const ExecutionConfig = {
-    /** Delay in milliseconds after publishing typing indicator */
-    TOOL_INDICATOR_DELAY_MS: 100,
-
-    /** Default duration for tool execution when not tracked */
-    DEFAULT_TOOL_DURATION_MS: 1000,
-
-    /** Default timeout for shell commands in milliseconds (30 seconds) */
-    DEFAULT_COMMAND_TIMEOUT_MS: 30000,
-
-    /** Threshold for considering a phase transition as recent in milliseconds (30 seconds) */
-    RECENT_TRANSITION_THRESHOLD_MS: 30000,
-} as const;

package/src/agents/execution/index.ts

@@ -1,3 +0,0 @@
-export * from "./AgentExecutor";
-export * from "./ExecutionContextFactory";
-export * from "./types";

package/src/agents/index.ts

@@ -1,4 +0,0 @@
-export { AgentRegistry } from "./AgentRegistry";
-export * from "./execution";
-export type { AgentInstance, AgentSummary } from "./types/runtime";
-export type { AgentConfig, AgentConfigOptionalNsec, StoredAgentData } from "./types/storage";

package/src/commands/agent.ts

@@ -1,215 +0,0 @@
-import * as fs from "node:fs/promises";
-import { existsSync } from "node:fs";
-import * as path from "node:path";
-import { homedir } from "node:os";
-import { Command } from "commander";
-import chalk from "chalk";
-import { NDKPrivateKeySigner, NDKEvent } from "@nostr-dev-kit/ndk";
-import { agentStorage, createStoredAgent } from "@/agents/AgentStorage";
-import { installAgentFromNostr, installAgentFromNostrEvent } from "@/agents/agent-installer";
-import { initNDK } from "@/nostr/ndkClient";
-
-// ─── OpenClaw discovery ──────────────────────────────────────────────────────
-
-const OPENCLAW_STATE_DIR_NAMES = [".openclaw", ".clawdbot", ".moldbot", ".moltbot"];
-const OPENCLAW_CONFIG_NAMES = ["openclaw.json", "clawdbot.json", "moldbot.json", "moltbot.json"];
-
-function findOpenClawStateDir(): string | undefined {
-    // 1. Environment variable
-    const envPath = process.env.OPENCLAW_STATE_DIR;
-    if (envPath && hasOpenClawConfig(envPath)) {
-        return envPath;
-    }
-
-    // 2. Home directory candidates
-    const home = homedir();
-    for (const name of OPENCLAW_STATE_DIR_NAMES) {
-        const candidate = path.join(home, name);
-        if (hasOpenClawConfig(candidate)) {
-            return candidate;
-        }
-    }
-
-    return undefined;
-}
-
-function hasOpenClawConfig(dir: string): boolean {
-    return OPENCLAW_CONFIG_NAMES.some((name) => existsSync(path.join(dir, name)));
-}
-
-/** Prettify a slug for display: "main" → "Main", "my-agent" → "My Agent" */
-function prettifySlug(slug: string): string {
-    return slug
-        .replace(/-/g, " ")
-        .replace(/\b\w/g, (c) => c.toUpperCase());
-}
-
-interface OpenClawAgent {
-    name: string;
-    slug: string;
-    role: string;
-}
-
-async function discoverOpenClawAgents(stateDir: string): Promise<OpenClawAgent[]> {
-    const agentsDir = path.join(stateDir, "agents");
-    try {
-        const entries = await fs.readdir(agentsDir, { withFileTypes: true });
-        return entries
-            .filter((e) => e.isDirectory())
-            .map((e) => ({
-                name: prettifySlug(e.name),
-                slug: e.name,
-                role: "",
-            }));
-    } catch {
-        return [];
-    }
-}
-
-// ─── tenex agent import openclaw ────────────────────────────────────────────
-
-async function importOpenClaw(options: {
-    dryRun: boolean;
-    json: boolean;
-    slugs?: string;
-}): Promise<void> {
-    const stateDir = findOpenClawStateDir();
-
-    if (!stateDir) {
-        if (options.json) {
-            console.log("[]");
-        } else {
-            console.error(chalk.yellow("OpenClaw installation not found."));
-        }
-        return;
-    }
-
-    const agents = await discoverOpenClawAgents(stateDir);
-
-    // Apply slug filter if provided
-    const filtered =
-        options.slugs
-            ? agents.filter((a) => options.slugs!.split(",").map((s) => s.trim()).includes(a.slug))
-            : agents;
-
-    if (options.json) {
-        console.log(JSON.stringify(filtered, null, 2));
-        return;
-    }
-
-    if (filtered.length === 0) {
-        console.log(chalk.yellow("No OpenClaw agents found."));
-        return;
-    }
-
-    if (options.dryRun) {
-        console.log(chalk.blue(`Would import ${filtered.length} OpenClaw agent(s):`));
-        for (const agent of filtered) {
-            console.log(chalk.gray(`  ${agent.slug} → "${agent.name}"`));
-        }
-        return;
-    }
-
-    await agentStorage.initialize();
-
-    let imported = 0;
-    let skipped = 0;
-
-    for (const agent of filtered) {
-        // Check if already exists by slug
-        const existing = await agentStorage.getAgentBySlug(agent.slug);
-        if (existing) {
-            console.log(chalk.gray(`  ${agent.slug}: already exists, skipping`));
-            skipped++;
-            continue;
-        }
-
-        const signer = NDKPrivateKeySigner.generate();
-        const stored = createStoredAgent({
-            nsec: signer.nsec,
-            slug: agent.slug,
-            name: agent.name,
-            role: agent.role,
-        });
-
-        await agentStorage.saveAgent(stored);
-        console.log(
-            chalk.green(`  ✓ ${agent.slug}`) +
-            chalk.gray(` → pubkey ${signer.pubkey.substring(0, 8)}...`)
-        );
-        imported++;
-    }
-
-    console.log(chalk.blue(`\nDone: ${imported} imported, ${skipped} skipped`));
-}
-
-// ─── tenex agent add ─────────────────────────────────────────────────────────
-
-async function readStdin(): Promise<string> {
-    return new Promise((resolve, reject) => {
-        let data = "";
-        process.stdin.setEncoding("utf-8");
-        process.stdin.on("data", (chunk) => {
-            data += chunk;
-        });
-        process.stdin.on("end", () => resolve(data.trim()));
-        process.stdin.on("error", reject);
-    });
-}
-
-async function addAgent(eventId: string | undefined): Promise<void> {
-    await agentStorage.initialize();
-
-    if (!process.stdin.isTTY) {
-        const raw = await readStdin();
-        const rawEvent = JSON.parse(raw);
-        const event = new NDKEvent(undefined, rawEvent);
-        const stored = await installAgentFromNostrEvent(event);
-        const pubkey = new NDKPrivateKeySigner(stored.nsec).pubkey;
-        console.log(chalk.green(`✓ Installed agent "${stored.name}" (${stored.slug})`));
-        console.log(chalk.gray(`  pubkey: ${pubkey}`));
-        return;
-    }
-
-    if (!eventId) {
-        console.error(chalk.red("Error: provide an event ID or pipe event JSON via stdin"));
-        process.exit(1);
-    }
-
-    await initNDK();
-    const stored = await installAgentFromNostr(eventId);
-    const pubkey = new NDKPrivateKeySigner(stored.nsec).pubkey;
-    console.log(chalk.green(`✓ Installed agent "${stored.name}" (${stored.slug})`));
-    console.log(chalk.gray(`  pubkey: ${pubkey}`));
-}
-
-// ─── Command registration ────────────────────────────────────────────────────
-
-const importOpenClawCommand = new Command("openclaw")
-    .description("Import agents from a local OpenClaw installation")
-    .option("--dry-run", "Print what would be imported without making changes")
-    .option("--json", "Output as JSON array")
-    .option("--slugs <slugs>", "Comma-separated list of slugs to import (default: all)")
-    .action(async (options) => {
-        await importOpenClaw({
-            dryRun: !!options.dryRun,
-            json: !!options.json,
-            slugs: options.slugs,
-        });
-    });
-
-const importCommand = new Command("import")
-    .description("Import agents from external sources")
-    .addCommand(importOpenClawCommand);
-
-const addCommand = new Command("add")
-    .description("Install an agent from a Nostr event ID or stdin JSON")
-    .argument("[event-id]", "Nostr event ID of the agent definition")
-    .action(async (eventId: string | undefined) => {
-        await addAgent(eventId);
-    });
-
-export const agentCommand = new Command("agent")
-    .description("Manage TENEX agents")
-    .addCommand(importCommand)
-    .addCommand(addCommand);

package/src/conversations/formatters/DelegationXmlFormatter.ts

@@ -1,64 +0,0 @@
-interface DelegationResponse {
-    from: string;
-    content: string;
-    eventId: string;
-    status: "completed" | "error";
-}
-
-interface DelegationInfo {
-    id: string;
-    from: string;
-    recipients: string[];
-    phase?: string;
-    message: string;
-    requestEventId: string;
-    responses: DelegationResponse[];
-}
-
-/**
- * Formats delegation information as structured XML for LLM comprehension
- */
-export class DelegationXmlFormatter {
-    /**
-     * Render a delegation with its responses as XML
-     */
-    static render(delegation: DelegationInfo, debug = false): string {
-        const eventPrefix = debug ? `[Event ${delegation.requestEventId.substring(0, 8)}] ` : "";
-        const recipientsAttr = delegation.recipients.join(",");
-        const phaseAttr = delegation.phase ? ` phase="${delegation.phase}"` : "";
-
-        let xml = `${eventPrefix}<delegation from="${delegation.from}" recipients="${recipientsAttr}" id="${delegation.id}"${phaseAttr}>`;
-        xml += `\n    <delegation-request>${DelegationXmlFormatter.escapeXml(delegation.message)}</delegation-request>`;
-
-        // Add responses
-        for (const response of delegation.responses) {
-            const statusAttr = response.status === "error" ? ' error="true"' : "";
-            const eventIdAttr = debug ? ` event-id="${response.eventId.substring(0, 8)}"` : "";
-            xml += `\n    <response from="${response.from}"${statusAttr}${eventIdAttr}>${DelegationXmlFormatter.escapeXml(response.content)}</response>`;
-        }
-
-        // Add pending placeholders for recipients without responses
-        const respondedFrom = new Set(delegation.responses.map((r) => r.from));
-        for (const recipient of delegation.recipients) {
-            if (!respondedFrom.has(recipient)) {
-                xml += `\n    <response from="${recipient}" status="pending" />`;
-            }
-        }
-
-        xml += "\n</delegation>";
-
-        return xml;
-    }
-
-    /**
-     * Escape XML special characters
-     */
-    private static escapeXml(text: string): string {
-        return text
-            .replace(/&/g, "&amp;")
-            .replace(/</g, "&lt;")
-            .replace(/>/g, "&gt;")
-            .replace(/"/g, "&quot;")
-            .replace(/'/g, "&apos;");
-    }
-}

package/src/conversations/formatters/index.ts

@@ -1,9 +0,0 @@
-export {
-    ThreadedConversationFormatter,
-    type ThreadNode,
-    type FormatterOptions,
-} from "./ThreadedConversationFormatter";
-export { TreeBuilder } from "./utils/TreeBuilder";
-export { MessageFormatter } from "./utils/MessageFormatter";
-export { TimestampFormatter } from "./utils/TimestampFormatter";
-export { TreeRenderer } from "./utils/TreeRenderer";

package/src/conversations/index.ts

@@ -1,2 +0,0 @@
-export { ConversationStore } from "./ConversationStore";
-export type { ConversationMetadata, ConversationEntry } from "./types";

package/src/conversations/utils/content-utils.ts

@@ -1,69 +0,0 @@
-/**
- * Content utilities for processing conversation messages
- * Purpose: Strip <thinking>...</thinking> blocks from conversation history; skip messages that are purely thinking blocks.
- * Also filter out events with reasoning tags.
- */
-
-import type { NDKEvent } from "@nostr-dev-kit/ndk";
-
-/**
- * Regex pattern to match thinking blocks (case-insensitive, multi-line)
- * Matches: <thinking>, <Thinking>, <THINKING> with any attributes and their closing tags
- */
-const THINKING_BLOCK_REGEX = /<thinking\b[^>]*>[\s\S]*?<\/thinking>/gi;
-
-/**
- * Remove all thinking blocks from content
- * @param content - The content to process
- * @returns The content with all thinking blocks removed and normalized whitespace (multiple blank lines collapsed to single newline)
- */
-export function stripThinkingBlocks(content: string): string {
-    if (!content) return "";
-
-    // Remove all thinking blocks
-    let stripped = content.replace(THINKING_BLOCK_REGEX, "");
-
-    // Normalize whitespace more carefully:
-    // 1. Only collapse multiple spaces that aren't at the beginning of a line (preserve indentation)
-    // 2. Collapse multiple blank lines to a single newline
-    stripped = stripped
-        .split("\n")
-        .map((line) => {
-            // Only collapse spaces in the middle of lines, not at the start (preserve indentation)
-            if (line.trimStart() !== line) {
-                // Line has leading whitespace - preserve it
-                const leadingWhitespace = line.match(/^\s*/)?.[0] || "";
-                const rest = line.slice(leadingWhitespace.length);
-                return leadingWhitespace + rest.replace(/ {2,}/g, " ");
-            }
-            // No leading whitespace - collapse all multiple spaces
-            return line.replace(/ {2,}/g, " ");
-        })
-        .join("\n")
-        .replace(/\n\s*\n+/g, "\n") // Collapse 2+ newlines to single newline
-        .trim(); // Trim leading/trailing whitespace
-
-    return stripped;
-}
-
-/**
- * Check if content contains only thinking blocks (no other content)
- * @param content - The content to check
- * @returns True if the content is empty after removing thinking blocks
- */
-export function isOnlyThinkingBlocks(content: string): boolean {
-    if (!content || content.trim().length === 0) return false; // Empty/whitespace content is not "only thinking blocks"
-
-    const stripped = stripThinkingBlocks(content);
-    return stripped.length === 0;
-}
-
-/**
- * Check if an event has a reasoning tag
- * @param event - The NDK event to check
- * @returns True if the event has a ["reasoning"] tag
- */
-export function hasReasoningTag(event: NDKEvent): boolean {
-    if (!event.tags) return false;
-    return event.tags.some((tag) => tag[0] === "reasoning" && tag.length === 1);
-}