@tenex-chat/backend 0.9.1

package/src/events/NDKAgentLesson.ts

@@ -0,0 +1,106 @@
+import type NDK from "@nostr-dev-kit/ndk";
+import { NDKEvent, type NDKRawEvent } from "@nostr-dev-kit/ndk";
+
+export class NDKAgentLesson extends NDKEvent {
+    static kind = 4129;
+    static kinds = [4129];
+
+    constructor(ndk?: NDK, event?: NDKEvent | NDKRawEvent) {
+        super(ndk, event);
+        this.kind ??= 4129;
+    }
+
+    static from(event: NDKEvent): NDKAgentLesson {
+        return new NDKAgentLesson(event.ndk, event);
+    }
+
+    get title(): string | undefined {
+        return this.tagValue("title");
+    }
+
+    /**
+     * Title/description of what this lesson is about.
+     */
+    set title(value: string | undefined) {
+        this.removeTag("title");
+        if (value) this.tags.push(["title", value]);
+    }
+
+    /**
+     * The lesson content - what the agent learned.
+     * This is stored in the event content.
+     */
+    get lesson(): string {
+        return this.content;
+    }
+
+    set lesson(value: string) {
+        this.content = value;
+    }
+
+    /**
+     * Set the agent that this lesson belongs to.
+     * @param agentEvent The NDKAgentDefinition event to reference
+     */
+    set agentDefinitionId(agentDefinitionId: string) {
+        this.removeTag("e");
+        this.tags.push(["e", agentDefinitionId]);
+    }
+
+    /**
+     * Get the agent event ID this lesson belongs to.
+     */
+    get agentDefinitionId(): string | undefined {
+        return this.tags.find((tag) => tag[0] === "e")?.[1];
+    }
+
+    /**
+     * Metacognition reasoning - why this lesson is worth learning
+     */
+    get metacognition(): string | undefined {
+        return this.tagValue("metacognition");
+    }
+
+    set metacognition(value: string | undefined) {
+        this.removeTag("metacognition");
+        if (value) this.tags.push(["metacognition", value]);
+    }
+
+    /**
+     * Detailed version of the lesson with richer explanation
+     */
+    get detailed(): string | undefined {
+        return this.tagValue("detailed");
+    }
+
+    set detailed(value: string | undefined) {
+        this.removeTag("detailed");
+        if (value) this.tags.push(["detailed", value]);
+    }
+
+    /**
+     * Category for filing this lesson
+     */
+    get category(): string | undefined {
+        return this.tagValue("category");
+    }
+
+    set category(value: string | undefined) {
+        this.removeTag("category");
+        if (value) this.tags.push(["category", value]);
+    }
+
+    /**
+     * Hashtags for easier sorting and discovery
+     */
+    get hashtags(): string[] {
+        return this.tags.filter((tag) => tag[0] === "t").map((tag) => tag[1]);
+    }
+
+    set hashtags(values: string[]) {
+        this.tags = this.tags.filter((tag) => tag[0] !== "t");
+        for (const hashtag of values) {
+            this.tags.push(["t", hashtag]);
+        }
+    }
+}

package/src/events/NDKEventMetadata.ts

@@ -0,0 +1,34 @@
+import { NDKEvent } from "@nostr-dev-kit/ndk";
+
+/**
+ * NDKEventMetadata - Kind 513
+ *
+ * Allows setting metadata about conversations:
+ * - ["e", "<event-id>"] - References the conversation
+ * - ["title", "title-of-the-conversation"] - Sets the conversation title
+ */
+export class NDKEventMetadata extends NDKEvent {
+    static kind = 513;
+
+    static from(event: NDKEvent): NDKEventMetadata {
+        return new NDKEventMetadata(event.ndk, event);
+    }
+
+    get conversationId(): string | undefined {
+        return this.tagValue("e");
+    }
+
+    get title(): string | undefined {
+        return this.tagValue("title");
+    }
+
+    set title(value: string) {
+        this.removeTag("title");
+        this.tags.push(["title", value]);
+    }
+
+    setConversationId(eventId: string): void {
+        this.removeTag("e");
+        this.tags.push(["e", eventId]);
+    }
+}

package/src/events/NDKMCPTool.ts

@@ -0,0 +1,60 @@
+import type NDK from "@nostr-dev-kit/ndk";
+import { NDKEvent, type NDKRawEvent } from "@nostr-dev-kit/ndk";
+
+export class NDKMCPTool extends NDKEvent {
+    static kind = 4200;
+    static kinds = [4200];
+
+    constructor(ndk?: NDK, event?: NDKEvent | NDKRawEvent) {
+        super(ndk, event);
+        this.kind ??= 4200;
+    }
+
+    static from(event: NDKEvent): NDKMCPTool {
+        return new NDKMCPTool(event.ndk, event);
+    }
+
+    get name(): string | undefined {
+        return this.tagValue("name");
+    }
+
+    set name(value: string | undefined) {
+        this.removeTag("name");
+        if (value) this.tags.push(["name", value]);
+    }
+
+    get description(): string | undefined {
+        return this.tagValue("description");
+    }
+
+    set description(value: string | undefined) {
+        this.removeTag("description");
+        if (value) this.tags.push(["description", value]);
+    }
+
+    get command(): string | undefined {
+        return this.tagValue("command");
+    }
+
+    set command(value: string | undefined) {
+        this.removeTag("command");
+        if (value) this.tags.push(["command", value]);
+    }
+
+    get image(): string | undefined {
+        return this.tagValue("image");
+    }
+
+    set image(value: string | undefined) {
+        this.removeTag("image");
+        if (value) this.tags.push(["image", value]);
+    }
+
+    get slug(): string {
+        const name = this.name || "unnamed";
+        return name
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, "-")
+            .replace(/^-|-$/g, "");
+    }
+}

package/src/events/NDKProjectStatus.ts

@@ -0,0 +1,384 @@
+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

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