@iloom/cli 0.3.4 → 0.4.1

package/dist/chunk-TMZAVPGF.js

@@ -0,0 +1,667 @@
+#!/usr/bin/env node
+import {
+  createLinearComment,
+  fetchLinearIssue,
+  fetchLinearIssueComments,
+  getLinearComment,
+  updateLinearComment
+} from "./chunk-QHA67Q7A.js";
+import {
+  MetadataManager
+} from "./chunk-IJ7IGJT3.js";
+import {
+  SettingsManager
+} from "./chunk-VWNS6DH5.js";
+import {
+  createIssueComment,
+  createPRComment,
+  executeGhCommand,
+  updateIssueComment
+} from "./chunk-KO2FOMHL.js";
+import {
+  generateDeterministicSessionId,
+  launchClaude
+} from "./chunk-RUC7OULH.js";
+import {
+  PromptTemplateManager
+} from "./chunk-74VMN2KC.js";
+import {
+  logger
+} from "./chunk-UYVWLISQ.js";
+
+// src/utils/claude-transcript.ts
+import { readFile } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+function getClaudeProjectPath(worktreePath) {
+  return worktreePath.replace(/[/_]/g, "-");
+}
+function getClaudeProjectsDir() {
+  return join(homedir(), ".claude", "projects");
+}
+function findSessionTranscript(worktreePath, sessionId) {
+  const projectsDir = getClaudeProjectsDir();
+  const projectDirName = getClaudeProjectPath(worktreePath);
+  const transcriptPath = join(projectsDir, projectDirName, `${sessionId}.jsonl`);
+  return transcriptPath;
+}
+function extractMessageContent(message) {
+  if (!message) return null;
+  if (typeof message.content === "string") {
+    return message.content;
+  }
+  if (Array.isArray(message.content)) {
+    return message.content.filter((item) => item.type === "text" && item.text).map((item) => item.text).join("\n");
+  }
+  return null;
+}
+async function extractCompactSummaries(transcriptPath, maxSummaries = 3) {
+  try {
+    const content = await readFile(transcriptPath, "utf-8");
+    const lines = content.split("\n").filter((line) => line.trim());
+    const summaries = [];
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.isCompactSummary === true && entry.message) {
+          const summaryContent = extractMessageContent(entry.message);
+          if (summaryContent) {
+            summaries.push(summaryContent);
+          }
+        }
+      } catch {
+        logger.debug("Skipping malformed JSONL line in transcript");
+      }
+    }
+    return summaries.slice(-maxSummaries);
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      logger.debug("Transcript file not found:", transcriptPath);
+    } else {
+      logger.debug("Error reading transcript file:", error);
+    }
+    return [];
+  }
+}
+async function readSessionContext(worktreePath, sessionId, maxSummaries = 3) {
+  const transcriptPath = findSessionTranscript(worktreePath, sessionId);
+  if (!transcriptPath) {
+    return null;
+  }
+  logger.debug(`Checking transcript at: ${transcriptPath}`);
+  const summaries = await extractCompactSummaries(transcriptPath, maxSummaries);
+  if (summaries.length === 0) {
+    return null;
+  }
+  const formattedSummaries = summaries.reverse().map((summary, index) => {
+    const header = summaries.length > 1 ? `### Compact Summary ${index + 1} of ${summaries.length}
+
+` : "";
+    return `${header}${summary}`;
+  }).join("\n\n---\n\n");
+  return formattedSummaries;
+}
+
+// src/mcp/GitHubIssueManagementProvider.ts
+function normalizeAuthor(author) {
+  if (!author) return null;
+  return {
+    id: author.id ? String(author.id) : author.login,
+    displayName: author.login,
+    // GitHub uses login as primary identifier
+    login: author.login,
+    // Preserve original GitHub field
+    ...author.avatarUrl && { avatarUrl: author.avatarUrl },
+    ...author.url && { url: author.url }
+  };
+}
+function extractNumericIdFromUrl(url) {
+  const match = url.match(/#issuecomment-(\d+)$/);
+  if (!(match == null ? void 0 : match[1])) {
+    throw new Error(`Cannot extract comment ID from URL: ${url}`);
+  }
+  return match[1];
+}
+var GitHubIssueManagementProvider = class {
+  constructor() {
+    this.providerName = "github";
+  }
+  /**
+   * Fetch issue details using gh CLI
+   * Normalizes GitHub-specific fields to provider-agnostic format
+   */
+  async getIssue(input) {
+    const { number, includeComments = true } = input;
+    const issueNumber = parseInt(number, 10);
+    if (isNaN(issueNumber)) {
+      throw new Error(`Invalid GitHub issue number: ${number}. GitHub issue IDs must be numeric.`);
+    }
+    const fields = includeComments ? "body,title,comments,labels,assignees,milestone,author,state,number,url" : "body,title,labels,assignees,milestone,author,state,number,url";
+    const raw = await executeGhCommand([
+      "issue",
+      "view",
+      String(issueNumber),
+      "--json",
+      fields
+    ]);
+    const result = {
+      // Core fields
+      id: String(raw.number),
+      title: raw.title,
+      body: raw.body,
+      state: raw.state,
+      url: raw.url,
+      provider: "github",
+      // Normalized author
+      author: normalizeAuthor(raw.author),
+      // Optional flexible fields
+      ...raw.assignees && {
+        assignees: raw.assignees.map((a) => normalizeAuthor(a)).filter((a) => a !== null)
+      },
+      ...raw.labels && {
+        labels: raw.labels
+      },
+      // GitHub-specific passthrough fields
+      ...raw.milestone && {
+        milestone: raw.milestone
+      }
+    };
+    if (raw.comments !== void 0) {
+      result.comments = raw.comments.map((comment) => ({
+        id: extractNumericIdFromUrl(comment.url),
+        body: comment.body,
+        createdAt: comment.createdAt,
+        author: normalizeAuthor(comment.author),
+        ...comment.updatedAt && { updatedAt: comment.updatedAt }
+      }));
+    }
+    return result;
+  }
+  /**
+   * Fetch a specific comment by ID using gh API
+   * Normalizes author to FlexibleAuthor format
+   */
+  async getComment(input) {
+    const { commentId } = input;
+    const numericCommentId = parseInt(commentId, 10);
+    if (isNaN(numericCommentId)) {
+      throw new Error(`Invalid GitHub comment ID: ${commentId}. GitHub comment IDs must be numeric.`);
+    }
+    const raw = await executeGhCommand([
+      "api",
+      `repos/:owner/:repo/issues/comments/${numericCommentId}`,
+      "--jq",
+      "{id: .id, body: .body, user: .user, created_at: .created_at, updated_at: .updated_at, html_url: .html_url, reactions: .reactions}"
+    ]);
+    return {
+      id: String(raw.id),
+      body: raw.body,
+      author: normalizeAuthor(raw.user),
+      created_at: raw.created_at,
+      ...raw.updated_at && { updated_at: raw.updated_at },
+      // Passthrough GitHub-specific fields
+      ...raw.html_url && { html_url: raw.html_url },
+      ...raw.reactions && { reactions: raw.reactions }
+    };
+  }
+  /**
+   * Create a new comment on an issue or PR
+   */
+  async createComment(input) {
+    const { number, body, type } = input;
+    const numericId = parseInt(number, 10);
+    if (isNaN(numericId)) {
+      throw new Error(`Invalid GitHub ${type} number: ${number}. GitHub IDs must be numeric.`);
+    }
+    const result = type === "issue" ? await createIssueComment(numericId, body) : await createPRComment(numericId, body);
+    return {
+      ...result,
+      id: String(result.id)
+    };
+  }
+  /**
+   * Update an existing comment
+   */
+  async updateComment(input) {
+    const { commentId, body } = input;
+    const numericCommentId = parseInt(commentId, 10);
+    if (isNaN(numericCommentId)) {
+      throw new Error(`Invalid GitHub comment ID: ${commentId}. GitHub comment IDs must be numeric.`);
+    }
+    const result = await updateIssueComment(numericCommentId, body);
+    return {
+      ...result,
+      id: String(result.id)
+    };
+  }
+};
+
+// src/utils/linear-markup-converter.ts
+import { appendFileSync } from "fs";
+import { join as join2, dirname, basename, extname } from "path";
+var LinearMarkupConverter = class {
+  /**
+   * Convert HTML details/summary blocks to Linear's collapsible format
+   * Handles nested details blocks recursively
+   *
+   * @param text - Text containing HTML details/summary blocks
+   * @returns Text with details/summary converted to Linear format
+   */
+  static convertDetailsToLinear(text) {
+    if (!text) {
+      return text;
+    }
+    let previousText = "";
+    let currentText = text;
+    while (previousText !== currentText) {
+      previousText = currentText;
+      currentText = this.convertSinglePass(currentText);
+    }
+    return currentText;
+  }
+  /**
+   * Perform a single pass of details block conversion
+   * Converts the innermost details blocks first
+   */
+  static convertSinglePass(text) {
+    const detailsRegex = /<details[^>]*>\s*<summary[^>]*>(.*?)<\/summary>\s*(.*?)\s*<\/details>/gis;
+    return text.replace(detailsRegex, (_match, summary, content) => {
+      const cleanSummary = this.cleanText(summary);
+      const cleanContent = this.cleanContent(content);
+      if (cleanContent) {
+        return `+++ ${cleanSummary}
+
+${cleanContent}
+
++++`;
+      } else {
+        return `+++ ${cleanSummary}
+
++++`;
+      }
+    });
+  }
+  /**
+   * Clean text by trimming whitespace and decoding common HTML entities
+   */
+  static cleanText(text) {
+    return text.trim().replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&").replace(/&quot;/g, '"').replace(/&#39;/g, "'");
+  }
+  /**
+   * Clean content while preserving internal structure
+   * - Removes leading/trailing whitespace
+   * - Normalizes internal blank lines (max 2 consecutive newlines)
+   * - Preserves code blocks and other formatting
+   */
+  static cleanContent(content) {
+    if (!content) {
+      return "";
+    }
+    let cleaned = content.trim();
+    cleaned = cleaned.replace(/\n{3,}/g, "\n\n");
+    return cleaned;
+  }
+  /**
+   * Check if text contains HTML details/summary blocks
+   * Useful for conditional conversion
+   */
+  static hasDetailsBlocks(text) {
+    if (!text) {
+      return false;
+    }
+    const detailsRegex = /<details[^>]*>.*?<summary[^>]*>.*?<\/summary>.*?<\/details>/is;
+    return detailsRegex.test(text);
+  }
+  /**
+   * Remove wrapper tags from code sample details blocks
+   * Identifies details blocks where summary contains "X lines" pattern
+   * and removes the details/summary tags while preserving the content
+   *
+   * @param text - Text containing potential code sample details blocks
+   * @returns Text with code sample wrappers removed
+   */
+  static removeCodeSampleWrappers(text) {
+    if (!text) {
+      return text;
+    }
+    const codeSampleRegex = /<details[^>]*>\s*<summary[^>]*>([^<]*\d+\s+lines[^<]*)<\/summary>\s*([\s\S]*?)<\/details>/gi;
+    return text.replace(codeSampleRegex, (_match, _summary, content) => {
+      return content.trim();
+    });
+  }
+  /**
+   * Convert text for Linear - applies all necessary conversions
+   * Currently only converts details/summary blocks, but can be extended
+   * for other HTML to Linear markdown conversions
+   */
+  static convertToLinear(text) {
+    if (!text) {
+      return text;
+    }
+    this.logConversion("INPUT", text);
+    let converted = text;
+    converted = this.removeCodeSampleWrappers(converted);
+    converted = this.convertDetailsToLinear(converted);
+    this.logConversion("OUTPUT", converted);
+    return converted;
+  }
+  /**
+   * Log conversion input/output if LINEAR_MARKDOWN_LOG_FILE is set
+   */
+  static logConversion(label, content) {
+    const logFilePath = process.env.LINEAR_MARKDOWN_LOG_FILE;
+    if (!logFilePath) {
+      return;
+    }
+    try {
+      const timestampedPath = this.getTimestampedLogPath(logFilePath);
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      const separator = "================================";
+      const logEntry = `${separator}
+[${timestamp}] CONVERSION ${label}
+${separator}
+${label}:
+${content}
+
+`;
+      appendFileSync(timestampedPath, logEntry, "utf-8");
+    } catch {
+    }
+  }
+  /**
+   * Generate timestamped log file path
+   * Example: debug.log -> debug-20231202-161234.log
+   */
+  static getTimestampedLogPath(logFilePath) {
+    const dir = dirname(logFilePath);
+    const ext = extname(logFilePath);
+    const base = basename(logFilePath, ext);
+    const now = /* @__PURE__ */ new Date();
+    const timestamp = [
+      now.getFullYear(),
+      String(now.getMonth() + 1).padStart(2, "0"),
+      String(now.getDate()).padStart(2, "0")
+    ].join("") + "-" + [
+      String(now.getHours()).padStart(2, "0"),
+      String(now.getMinutes()).padStart(2, "0"),
+      String(now.getSeconds()).padStart(2, "0")
+    ].join("");
+    return join2(dir, `${base}-${timestamp}${ext}`);
+  }
+};
+
+// src/mcp/LinearIssueManagementProvider.ts
+var LinearIssueManagementProvider = class {
+  constructor() {
+    this.providerName = "linear";
+  }
+  /**
+   * Fetch issue details using Linear SDK
+   */
+  async getIssue(input) {
+    const { number, includeComments = true } = input;
+    const raw = await fetchLinearIssue(number);
+    const state = raw.state && (raw.state.toLowerCase().includes("done") || raw.state.toLowerCase().includes("completed") || raw.state.toLowerCase().includes("canceled")) ? "closed" : "open";
+    const result = {
+      id: raw.identifier,
+      title: raw.title,
+      body: raw.description ?? "",
+      state,
+      url: raw.url,
+      provider: "linear",
+      author: null,
+      // Linear SDK doesn't return author in basic fetch
+      // Linear-specific fields
+      linearState: raw.state,
+      createdAt: raw.createdAt,
+      updatedAt: raw.updatedAt
+    };
+    if (includeComments) {
+      try {
+        const comments = await this.fetchIssueComments(number);
+        if (comments) {
+          result.comments = comments;
+        }
+      } catch {
+      }
+    }
+    return result;
+  }
+  /**
+   * Fetch comments for an issue
+   */
+  async fetchIssueComments(identifier) {
+    try {
+      const comments = await fetchLinearIssueComments(identifier);
+      return comments.map((comment) => ({
+        id: comment.id,
+        body: comment.body,
+        createdAt: comment.createdAt,
+        author: null,
+        // Linear SDK doesn't return comment author info in basic fetch
+        ...comment.updatedAt && { updatedAt: comment.updatedAt }
+      }));
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Fetch a specific comment by ID
+   */
+  async getComment(input) {
+    const { commentId } = input;
+    const raw = await getLinearComment(commentId);
+    return {
+      id: raw.id,
+      body: raw.body,
+      author: null,
+      // Linear SDK doesn't return comment author info in basic fetch
+      created_at: raw.createdAt
+    };
+  }
+  /**
+   * Create a new comment on an issue
+   */
+  async createComment(input) {
+    const { number, body } = input;
+    const convertedBody = LinearMarkupConverter.convertToLinear(body);
+    const result = await createLinearComment(number, convertedBody);
+    return {
+      id: result.id,
+      url: result.url,
+      created_at: result.createdAt
+    };
+  }
+  /**
+   * Update an existing comment
+   */
+  async updateComment(input) {
+    const { commentId, body } = input;
+    const convertedBody = LinearMarkupConverter.convertToLinear(body);
+    const result = await updateLinearComment(commentId, convertedBody);
+    return {
+      id: result.id,
+      url: result.url,
+      updated_at: result.updatedAt
+    };
+  }
+};
+
+// src/mcp/IssueManagementProviderFactory.ts
+var IssueManagementProviderFactory = class {
+  /**
+   * Create an issue management provider based on the provider type
+   */
+  static create(provider) {
+    switch (provider) {
+      case "github":
+        return new GitHubIssueManagementProvider();
+      case "linear":
+        return new LinearIssueManagementProvider();
+      default:
+        throw new Error(`Unsupported issue management provider: ${provider}`);
+    }
+  }
+};
+
+// src/lib/SessionSummaryService.ts
+var SessionSummaryService = class {
+  constructor(templateManager, metadataManager, settingsManager) {
+    this.templateManager = templateManager ?? new PromptTemplateManager();
+    this.metadataManager = metadataManager ?? new MetadataManager();
+    this.settingsManager = settingsManager ?? new SettingsManager();
+  }
+  /**
+   * Generate and post a session summary to the issue
+   *
+   * Non-blocking: Catches all errors and logs warnings instead of throwing
+   * This ensures the finish workflow continues even if summary generation fails
+   */
+  async generateAndPostSummary(input) {
+    try {
+      if (input.loomType === "branch") {
+        logger.debug("Skipping session summary: branch type has no associated issue");
+        return;
+      }
+      const metadata = await this.metadataManager.readMetadata(input.worktreePath);
+      const sessionId = (metadata == null ? void 0 : metadata.sessionId) ?? generateDeterministicSessionId(input.worktreePath);
+      const settings = await this.settingsManager.loadSettings(input.worktreePath);
+      if (!this.shouldGenerateSummary(input.loomType, settings)) {
+        logger.debug(`Skipping session summary: generateSummary is disabled for ${input.loomType} workflow`);
+        return;
+      }
+      logger.info("Generating session summary...");
+      logger.debug(`Looking for session transcript with sessionId: ${sessionId}`);
+      const compactSummaries = await readSessionContext(input.worktreePath, sessionId);
+      if (compactSummaries) {
+        logger.debug(`Found compact summaries (${compactSummaries.length} chars)`);
+      } else {
+        logger.debug("No compact summaries found in session transcript");
+      }
+      const prompt = await this.templateManager.getPrompt("session-summary", {
+        ISSUE_NUMBER: String(input.issueNumber),
+        BRANCH_NAME: input.branchName,
+        LOOM_TYPE: input.loomType,
+        COMPACT_SUMMARIES: compactSummaries ?? ""
+      });
+      logger.debug("Session summary prompt:\n" + prompt);
+      const summaryModel = this.settingsManager.getSummaryModel(settings);
+      const summaryResult = await launchClaude(prompt, {
+        headless: true,
+        model: summaryModel,
+        sessionId
+        // Resume this session so Claude has conversation context
+      });
+      if (!summaryResult || typeof summaryResult !== "string" || summaryResult.trim() === "") {
+        logger.warn("Session summary generation returned empty result");
+        return;
+      }
+      const summary = summaryResult.trim();
+      if (summary.length < 100) {
+        logger.warn("Session summary too short, skipping post");
+        return;
+      }
+      await this.postSummaryToIssue(input.issueNumber, summary, settings);
+      logger.success("Session summary posted to issue");
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger.warn(`Failed to generate session summary: ${errorMessage}`);
+      logger.debug("Session summary generation error details:", { error });
+    }
+  }
+  /**
+   * Generate a session summary without posting it
+   *
+   * This method is useful for previewing the summary or for use by CLI commands
+   * that want to display the summary before optionally posting it.
+   *
+   * @param worktreePath - Path to the worktree
+   * @param branchName - Name of the branch
+   * @param loomType - Type of loom ('issue' | 'pr' | 'branch')
+   * @param issueNumber - Issue or PR number (optional, for template variables)
+   * @returns The generated summary and session ID
+   * @throws Error if Claude invocation fails
+   */
+  async generateSummary(worktreePath, branchName, loomType, issueNumber) {
+    const metadata = await this.metadataManager.readMetadata(worktreePath);
+    const sessionId = (metadata == null ? void 0 : metadata.sessionId) ?? generateDeterministicSessionId(worktreePath);
+    const settings = await this.settingsManager.loadSettings(worktreePath);
+    logger.info("Generating session summary...");
+    logger.debug(`Looking for session transcript with sessionId: ${sessionId}`);
+    const compactSummaries = await readSessionContext(worktreePath, sessionId);
+    if (compactSummaries) {
+      logger.debug(`Found compact summaries (${compactSummaries.length} chars)`);
+    } else {
+      logger.debug("No compact summaries found in session transcript");
+    }
+    const prompt = await this.templateManager.getPrompt("session-summary", {
+      ISSUE_NUMBER: issueNumber !== void 0 ? String(issueNumber) : "",
+      BRANCH_NAME: branchName,
+      LOOM_TYPE: loomType,
+      COMPACT_SUMMARIES: compactSummaries ?? ""
+    });
+    logger.debug("Session summary prompt:\n" + prompt);
+    const summaryModel = this.settingsManager.getSummaryModel(settings);
+    const summaryResult = await launchClaude(prompt, {
+      headless: true,
+      model: summaryModel,
+      sessionId
+    });
+    if (!summaryResult || typeof summaryResult !== "string" || summaryResult.trim() === "") {
+      throw new Error("Session summary generation returned empty result");
+    }
+    const summary = summaryResult.trim();
+    if (summary.length < 100) {
+      throw new Error("Session summary too short - generation may have failed");
+    }
+    return {
+      summary,
+      sessionId
+    };
+  }
+  /**
+   * Post a summary to an issue (used by both generateAndPostSummary and CLI commands)
+   *
+   * @param issueNumber - Issue or PR number to post to
+   * @param summary - The summary text to post
+   * @param worktreePath - Path to worktree for loading settings (optional)
+   */
+  async postSummary(issueNumber, summary, worktreePath) {
+    const settings = await this.settingsManager.loadSettings(worktreePath);
+    await this.postSummaryToIssue(issueNumber, summary, settings);
+    logger.success("Session summary posted to issue");
+  }
+  /**
+   * Determine if summary should be generated based on loom type and settings
+   *
+   * @param loomType - The type of loom being finished
+   * @param settings - The loaded iloom settings
+   * @returns true if summary should be generated
+   */
+  shouldGenerateSummary(loomType, settings) {
+    var _a, _b;
+    if (loomType === "branch") {
+      return false;
+    }
+    const workflowConfig = loomType === "issue" ? (_a = settings.workflows) == null ? void 0 : _a.issue : (_b = settings.workflows) == null ? void 0 : _b.pr;
+    return (workflowConfig == null ? void 0 : workflowConfig.generateSummary) ?? true;
+  }
+  /**
+   * Post the summary as a comment to the issue
+   */
+  async postSummaryToIssue(issueNumber, summary, settings) {
+    var _a;
+    const providerType = ((_a = settings.issueManagement) == null ? void 0 : _a.provider) ?? "github";
+    const provider = IssueManagementProviderFactory.create(providerType);
+    await provider.createComment({
+      number: String(issueNumber),
+      body: summary,
+      type: "issue"
+    });
+  }
+};
+
+export {
+  SessionSummaryService
+};
+//# sourceMappingURL=chunk-TMZAVPGF.js.map