kanban-lite 1.2.13 → 1.2.16

package/dist/cli.js

@@ -25092,6 +25092,56 @@ async function updateComment(ctx, { cardId, commentId, content, boardId }) {
   });
   return card;
 }
+async function streamComment(ctx, {
+  cardId,
+  author,
+  boardId,
+  stream,
+  onStart,
+  onChunk
+}) {
+  if (!author?.trim())
+    throw new Error("Comment author cannot be empty");
+  const card = await ctx.getCard(cardId, boardId);
+  if (!card)
+    throw new Error(`Card not found: ${cardId}`);
+  if (!card.comments)
+    card.comments = [];
+  const maxId = card.comments.reduce((max, c) => {
+    const num = parseInt(c.id.replace("c", ""), 10);
+    return Number.isNaN(num) ? max : Math.max(max, num);
+  }, 0);
+  const commentId = `c${maxId + 1}`;
+  const created = (/* @__PURE__ */ new Date()).toISOString();
+  onStart?.(commentId, author, created);
+  let accumulated = "";
+  for await (const chunk of stream) {
+    accumulated += chunk;
+    onChunk?.(commentId, chunk);
+  }
+  const comment = {
+    id: commentId,
+    author,
+    created,
+    content: accumulated
+  };
+  card.comments.push(comment);
+  card.modified = (/* @__PURE__ */ new Date()).toISOString();
+  await ctx._storage.writeCard(card);
+  await appendActivityLog(ctx, {
+    cardId: card.id,
+    boardId: card.boardId || ctx._resolveBoardId(boardId),
+    eventType: "comment.created",
+    text: `Comment added by \`${author}\` (streamed)`,
+    metadata: {
+      commentId: comment.id,
+      author,
+      created: comment.created
+    }
+  }).catch(() => {
+  });
+  return card;
+}
 async function deleteComment(ctx, { cardId, commentId, boardId }) {
   const card = await ctx.getCard(cardId, boardId);
   if (!card)
@@ -27203,7 +27253,47 @@ var init_KanbanSDK = __esm({
           this._runAfterEvent("comment.deleted", { ...deletedComment, cardId: mergedInput.cardId }, void 0, card.boardId ?? this._resolveBoardId(mergedInput.boardId));
         return card;
       }
-      // --- Log management ---
+      /**
+       * Creates a comment on a card from a streaming text source, persisting it
+       * once the stream is exhausted.
+       *
+       * This method is the streaming counterpart to {@link addComment}. It is
+       * intended for use by AI agents that generate comment text incrementally
+       * (e.g. an LLM `textStream`). The caller may supply `onStart` and `onChunk`
+       * callbacks to fan live progress out to connected WebSocket viewers without
+       * requiring intermediate disk writes.
+       *
+       * @param cardId - The ID of the card to comment on.
+       * @param author - Display name of the streaming author.
+       * @param stream - An `AsyncIterable<string>` that yields text chunks.
+       * @param options.boardId - Optional board ID override.
+       * @param options.onStart - Called once before iteration with the allocated
+       *   comment ID, author, and ISO timestamp.
+       * @param options.onChunk - Called after each chunk with the comment ID and
+       *   the raw chunk string.
+       * @returns A promise resolving to the updated {@link Card} once the stream
+       *   has been fully consumed and the comment has been persisted.
+       * @throws {Error} If the card is not found.
+       * @throws {Error} If `author` is empty.
+       *
+       * @example
+       * ```ts
+       * // Stream an AI SDK textStream as a comment
+       * const { textStream } = await streamText({ model, prompt })
+       * const card = await sdk.streamComment('42', 'ai-agent', textStream, {
+       *   onStart: (id, author, created) => broadcast({ type: 'commentStreamStart', cardId: '42', commentId: id, author, created }),
+       *   onChunk: (id, chunk) => broadcast({ type: 'commentChunk', cardId: '42', commentId: id, chunk }),
+       * })
+       * ```
+       */
+      async streamComment(cardId, author, stream, options) {
+        const { boardId, onStart, onChunk } = options ?? {};
+        const card = await streamComment(this, { cardId, author, boardId, stream, onStart, onChunk });
+        const newComment = card.comments?.[card.comments.length - 1];
+        if (newComment)
+          this._runAfterEvent("comment.created", { ...newComment, cardId }, void 0, card.boardId ?? this._resolveBoardId(boardId));
+        return card;
+      }
       /**
        * Returns the absolute path to the log file for a card.
        *
@@ -43803,6 +43893,55 @@ async function main() {
       };
     }
   );
+  server.tool(
+    "stream_comment",
+    "Add a comment to a kanban card from a streaming text source. Provide the full content string; it will be written via the streaming path so connected webview clients see it arrive incrementally.",
+    {
+      boardId: external_exports.string().optional().describe("Board ID (uses default board if omitted)"),
+      cardId: external_exports.string().describe("Card ID (or partial ID)"),
+      author: external_exports.string().describe("Comment author name"),
+      content: external_exports.string().describe("Full comment text (supports markdown). The content is streamed word-by-word to connected viewers.")
+    },
+    async ({ boardId, cardId, author, content }) => {
+      let resolvedId = cardId;
+      const card = await sdk.getCard(cardId, boardId);
+      if (!card) {
+        const all = await sdk.listCards(void 0, boardId);
+        const matches = all.filter((c) => c.id.includes(cardId));
+        if (matches.length === 1) {
+          resolvedId = matches[0].id;
+        } else if (matches.length > 1) {
+          return {
+            content: [{ type: "text", text: `Multiple cards match "${cardId}": ${matches.map((m) => m.id).join(", ")}` }],
+            isError: true
+          };
+        } else {
+          return {
+            content: [{ type: "text", text: `Card not found: ${cardId}` }],
+            isError: true
+          };
+        }
+      }
+      async function* singleChunk() {
+        yield content;
+      }
+      try {
+        const updated = await runWithMcpAuth(() => sdk.streamComment(resolvedId, author, singleChunk(), { boardId }));
+        const added = updated.comments?.[updated.comments.length - 1];
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify(added, null, 2)
+          }]
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: String(err) }],
+          isError: true
+        };
+      }
+    }
+  );
   server.tool(
     "update_comment",
     "Update the content of a comment on a kanban card.",
@@ -94976,6 +95115,15 @@ async function broadcastLogsUpdatedToEditingClients(ctx, cardId, logs) {
     client.send(json2);
   }
 }
+function broadcastCommentStreamStart(ctx, cardId, commentId, author, created) {
+  broadcast(ctx, { type: "commentStreamStart", cardId, commentId, author, created });
+}
+function broadcastCommentChunk(ctx, cardId, commentId, chunk) {
+  broadcast(ctx, { type: "commentChunk", cardId, commentId, chunk });
+}
+function broadcastCommentStreamDone(ctx, cardId, commentId) {
+  broadcast(ctx, { type: "commentStreamDone", cardId, commentId });
+}
 var init_broadcastService = __esm({
   "src/standalone/broadcastService.ts"() {
     "use strict";
@@ -97002,6 +97150,49 @@ async function handleTaskRoutes(request) {
     }
     return true;
   }
+  params = route("POST", "/api/tasks/:id/comments/stream");
+  if (params) {
+    const { id } = params;
+    const author = (url.searchParams.get("author") ?? req.headers["x-comment-author"] ?? "").trim();
+    if (!author) {
+      jsonError(res, 400, "author query param is required");
+      return true;
+    }
+    let commentId;
+    try {
+      async function* requestTextStream() {
+        const decoder = new TextDecoder("utf-8");
+        for await (const chunk of req) {
+          yield decoder.decode(chunk, { stream: true });
+        }
+      }
+      const card = await runWithRequestAuth(
+        () => ctx.sdk.streamComment(id, author, requestTextStream(), {
+          boardId: url.searchParams.get("boardId") ?? void 0,
+          onStart: (cid, commentAuthor, created) => {
+            commentId = cid;
+            broadcastCommentStreamStart(ctx, id, cid, commentAuthor, created);
+          },
+          onChunk: (cid, chunk) => {
+            broadcastCommentChunk(ctx, id, cid, chunk);
+          }
+        })
+      );
+      if (!card) {
+        jsonError(res, 404, "Task not found");
+        return true;
+      }
+      await loadCards(ctx);
+      broadcast(ctx, buildInitMessage(ctx));
+      if (commentId)
+        broadcastCommentStreamDone(ctx, id, commentId);
+      const comment = card.comments?.find((c) => c.id === commentId);
+      jsonOk(res, comment ?? null, 201);
+    } catch (err) {
+      handleKnownError(err);
+    }
+    return true;
+  }
   params = route("PUT", "/api/tasks/:id/comments/:commentId");
   if (params) {
     try {
@@ -99265,7 +99456,7 @@ async function resolveCardId(sdk, cardId, boardId) {
 async function cmdComment(sdk, positional, flags) {
   const subcommand = positional[0] || "list";
   const boardId = getBoardId(flags);
-  if (subcommand !== "list" && subcommand !== "add" && subcommand !== "edit" && subcommand !== "remove" && subcommand !== "rm") {
+  if (subcommand !== "list" && subcommand !== "add" && subcommand !== "edit" && subcommand !== "remove" && subcommand !== "rm" && subcommand !== "stream") {
     const resolvedId = await resolveCardId(sdk, subcommand, boardId);
     const comments = await sdk.listComments(resolvedId, boardId);
     if (flags.json) {
@@ -99370,6 +99561,38 @@ async function cmdComment(sdk, positional, flags) {
       console.log(green(`Deleted comment ${commentId}`));
       break;
     }
+    case "stream": {
+      if (!cardId) {
+        console.error(red("Usage: kl comment stream <card-id> --author <name>"));
+        process.exit(1);
+      }
+      const author = typeof flags.author === "string" ? flags.author : "";
+      if (!author) {
+        console.error(red("Error: --author is required"));
+        process.exit(1);
+      }
+      const resolvedId = await resolveCardId(sdk, cardId, boardId);
+      async function* stdinStream() {
+        process.stdin.setEncoding("utf8");
+        for await (const chunk of process.stdin) {
+          if (!flags.json)
+            process.stderr.write(".");
+          yield chunk;
+        }
+      }
+      if (!flags.json)
+        process.stderr.write("Streaming comment");
+      const card = await sdk.streamComment(resolvedId, author, stdinStream(), { boardId });
+      if (!flags.json)
+        process.stderr.write("\n");
+      const added = card.comments?.[card.comments.length - 1];
+      if (flags.json) {
+        console.log(JSON.stringify(added, null, 2));
+      } else {
+        console.log(green(`Streamed comment ${added?.id ?? "?"} to card ${resolvedId}`));
+      }
+      break;
+    }
   }
 }
 async function cmdLog(sdk, positional, flags) {
@@ -99895,6 +100118,7 @@ ${bold("Attachment Commands:")}
 ${bold("Comment Commands:")}
   comment <id>                List comments on a card
   comment add <id>            Add a comment (--author, --body)
+  comment stream <id>         Stream a comment from stdin (--author)
   comment edit <id> <cid>     Edit a comment (--body)
   comment remove <id> <cid>   Remove a comment
 

package/dist/extension.js

@@ -72588,6 +72588,56 @@ async function updateComment(ctx, { cardId, commentId, content, boardId }) {
   });
   return card;
 }
+async function streamComment(ctx, {
+  cardId,
+  author,
+  boardId,
+  stream,
+  onStart,
+  onChunk
+}) {
+  if (!author?.trim())
+    throw new Error("Comment author cannot be empty");
+  const card = await ctx.getCard(cardId, boardId);
+  if (!card)
+    throw new Error(`Card not found: ${cardId}`);
+  if (!card.comments)
+    card.comments = [];
+  const maxId = card.comments.reduce((max, c) => {
+    const num = parseInt(c.id.replace("c", ""), 10);
+    return Number.isNaN(num) ? max : Math.max(max, num);
+  }, 0);
+  const commentId = `c${maxId + 1}`;
+  const created = (/* @__PURE__ */ new Date()).toISOString();
+  onStart?.(commentId, author, created);
+  let accumulated = "";
+  for await (const chunk of stream) {
+    accumulated += chunk;
+    onChunk?.(commentId, chunk);
+  }
+  const comment = {
+    id: commentId,
+    author,
+    created,
+    content: accumulated
+  };
+  card.comments.push(comment);
+  card.modified = (/* @__PURE__ */ new Date()).toISOString();
+  await ctx._storage.writeCard(card);
+  await appendActivityLog(ctx, {
+    cardId: card.id,
+    boardId: card.boardId || ctx._resolveBoardId(boardId),
+    eventType: "comment.created",
+    text: `Comment added by \`${author}\` (streamed)`,
+    metadata: {
+      commentId: comment.id,
+      author,
+      created: comment.created
+    }
+  }).catch(() => {
+  });
+  return card;
+}
 async function deleteComment(ctx, { cardId, commentId, boardId }) {
   const card = await ctx.getCard(cardId, boardId);
   if (!card)
@@ -74649,7 +74699,47 @@ var KanbanSDK = class _KanbanSDK {
       this._runAfterEvent("comment.deleted", { ...deletedComment, cardId: mergedInput.cardId }, void 0, card.boardId ?? this._resolveBoardId(mergedInput.boardId));
     return card;
   }
-  // --- Log management ---
+  /**
+   * Creates a comment on a card from a streaming text source, persisting it
+   * once the stream is exhausted.
+   *
+   * This method is the streaming counterpart to {@link addComment}. It is
+   * intended for use by AI agents that generate comment text incrementally
+   * (e.g. an LLM `textStream`). The caller may supply `onStart` and `onChunk`
+   * callbacks to fan live progress out to connected WebSocket viewers without
+   * requiring intermediate disk writes.
+   *
+   * @param cardId - The ID of the card to comment on.
+   * @param author - Display name of the streaming author.
+   * @param stream - An `AsyncIterable<string>` that yields text chunks.
+   * @param options.boardId - Optional board ID override.
+   * @param options.onStart - Called once before iteration with the allocated
+   *   comment ID, author, and ISO timestamp.
+   * @param options.onChunk - Called after each chunk with the comment ID and
+   *   the raw chunk string.
+   * @returns A promise resolving to the updated {@link Card} once the stream
+   *   has been fully consumed and the comment has been persisted.
+   * @throws {Error} If the card is not found.
+   * @throws {Error} If `author` is empty.
+   *
+   * @example
+   * ```ts
+   * // Stream an AI SDK textStream as a comment
+   * const { textStream } = await streamText({ model, prompt })
+   * const card = await sdk.streamComment('42', 'ai-agent', textStream, {
+   *   onStart: (id, author, created) => broadcast({ type: 'commentStreamStart', cardId: '42', commentId: id, author, created }),
+   *   onChunk: (id, chunk) => broadcast({ type: 'commentChunk', cardId: '42', commentId: id, chunk }),
+   * })
+   * ```
+   */
+  async streamComment(cardId, author, stream, options) {
+    const { boardId, onStart, onChunk } = options ?? {};
+    const card = await streamComment(this, { cardId, author, boardId, stream, onStart, onChunk });
+    const newComment = card.comments?.[card.comments.length - 1];
+    if (newComment)
+      this._runAfterEvent("comment.created", { ...newComment, cardId }, void 0, card.boardId ?? this._resolveBoardId(boardId));
+    return card;
+  }
   /**
    * Returns the absolute path to the log file for a card.
    *
@@ -78341,6 +78431,15 @@ async function broadcastLogsUpdatedToEditingClients(ctx, cardId, logs) {
     client.send(json2);
   }
 }
+function broadcastCommentStreamStart(ctx, cardId, commentId, author, created) {
+  broadcast(ctx, { type: "commentStreamStart", cardId, commentId, author, created });
+}
+function broadcastCommentChunk(ctx, cardId, commentId, chunk) {
+  broadcast(ctx, { type: "commentChunk", cardId, commentId, chunk });
+}
+function broadcastCommentStreamDone(ctx, cardId, commentId) {
+  broadcast(ctx, { type: "commentStreamDone", cardId, commentId });
+}
 
 // src/standalone/watcherSetup.ts
 var fs10 = __toESM(require("fs"));
@@ -80282,6 +80381,49 @@ async function handleTaskRoutes(request) {
     }
     return true;
   }
+  params = route("POST", "/api/tasks/:id/comments/stream");
+  if (params) {
+    const { id } = params;
+    const author = (url.searchParams.get("author") ?? req.headers["x-comment-author"] ?? "").trim();
+    if (!author) {
+      jsonError(res, 400, "author query param is required");
+      return true;
+    }
+    let commentId;
+    try {
+      async function* requestTextStream() {
+        const decoder = new TextDecoder("utf-8");
+        for await (const chunk of req) {
+          yield decoder.decode(chunk, { stream: true });
+        }
+      }
+      const card = await runWithRequestAuth(
+        () => ctx.sdk.streamComment(id, author, requestTextStream(), {
+          boardId: url.searchParams.get("boardId") ?? void 0,
+          onStart: (cid, commentAuthor, created) => {
+            commentId = cid;
+            broadcastCommentStreamStart(ctx, id, cid, commentAuthor, created);
+          },
+          onChunk: (cid, chunk) => {
+            broadcastCommentChunk(ctx, id, cid, chunk);
+          }
+        })
+      );
+      if (!card) {
+        jsonError(res, 404, "Task not found");
+        return true;
+      }
+      await loadCards(ctx);
+      broadcast(ctx, buildInitMessage(ctx));
+      if (commentId)
+        broadcastCommentStreamDone(ctx, id, commentId);
+      const comment = card.comments?.find((c) => c.id === commentId);
+      jsonOk(res, comment ?? null, 201);
+    } catch (err) {
+      handleKnownError(err);
+    }
+    return true;
+  }
   params = route("PUT", "/api/tasks/:id/comments/:commentId");
   if (params) {
     try {

package/dist/mcp-server.js

@@ -24986,6 +24986,56 @@ async function updateComment(ctx, { cardId, commentId, content, boardId }) {
   });
   return card;
 }
+async function streamComment(ctx, {
+  cardId,
+  author,
+  boardId,
+  stream,
+  onStart,
+  onChunk
+}) {
+  if (!author?.trim())
+    throw new Error("Comment author cannot be empty");
+  const card = await ctx.getCard(cardId, boardId);
+  if (!card)
+    throw new Error(`Card not found: ${cardId}`);
+  if (!card.comments)
+    card.comments = [];
+  const maxId = card.comments.reduce((max, c) => {
+    const num = parseInt(c.id.replace("c", ""), 10);
+    return Number.isNaN(num) ? max : Math.max(max, num);
+  }, 0);
+  const commentId = `c${maxId + 1}`;
+  const created = (/* @__PURE__ */ new Date()).toISOString();
+  onStart?.(commentId, author, created);
+  let accumulated = "";
+  for await (const chunk of stream) {
+    accumulated += chunk;
+    onChunk?.(commentId, chunk);
+  }
+  const comment = {
+    id: commentId,
+    author,
+    created,
+    content: accumulated
+  };
+  card.comments.push(comment);
+  card.modified = (/* @__PURE__ */ new Date()).toISOString();
+  await ctx._storage.writeCard(card);
+  await appendActivityLog(ctx, {
+    cardId: card.id,
+    boardId: card.boardId || ctx._resolveBoardId(boardId),
+    eventType: "comment.created",
+    text: `Comment added by \`${author}\` (streamed)`,
+    metadata: {
+      commentId: comment.id,
+      author,
+      created: comment.created
+    }
+  }).catch(() => {
+  });
+  return card;
+}
 async function deleteComment(ctx, { cardId, commentId, boardId }) {
   const card = await ctx.getCard(cardId, boardId);
   if (!card)
@@ -27047,7 +27097,47 @@ var KanbanSDK = class _KanbanSDK {
       this._runAfterEvent("comment.deleted", { ...deletedComment, cardId: mergedInput.cardId }, void 0, card.boardId ?? this._resolveBoardId(mergedInput.boardId));
     return card;
   }
-  // --- Log management ---
+  /**
+   * Creates a comment on a card from a streaming text source, persisting it
+   * once the stream is exhausted.
+   *
+   * This method is the streaming counterpart to {@link addComment}. It is
+   * intended for use by AI agents that generate comment text incrementally
+   * (e.g. an LLM `textStream`). The caller may supply `onStart` and `onChunk`
+   * callbacks to fan live progress out to connected WebSocket viewers without
+   * requiring intermediate disk writes.
+   *
+   * @param cardId - The ID of the card to comment on.
+   * @param author - Display name of the streaming author.
+   * @param stream - An `AsyncIterable<string>` that yields text chunks.
+   * @param options.boardId - Optional board ID override.
+   * @param options.onStart - Called once before iteration with the allocated
+   *   comment ID, author, and ISO timestamp.
+   * @param options.onChunk - Called after each chunk with the comment ID and
+   *   the raw chunk string.
+   * @returns A promise resolving to the updated {@link Card} once the stream
+   *   has been fully consumed and the comment has been persisted.
+   * @throws {Error} If the card is not found.
+   * @throws {Error} If `author` is empty.
+   *
+   * @example
+   * ```ts
+   * // Stream an AI SDK textStream as a comment
+   * const { textStream } = await streamText({ model, prompt })
+   * const card = await sdk.streamComment('42', 'ai-agent', textStream, {
+   *   onStart: (id, author, created) => broadcast({ type: 'commentStreamStart', cardId: '42', commentId: id, author, created }),
+   *   onChunk: (id, chunk) => broadcast({ type: 'commentChunk', cardId: '42', commentId: id, chunk }),
+   * })
+   * ```
+   */
+  async streamComment(cardId, author, stream, options) {
+    const { boardId, onStart, onChunk } = options ?? {};
+    const card = await streamComment(this, { cardId, author, boardId, stream, onStart, onChunk });
+    const newComment = card.comments?.[card.comments.length - 1];
+    if (newComment)
+      this._runAfterEvent("comment.created", { ...newComment, cardId }, void 0, card.boardId ?? this._resolveBoardId(boardId));
+    return card;
+  }
   /**
    * Returns the absolute path to the log file for a card.
    *
@@ -28564,6 +28654,55 @@ async function main() {
       };
     }
   );
+  server.tool(
+    "stream_comment",
+    "Add a comment to a kanban card from a streaming text source. Provide the full content string; it will be written via the streaming path so connected webview clients see it arrive incrementally.",
+    {
+      boardId: import_zod.z.string().optional().describe("Board ID (uses default board if omitted)"),
+      cardId: import_zod.z.string().describe("Card ID (or partial ID)"),
+      author: import_zod.z.string().describe("Comment author name"),
+      content: import_zod.z.string().describe("Full comment text (supports markdown). The content is streamed word-by-word to connected viewers.")
+    },
+    async ({ boardId, cardId, author, content }) => {
+      let resolvedId = cardId;
+      const card = await sdk.getCard(cardId, boardId);
+      if (!card) {
+        const all = await sdk.listCards(void 0, boardId);
+        const matches = all.filter((c) => c.id.includes(cardId));
+        if (matches.length === 1) {
+          resolvedId = matches[0].id;
+        } else if (matches.length > 1) {
+          return {
+            content: [{ type: "text", text: `Multiple cards match "${cardId}": ${matches.map((m) => m.id).join(", ")}` }],
+            isError: true
+          };
+        } else {
+          return {
+            content: [{ type: "text", text: `Card not found: ${cardId}` }],
+            isError: true
+          };
+        }
+      }
+      async function* singleChunk() {
+        yield content;
+      }
+      try {
+        const updated = await runWithMcpAuth(() => sdk.streamComment(resolvedId, author, singleChunk(), { boardId }));
+        const added = updated.comments?.[updated.comments.length - 1];
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify(added, null, 2)
+          }]
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: String(err) }],
+          isError: true
+        };
+      }
+    }
+  );
   server.tool(
     "update_comment",
     "Update the content of a comment on a kanban card.",