markupr 2.4.0 → 2.6.0

package/dist/cli/index.mjs

@@ -1,14 +1,724 @@
 #!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/integrations/linear/types.ts
+var SEVERITY_TO_PRIORITY, CATEGORY_TO_LABEL;
+var init_types = __esm({
+  "src/integrations/linear/types.ts"() {
+    "use strict";
+    SEVERITY_TO_PRIORITY = {
+      Critical: 1,
+      High: 2,
+      Medium: 3,
+      Low: 4
+    };
+    CATEGORY_TO_LABEL = {
+      "Bug": "Bug",
+      "UX Issue": "Improvement",
+      "Suggestion": "Feature",
+      "Performance": "Bug",
+      "Question": "Feature",
+      "General": "Feature"
+    };
+  }
+});
+
+// src/integrations/linear/LinearIssueCreator.ts
+var LinearIssueCreator_exports = {};
+__export(LinearIssueCreator_exports, {
+  LinearIssueCreator: () => LinearIssueCreator,
+  parseMarkdownReport: () => parseMarkdownReport
+});
+import { readFile as readFile3 } from "fs/promises";
+function parseMarkdownReport(markdown) {
+  const items = [];
+  const itemPattern = /^### (FB-\d+): (.+)$/gm;
+  const matches = [];
+  let match;
+  while ((match = itemPattern.exec(markdown)) !== null) {
+    matches.push({ index: match.index, id: match[1], title: match[2] });
+  }
+  for (let i = 0; i < matches.length; i++) {
+    const start = matches[i].index;
+    const end = i + 1 < matches.length ? matches[i + 1].index : markdown.length;
+    const section = markdown.slice(start, end);
+    const severity = extractField(section, "Severity") || "Medium";
+    const category = extractField(section, "Type") || "General";
+    const timestamp = extractField(section, "Timestamp") || "00:00";
+    const description = extractBlockquote(section);
+    const screenshotPaths = extractScreenshots(section);
+    const suggestedAction = extractSuggestedAction(section);
+    items.push({
+      id: matches[i].id,
+      title: matches[i].title,
+      severity,
+      category,
+      timestamp,
+      description,
+      screenshotPaths,
+      suggestedAction
+    });
+  }
+  return items;
+}
+function extractField(section, fieldName) {
+  const pattern = new RegExp(`\\*\\*${fieldName}:\\*\\*\\s*(.+)`, "m");
+  const match = section.match(pattern);
+  return match ? match[1].trim() : "";
+}
+function extractBlockquote(section) {
+  const whatHappened = section.match(/#### What Happened\s*\n([\s\S]*?)(?=\n####|\n---)/);
+  if (!whatHappened) return "";
+  const lines = whatHappened[1].split("\n").filter((line) => line.startsWith(">")).map((line) => line.replace(/^>\s*/, "").trim());
+  return lines.join(" ").trim();
+}
+function extractScreenshots(section) {
+  const paths = [];
+  const pattern = /!\[.*?\]\((.+?)\)/g;
+  let match;
+  while ((match = pattern.exec(section)) !== null) {
+    paths.push(match[1]);
+  }
+  return paths;
+}
+function extractSuggestedAction(section) {
+  const actionSection = section.match(/#### Suggested Next Step\s*\n-\s*(.+)/);
+  return actionSection ? actionSection[1].trim() : "";
+}
+var LINEAR_API_URL, LinearIssueCreator;
+var init_LinearIssueCreator = __esm({
+  "src/integrations/linear/LinearIssueCreator.ts"() {
+    "use strict";
+    init_types();
+    LINEAR_API_URL = "https://api.linear.app/graphql";
+    LinearIssueCreator = class {
+      token;
+      constructor(token) {
+        this.token = token;
+      }
+      /**
+       * Push a markupr report to Linear, creating one issue per feedback item.
+       */
+      async pushReport(reportPath, options) {
+        const markdown = await readFile3(reportPath, "utf-8");
+        const items = parseMarkdownReport(markdown);
+        const team = await this.resolveTeam(options.teamKey);
+        const labels = await this.getTeamLabels(team.id);
+        const result = {
+          teamKey: options.teamKey,
+          totalItems: items.length,
+          created: 0,
+          failed: 0,
+          issues: [],
+          dryRun: options.dryRun ?? false
+        };
+        for (const item of items) {
+          const labelName = CATEGORY_TO_LABEL[item.category] ?? "Feature";
+          const matchingLabel = labels.find(
+            (l) => l.name.toLowerCase() === labelName.toLowerCase()
+          );
+          const issueInput = {
+            title: `[${item.id}] ${item.title}`,
+            description: this.buildIssueDescription(item),
+            teamId: team.id,
+            priority: SEVERITY_TO_PRIORITY[item.severity] ?? 3,
+            labelIds: matchingLabel ? [matchingLabel.id] : void 0,
+            projectId: options.projectName ? await this.resolveProjectId(team.id, options.projectName) : void 0
+          };
+          if (options.dryRun) {
+            result.issues.push({
+              success: true,
+              issueId: `dry-run-${item.id}`,
+              identifier: `DRY-${item.id}`,
+              issueUrl: `https://linear.app/dry-run/${item.id}`
+            });
+            result.created++;
+            continue;
+          }
+          const issueResult = await this.createIssue(issueInput);
+          result.issues.push(issueResult);
+          if (issueResult.success) {
+            result.created++;
+          } else {
+            result.failed++;
+          }
+        }
+        return result;
+      }
+      /**
+       * Create a single Linear issue via GraphQL.
+       */
+      async createIssue(input) {
+        const mutation = `
+      mutation IssueCreate($input: IssueCreateInput!) {
+        issueCreate(input: $input) {
+          success
+          issue {
+            id
+            url
+            identifier
+          }
+        }
+      }
+    `;
+        const variables = {
+          input: {
+            title: input.title,
+            description: input.description,
+            teamId: input.teamId,
+            priority: input.priority,
+            ...input.labelIds && { labelIds: input.labelIds },
+            ...input.projectId && { projectId: input.projectId }
+          }
+        };
+        try {
+          const data = await this.graphql(mutation, variables);
+          if (data.issueCreate.success) {
+            return {
+              success: true,
+              issueId: data.issueCreate.issue.id,
+              issueUrl: data.issueCreate.issue.url,
+              identifier: data.issueCreate.issue.identifier
+            };
+          }
+          return { success: false, error: "Linear API returned success: false" };
+        } catch (error) {
+          return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error)
+          };
+        }
+      }
+      /**
+       * Resolve a team key (e.g., "ENG") to a team ID.
+       */
+      async resolveTeam(teamKey) {
+        const query = `
+      query Teams {
+        teams {
+          nodes {
+            id
+            key
+            name
+          }
+        }
+      }
+    `;
+        const data = await this.graphql(query);
+        const team = data.teams.nodes.find(
+          (t) => t.key.toLowerCase() === teamKey.toLowerCase()
+        );
+        if (!team) {
+          const available = data.teams.nodes.map((t) => t.key).join(", ");
+          throw new Error(
+            `Team "${teamKey}" not found. Available teams: ${available}`
+          );
+        }
+        return team;
+      }
+      /**
+       * Get all labels for a team.
+       */
+      async getTeamLabels(teamId) {
+        const query = `
+      query TeamLabels($teamId: String!) {
+        team(id: $teamId) {
+          labels {
+            nodes {
+              id
+              name
+            }
+          }
+        }
+      }
+    `;
+        const data = await this.graphql(query, { teamId });
+        return data.team.labels.nodes;
+      }
+      /**
+       * Resolve a project name to a project ID within a team.
+       */
+      async resolveProjectId(teamId, projectName) {
+        const query = `
+      query Projects($teamId: String!) {
+        team(id: $teamId) {
+          projects {
+            nodes {
+              id
+              name
+            }
+          }
+        }
+      }
+    `;
+        const data = await this.graphql(query, { teamId });
+        const project = data.team.projects.nodes.find(
+          (p) => p.name.toLowerCase() === projectName.toLowerCase()
+        );
+        return project?.id;
+      }
+      /**
+       * Build markdown description for a Linear issue from a feedback item.
+       */
+      buildIssueDescription(item) {
+        let desc = `## markupr Feedback: ${item.id}
+
+`;
+        desc += `**Severity:** ${item.severity}
+`;
+        desc += `**Category:** ${item.category}
+`;
+        desc += `**Timestamp:** ${item.timestamp}
+
+`;
+        desc += `### Description
+
+${item.description}
+
+`;
+        if (item.suggestedAction) {
+          desc += `### Suggested Action
+
+${item.suggestedAction}
+
+`;
+        }
+        if (item.screenshotPaths.length > 0) {
+          desc += `### Screenshots
+
+`;
+          desc += `_${item.screenshotPaths.length} screenshot(s) captured during session._
+`;
+          for (const path3 of item.screenshotPaths) {
+            desc += `- \`${path3}\`
+`;
+          }
+        }
+        desc += `
+---
+*Created by [markupr](https://markupr.com)*`;
+        return desc;
+      }
+      /**
+       * Execute a GraphQL request against the Linear API.
+       */
+      async graphql(query, variables) {
+        const response = await fetch(LINEAR_API_URL, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: this.token
+          },
+          body: JSON.stringify({ query, variables })
+        });
+        if (!response.ok) {
+          throw new Error(
+            `Linear API error: ${response.status} ${response.statusText}`
+          );
+        }
+        const json = await response.json();
+        if (json.errors && json.errors.length > 0) {
+          throw new Error(`Linear GraphQL error: ${json.errors[0].message}`);
+        }
+        if (!json.data) {
+          throw new Error("Linear API returned no data");
+        }
+        return json.data;
+      }
+    };
+  }
+});
+
+// src/integrations/github/types.ts
+var CATEGORY_LABELS, SEVERITY_LABELS, MARKUPR_LABEL;
+var init_types2 = __esm({
+  "src/integrations/github/types.ts"() {
+    "use strict";
+    CATEGORY_LABELS = {
+      Bug: { name: "bug", color: "d73a4a", description: "Something isn't working" },
+      "UX Issue": { name: "ux", color: "e4e669", description: "User experience issue" },
+      Suggestion: { name: "enhancement", color: "a2eeef", description: "New feature or request" },
+      Performance: { name: "performance", color: "f9d0c4", description: "Performance issue" },
+      Question: { name: "question", color: "d876e3", description: "Further information is requested" },
+      General: { name: "feedback", color: "c5def5", description: "General feedback" }
+    };
+    SEVERITY_LABELS = {
+      Critical: { name: "priority: critical", color: "b60205", description: "Critical priority" },
+      High: { name: "priority: high", color: "d93f0b", description: "High priority" },
+      Medium: { name: "priority: medium", color: "fbca04", description: "Medium priority" },
+      Low: { name: "priority: low", color: "0e8a16", description: "Low priority" }
+    };
+    MARKUPR_LABEL = {
+      name: "markupr",
+      color: "6f42c1",
+      description: "Created from markupr feedback session"
+    };
+  }
+});
+
+// src/integrations/github/GitHubIssueCreator.ts
+var GitHubIssueCreator_exports = {};
+__export(GitHubIssueCreator_exports, {
+  GitHubAPIClient: () => GitHubAPIClient,
+  collectRequiredLabels: () => collectRequiredLabels,
+  formatIssueBody: () => formatIssueBody,
+  getLabelsForItem: () => getLabelsForItem,
+  parseMarkuprReport: () => parseMarkuprReport,
+  parseRepoString: () => parseRepoString,
+  pushToGitHub: () => pushToGitHub,
+  resolveAuth: () => resolveAuth
+});
+import { readFile as readFile4 } from "fs/promises";
+async function resolveAuth(explicitToken) {
+  if (explicitToken) {
+    return { token: explicitToken, source: "flag" };
+  }
+  const envToken = process.env.GITHUB_TOKEN;
+  if (envToken) {
+    return { token: envToken, source: "env" };
+  }
+  try {
+    const { execSync } = await import("child_process");
+    const ghToken = execSync("gh auth token", { encoding: "utf-8", timeout: 5e3 }).trim();
+    if (ghToken) {
+      return { token: ghToken, source: "gh-cli" };
+    }
+  } catch {
+  }
+  throw new Error(
+    "No GitHub token found. Provide one via:\n  --token <token>\n  GITHUB_TOKEN environment variable\n  gh auth login (GitHub CLI)"
+  );
+}
+function parseMarkuprReport(markdown) {
+  const items = [];
+  const itemPattern = /### (FB-\d{3}): (.+?)(?=\n)/g;
+  let match;
+  while ((match = itemPattern.exec(markdown)) !== null) {
+    const id = match[1];
+    const title = match[2].trim();
+    const startIndex = match.index;
+    const rest = markdown.slice(startIndex + match[0].length);
+    const nextSectionMatch = rest.match(/\n### FB-\d{3}:|(?=\n## [A-Z])/);
+    const itemBlock = nextSectionMatch ? rest.slice(0, nextSectionMatch.index) : rest;
+    const severity = extractField2(itemBlock, "Severity") || "Medium";
+    const category = extractField2(itemBlock, "Type") || "General";
+    const timestamp = extractField2(itemBlock, "Timestamp") || "00:00";
+    const transcription = extractTranscription(itemBlock);
+    const screenshotPaths = extractScreenshots2(itemBlock);
+    const suggestedAction = extractSuggestedAction2(itemBlock);
+    items.push({
+      id,
+      title,
+      category,
+      severity,
+      timestamp,
+      transcription,
+      screenshotPaths,
+      suggestedAction
+    });
+  }
+  return items;
+}
+function extractField2(block, fieldName) {
+  const pattern = new RegExp(`\\*\\*${fieldName}:\\*\\*\\s*(.+)`);
+  const match = block.match(pattern);
+  return match ? match[1].trim() : void 0;
+}
+function extractTranscription(block) {
+  const whatHappenedIdx = block.indexOf("#### What Happened");
+  if (whatHappenedIdx === -1) return "";
+  const afterHeading = block.slice(whatHappenedIdx);
+  const nextHeading = afterHeading.indexOf("\n####", 5);
+  const section = nextHeading !== -1 ? afterHeading.slice(0, nextHeading) : afterHeading;
+  const lines = section.split("\n");
+  const quotedLines = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("> ")) {
+      quotedLines.push(trimmed.slice(2));
+    } else if (trimmed === ">") {
+      quotedLines.push("");
+    }
+  }
+  return quotedLines.join(" ").trim();
+}
+function extractScreenshots2(block) {
+  const paths = [];
+  const pattern = /!\[.*?\]\((.+?)\)/g;
+  let match;
+  while ((match = pattern.exec(block)) !== null) {
+    paths.push(match[1]);
+  }
+  return paths;
+}
+function extractSuggestedAction2(block) {
+  const idx = block.indexOf("#### Suggested Next Step");
+  if (idx === -1) return "";
+  const afterHeading = block.slice(idx + "#### Suggested Next Step".length);
+  const nextSection = afterHeading.indexOf("\n---");
+  const section = nextSection !== -1 ? afterHeading.slice(0, nextSection) : afterHeading;
+  const lines = section.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("- ")) {
+      return trimmed.slice(2);
+    }
+  }
+  return "";
+}
+function formatIssueBody(item, reportPath) {
+  let body = `## ${item.id}: ${item.title}
+
+`;
+  body += `| Field | Value |
+|-------|-------|
+`;
+  body += `| **Severity** | ${item.severity} |
+`;
+  body += `| **Category** | ${item.category} |
+`;
+  body += `| **Timestamp** | ${item.timestamp} |
+
+`;
+  body += `### What Happened
+
+`;
+  body += `> ${item.transcription}
+
+`;
+  if (item.screenshotPaths.length > 0) {
+    body += `### Screenshots
+
+`;
+    body += `_${item.screenshotPaths.length} screenshot(s) captured \u2014 see the markupr report for images._
+
+`;
+  }
+  if (item.suggestedAction) {
+    body += `### Suggested Action
+
+`;
+    body += `${item.suggestedAction}
+
+`;
+  }
+  body += `---
+`;
+  if (reportPath) {
+    body += `_Source: \`${reportPath}\`_
+`;
+  }
+  body += `_Created by [markupr](https://markupr.com)_
+`;
+  return body;
+}
+function getLabelsForItem(item) {
+  const labels = [MARKUPR_LABEL.name];
+  const categoryLabel = CATEGORY_LABELS[item.category];
+  if (categoryLabel) {
+    labels.push(categoryLabel.name);
+  }
+  const severityLabel = SEVERITY_LABELS[item.severity];
+  if (severityLabel) {
+    labels.push(severityLabel.name);
+  }
+  return labels;
+}
+function collectRequiredLabels(items) {
+  const seen = /* @__PURE__ */ new Set();
+  const labels = [];
+  seen.add(MARKUPR_LABEL.name);
+  labels.push(MARKUPR_LABEL);
+  for (const item of items) {
+    const catLabel = CATEGORY_LABELS[item.category];
+    if (catLabel && !seen.has(catLabel.name)) {
+      seen.add(catLabel.name);
+      labels.push(catLabel);
+    }
+    const sevLabel = SEVERITY_LABELS[item.severity];
+    if (sevLabel && !seen.has(sevLabel.name)) {
+      seen.add(sevLabel.name);
+      labels.push(sevLabel);
+    }
+  }
+  return labels;
+}
+async function pushToGitHub(options) {
+  const { repo, auth, reportPath, dryRun = false, items: filterIds } = options;
+  const markdown = await readFile4(reportPath, "utf-8");
+  let items = parseMarkuprReport(markdown);
+  if (items.length === 0) {
+    throw new Error("No feedback items found in the report. Is this a valid markupr report?");
+  }
+  if (filterIds && filterIds.length > 0) {
+    const filterSet = new Set(filterIds.map((id) => id.toUpperCase()));
+    items = items.filter((item) => filterSet.has(item.id));
+    if (items.length === 0) {
+      throw new Error(`None of the specified items (${filterIds.join(", ")}) found in the report`);
+    }
+  }
+  const result = {
+    created: [],
+    labelsCreated: [],
+    errors: [],
+    dryRun
+  };
+  if (dryRun) {
+    for (const item of items) {
+      const labels = getLabelsForItem(item);
+      result.created.push({
+        number: 0,
+        url: "",
+        title: `[${item.id}] ${item.title}`
+      });
+    }
+    result.labelsCreated = collectRequiredLabels(items).map((l) => l.name);
+    return result;
+  }
+  const client = new GitHubAPIClient(auth);
+  await client.verifyAccess(repo);
+  const requiredLabels = collectRequiredLabels(items);
+  for (const label of requiredLabels) {
+    try {
+      const created = await client.ensureLabel(repo, label);
+      if (created) {
+        result.labelsCreated.push(label.name);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      result.errors.push({ itemId: "labels", error: message });
+    }
+  }
+  for (const item of items) {
+    try {
+      const labels = getLabelsForItem(item);
+      const body = formatIssueBody(item, reportPath);
+      const issueResult = await client.createIssue(repo, {
+        title: `[${item.id}] ${item.title}`,
+        body,
+        labels
+      });
+      result.created.push(issueResult);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      result.errors.push({ itemId: item.id, error: message });
+    }
+  }
+  return result;
+}
+function parseRepoString(repoStr) {
+  const parts = repoStr.split("/");
+  if (parts.length !== 2 || !parts[0] || !parts[1]) {
+    throw new Error(`Invalid repository format: "${repoStr}". Expected "owner/repo".`);
+  }
+  return { owner: parts[0], repo: parts[1] };
+}
+var GITHUB_API, GitHubAPIClient;
+var init_GitHubIssueCreator = __esm({
+  "src/integrations/github/GitHubIssueCreator.ts"() {
+    "use strict";
+    init_types2();
+    GITHUB_API = "https://api.github.com";
+    GitHubAPIClient = class {
+      baseUrl;
+      headers;
+      constructor(auth, baseUrl = GITHUB_API) {
+        this.baseUrl = baseUrl;
+        this.headers = {
+          Authorization: `Bearer ${auth.token}`,
+          Accept: "application/vnd.github+json",
+          "X-GitHub-Api-Version": "2022-11-28",
+          "Content-Type": "application/json",
+          "User-Agent": "markupr-github-integration"
+        };
+      }
+      async createIssue(repo, input) {
+        const url = `${this.baseUrl}/repos/${repo.owner}/${repo.repo}/issues`;
+        const response = await fetch(url, {
+          method: "POST",
+          headers: this.headers,
+          body: JSON.stringify({
+            title: input.title,
+            body: input.body,
+            labels: input.labels
+          })
+        });
+        if (!response.ok) {
+          const text = await response.text();
+          throw new Error(`GitHub API error (${response.status}): ${text}`);
+        }
+        const data = await response.json();
+        return {
+          number: data.number,
+          url: data.html_url,
+          title: data.title
+        };
+      }
+      async ensureLabel(repo, label) {
+        const url = `${this.baseUrl}/repos/${repo.owner}/${repo.repo}/labels`;
+        const checkUrl = `${url}/${encodeURIComponent(label.name)}`;
+        const checkResponse = await fetch(checkUrl, {
+          method: "GET",
+          headers: this.headers
+        });
+        if (checkResponse.ok) {
+          return false;
+        }
+        const createResponse = await fetch(url, {
+          method: "POST",
+          headers: this.headers,
+          body: JSON.stringify({
+            name: label.name,
+            color: label.color,
+            description: label.description
+          })
+        });
+        if (!createResponse.ok) {
+          if (createResponse.status === 422) {
+            return false;
+          }
+          const text = await createResponse.text();
+          throw new Error(`Failed to create label "${label.name}": ${text}`);
+        }
+        return true;
+      }
+      async verifyAccess(repo) {
+        const url = `${this.baseUrl}/repos/${repo.owner}/${repo.repo}`;
+        const response = await fetch(url, {
+          method: "GET",
+          headers: this.headers
+        });
+        if (!response.ok) {
+          if (response.status === 404) {
+            throw new Error(`Repository ${repo.owner}/${repo.repo} not found (or no access)`);
+          }
+          if (response.status === 401) {
+            throw new Error("GitHub token is invalid or expired");
+          }
+          throw new Error(`Failed to access repository (${response.status})`);
+        }
+      }
+    };
+  }
+});
 
 // src/cli/index.ts
-import { existsSync as existsSync4 } from "fs";
-import { resolve } from "path";
+import { existsSync as existsSync7 } from "fs";
+import { resolve as resolve3 } from "path";
 import { Command } from "commander";
 
 // src/cli/CLIPipeline.ts
@@ -435,7 +1145,7 @@ ${REPORT_SUPPORT_LINE}
     const screenshotCount = this.countScreenshots(items);
     const topThemes = this.extractTopThemes(items);
     const highImpactCount = (severityCounts.Critical || 0) + (severityCounts.High || 0);
-    const platform = session.metadata?.os || process?.platform || "Unknown";
+    const platform2 = session.metadata?.os || process?.platform || "Unknown";
     let content = `# ${projectName} Feedback Report
 > Generated by markupr on ${timestamp}
 > Duration: ${duration} | Items: ${items.length} | Screenshots: ${screenshotCount}
@@ -443,7 +1153,7 @@ ${REPORT_SUPPORT_LINE}
 ## Session Overview
 - **Session ID:** \`${session.id}\`
 - **Source:** ${session.metadata?.sourceName || "Unknown"} (${session.metadata?.sourceType || "screen"})
-- **Platform:** ${platform}
+- **Platform:** ${platform2}
 - **Segments:** ${items.length}
 - **High-impact items:** ${highImpactCount}
 
@@ -1189,7 +1899,7 @@ var WhisperService = class extends EventEmitter {
       const percent = Math.round((i + 1) / totalChunks * 100);
       onProgress?.(percent);
       if (i < totalChunks - 1) {
-        await new Promise((resolve2) => setTimeout(resolve2, 0));
+        await new Promise((resolve4) => setTimeout(resolve4, 0));
       }
     }
     this.log(`Transcription complete: ${results.length} segment(s)`);
@@ -1462,108 +2172,552 @@ var WhisperService = class extends EventEmitter {
 };
 var whisperService = new WhisperService();
 
-// src/cli/CLIPipeline.ts
-var EXIT_SUCCESS = 0;
-var EXIT_USER_ERROR = 1;
-var EXIT_SYSTEM_ERROR = 2;
-var EXIT_SIGINT = 130;
-var CLIPipeline = class _CLIPipeline {
-  options;
-  log;
-  progress;
-  tempFiles = [];
-  activeProcesses = /* @__PURE__ */ new Set();
-  constructor(options, log, progress) {
-    this.options = options;
-    this.log = log;
-    this.progress = progress ?? (() => {
-    });
-  }
+// src/main/output/templates/registry.ts
+var TemplateRegistryImpl = class {
+  templates = /* @__PURE__ */ new Map();
   /**
-   * Run the full pipeline: audio extraction -> transcription -> analysis ->
-   * frame extraction -> markdown generation.
+   * Register a template. Overwrites any existing template with the same name.
    */
-  async run() {
-    try {
-      return await this.runPipeline();
-    } finally {
-      await this.cleanup();
-    }
-  }
-  async runPipeline() {
-    const startTime = Date.now();
-    await this.validateVideoFile();
-    if (!(this.options.audioPath && this.options.skipFrames)) {
-      await this.checkFfmpegAvailable();
-    }
-    try {
-      if (!existsSync3(this.options.outputDir)) {
-        mkdirSync2(this.options.outputDir, { recursive: true });
-      }
-    } catch (error) {
-      const code = error.code;
-      if (code === "EACCES") {
-        throw new CLIPipelineError(
-          `Permission denied: cannot create output directory: ${this.options.outputDir}`,
-          "user"
-        );
-      }
-      throw new CLIPipelineError(
-        `Cannot create output directory: ${this.options.outputDir} (${code})`,
-        "system"
-      );
-    }
-    this.progress("Extracting audio...");
-    const audioPath = await this.resolveAudioPath();
-    this.progress("Transcribing (this may take a while)...");
-    const segments = await this.transcribe(audioPath);
-    const analyzer = new TranscriptAnalyzer();
-    const keyMoments = analyzer.analyze(segments);
-    this.log(`  Found ${keyMoments.length} key moment(s)`);
-    let extractedFrames = [];
-    if (!this.options.skipFrames) {
-      this.progress("Extracting frames...");
-      extractedFrames = await this.extractFrames(keyMoments, segments);
-    } else {
-      this.log("  Frame extraction skipped (--no-frames)");
-    }
-    this.progress("Generating report...");
-    const result = {
-      transcriptSegments: segments,
-      extractedFrames,
-      reportPath: this.options.outputDir
-    };
-    const generator = new MarkdownGeneratorImpl();
-    const markdown = generator.generateFromPostProcess(result, this.options.outputDir);
-    const outputFilename = this.generateOutputFilename();
-    const outputPath = join3(this.options.outputDir, outputFilename);
-    try {
-      await writeFile(outputPath, markdown, "utf-8");
-    } catch (error) {
-      const code = error.code;
-      throw new CLIPipelineError(
-        `Failed to write output file: ${outputPath}
-  Reason: ${code === "ENOSPC" ? "Disk is full" : error.message}`,
-        "system"
-      );
-    }
-    const durationSeconds = (Date.now() - startTime) / 1e3;
-    return {
-      outputPath,
-      transcriptSegments: segments.length,
-      extractedFrames: extractedFrames.length,
-      durationSeconds
-    };
+  register(template) {
+    this.templates.set(template.name, template);
   }
   /**
-   * Abort the pipeline: kill active child processes and clean up temp files.
+   * Get a template by name. Returns undefined if not found.
    */
-  async abort() {
-    for (const proc of this.activeProcesses) {
-      proc.kill("SIGTERM");
-    }
-    this.activeProcesses.clear();
-    await this.cleanup();
+  get(name) {
+    return this.templates.get(name);
+  }
+  /**
+   * Check if a template with the given name exists.
+   */
+  has(name) {
+    return this.templates.has(name);
+  }
+  /**
+   * List all registered template names.
+   */
+  list() {
+    return Array.from(this.templates.keys());
+  }
+  /**
+   * List all registered templates with their descriptions.
+   */
+  listWithDescriptions() {
+    return Array.from(this.templates.values()).map((t) => ({
+      name: t.name,
+      description: t.description,
+      fileExtension: t.fileExtension
+    }));
+  }
+  /**
+   * Get the default template name.
+   */
+  getDefault() {
+    return "markdown";
+  }
+};
+var templateRegistry = new TemplateRegistryImpl();
+
+// src/main/output/templates/helpers.ts
+import * as path2 from "path";
+function formatTimestamp(seconds) {
+  const totalSeconds = Math.max(0, Math.floor(seconds));
+  const mins = Math.floor(totalSeconds / 60);
+  const secs = totalSeconds % 60;
+  return `${mins}:${secs.toString().padStart(2, "0")}`;
+}
+function formatDuration(ms) {
+  const totalSeconds = Math.floor(ms / 1e3);
+  const mins = Math.floor(totalSeconds / 60);
+  const secs = totalSeconds % 60;
+  return `${mins}:${secs.toString().padStart(2, "0")}`;
+}
+function formatDate(date) {
+  const months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+  const month = months[date.getMonth()];
+  const day = date.getDate();
+  const year = date.getFullYear();
+  const rawHours = date.getHours();
+  const ampm = rawHours >= 12 ? "PM" : "AM";
+  const hours = rawHours % 12 || 12;
+  const minutes = date.getMinutes().toString().padStart(2, "0");
+  return `${month} ${day}, ${year} at ${hours}:${minutes} ${ampm}`;
+}
+function generateSegmentTitle(text) {
+  const firstSentence = text.split(/[.!?]/)[0].trim();
+  if (firstSentence.length <= 60) return firstSentence;
+  return firstSentence.slice(0, 57) + "...";
+}
+function wrapTranscription(transcription) {
+  if (!transcription.includes(".") && !transcription.includes("!") && !transcription.includes("?")) {
+    return transcription;
+  }
+  const sentences = transcription.split(/(?<=[.!?])\s+/).map((s) => s.trim()).filter(Boolean);
+  if (sentences.length <= 1) return transcription;
+  return sentences.join("\n> ");
+}
+function computeRelativeFramePath(framePath, sessionDir) {
+  if (!path2.isAbsolute(framePath)) {
+    return framePath;
+  }
+  return path2.relative(sessionDir, framePath);
+}
+function computeSessionDuration(segments) {
+  if (segments.length === 0) return "0:00";
+  return formatDuration(
+    (segments[segments.length - 1].endTime - segments[0].startTime) * 1e3
+  );
+}
+function mapFramesToSegments(segments, frames) {
+  const map = /* @__PURE__ */ new Map();
+  for (const frame of frames) {
+    let bestIndex = 0;
+    let bestDistance = Infinity;
+    for (let i = 0; i < segments.length; i++) {
+      const seg = segments[i];
+      if (frame.timestamp >= seg.startTime && frame.timestamp <= seg.endTime) {
+        bestIndex = i;
+        bestDistance = 0;
+        break;
+      }
+      const distance = Math.abs(frame.timestamp - seg.startTime);
+      if (distance < bestDistance) {
+        bestDistance = distance;
+        bestIndex = i;
+      }
+    }
+    const existing = map.get(bestIndex) || [];
+    existing.push(frame);
+    map.set(bestIndex, existing);
+  }
+  for (const [, frameList] of map) {
+    frameList.sort((a, b) => a.timestamp - b.timestamp);
+  }
+  return map;
+}
+
+// src/main/output/templates/markdown.ts
+var REPORT_SUPPORT_LINE2 = "*If this report saved you time, support development: [Ko-fi](https://ko-fi.com/eddiesanjuan)*";
+var markdownTemplate = {
+  name: "markdown",
+  description: "Default Markdown format \u2014 AI-ready, llms.txt-inspired structured document",
+  fileExtension: ".md",
+  render(context) {
+    const { result, sessionDir, timestamp } = context;
+    const { transcriptSegments, extractedFrames } = result;
+    const sessionTimestamp = formatDate(new Date(timestamp ?? Date.now()));
+    const sessionDuration = computeSessionDuration(transcriptSegments);
+    let md = `# markupr Session \u2014 ${sessionTimestamp}
+`;
+    md += `> Segments: ${transcriptSegments.length} | Frames: ${extractedFrames.length} | Duration: ${sessionDuration}
+
+`;
+    if (transcriptSegments.length === 0) {
+      md += `_No speech was detected during this recording._
+`;
+      return { content: md, fileExtension: ".md" };
+    }
+    md += `## Transcript
+
+`;
+    const segmentFrameMap = mapFramesToSegments(transcriptSegments, extractedFrames);
+    for (let i = 0; i < transcriptSegments.length; i++) {
+      const segment = transcriptSegments[i];
+      const formattedTime = formatTimestamp(segment.startTime);
+      const title = generateSegmentTitle(segment.text);
+      md += `### [${formattedTime}] ${title}
+`;
+      md += `> ${wrapTranscription(segment.text)}
+
+`;
+      const frames = segmentFrameMap.get(i);
+      if (frames && frames.length > 0) {
+        for (const frame of frames) {
+          const frameTimestamp = formatTimestamp(frame.timestamp);
+          const relativePath = computeRelativeFramePath(frame.path, sessionDir);
+          md += `![Frame at ${frameTimestamp}](${relativePath})
+
+`;
+        }
+      }
+    }
+    md += `---
+*Generated by [markupr](https://markupr.com)*
+${REPORT_SUPPORT_LINE2}
+`;
+    return { content: md, fileExtension: ".md" };
+  }
+};
+
+// src/main/output/templates/json.ts
+var jsonTemplate = {
+  name: "json",
+  description: "Structured JSON output for programmatic consumption",
+  fileExtension: ".json",
+  render(context) {
+    const { result, sessionDir, timestamp } = context;
+    const { transcriptSegments, extractedFrames } = result;
+    const segmentFrameMap = mapFramesToSegments(transcriptSegments, extractedFrames);
+    const output = {
+      version: "1.0",
+      generator: "markupr",
+      timestamp: new Date(timestamp ?? Date.now()).toISOString(),
+      summary: {
+        segments: transcriptSegments.length,
+        frames: extractedFrames.length,
+        duration: computeSessionDuration(transcriptSegments)
+      },
+      segments: transcriptSegments.map((segment, i) => {
+        const frames = segmentFrameMap.get(i) || [];
+        return {
+          text: segment.text,
+          startTime: segment.startTime,
+          endTime: segment.endTime,
+          confidence: segment.confidence,
+          frames: frames.map((f) => ({
+            path: computeRelativeFramePath(f.path, sessionDir),
+            timestamp: f.timestamp,
+            reason: f.reason
+          }))
+        };
+      })
+    };
+    return {
+      content: JSON.stringify(output, null, 2),
+      fileExtension: ".json"
+    };
+  }
+};
+
+// src/main/output/templates/github-issue.ts
+var githubIssueTemplate = {
+  name: "github-issue",
+  description: "GitHub-flavored Markdown optimized for issue bodies with task lists and collapsible details",
+  fileExtension: ".md",
+  render(context) {
+    const { result, sessionDir, timestamp } = context;
+    const { transcriptSegments, extractedFrames } = result;
+    const sessionTimestamp = formatDate(new Date(timestamp ?? Date.now()));
+    const duration = computeSessionDuration(transcriptSegments);
+    let md = `## Feedback Report
+
+`;
+    md += `> Captured by [markupr](https://markupr.com) on ${sessionTimestamp}
+`;
+    md += `> ${transcriptSegments.length} segments | ${extractedFrames.length} frames | Duration: ${duration}
+
+`;
+    if (transcriptSegments.length === 0) {
+      md += `_No feedback was captured during this recording._
+`;
+      return { content: md, fileExtension: ".md" };
+    }
+    md += `### Action Items
+
+`;
+    for (const segment of transcriptSegments) {
+      const title = generateSegmentTitle(segment.text);
+      md += `- [ ] ${title}
+`;
+    }
+    md += `
+`;
+    md += `### Details
+
+`;
+    const segmentFrameMap = mapFramesToSegments(transcriptSegments, extractedFrames);
+    for (let i = 0; i < transcriptSegments.length; i++) {
+      const segment = transcriptSegments[i];
+      const formattedTime = formatTimestamp(segment.startTime);
+      const title = generateSegmentTitle(segment.text);
+      md += `<details>
+`;
+      md += `<summary><strong>[${formattedTime}] ${title}</strong></summary>
+
+`;
+      md += `${segment.text}
+
+`;
+      const frames = segmentFrameMap.get(i);
+      if (frames && frames.length > 0) {
+        for (const frame of frames) {
+          const relativePath = computeRelativeFramePath(frame.path, sessionDir);
+          md += `![Screenshot](${relativePath})
+
+`;
+        }
+      }
+      md += `</details>
+
+`;
+    }
+    md += `---
+_Generated by [markupr](https://markupr.com)_
+`;
+    return { content: md, fileExtension: ".md" };
+  }
+};
+
+// src/main/output/templates/linear.ts
+var linearTemplate = {
+  name: "linear",
+  description: "Linear-compatible Markdown for issue descriptions",
+  fileExtension: ".md",
+  render(context) {
+    const { result, sessionDir, timestamp } = context;
+    const { transcriptSegments, extractedFrames } = result;
+    const sessionTimestamp = formatDate(new Date(timestamp ?? Date.now()));
+    const duration = computeSessionDuration(transcriptSegments);
+    let md = `**Feedback Report** \u2014 ${sessionTimestamp}
+`;
+    md += `${transcriptSegments.length} segments | ${extractedFrames.length} frames | Duration: ${duration}
+
+`;
+    if (transcriptSegments.length === 0) {
+      md += `_No feedback was captured during this recording._
+`;
+      return { content: md, fileExtension: ".md" };
+    }
+    md += `**Action Items**
+
+`;
+    for (const segment of transcriptSegments) {
+      const title = generateSegmentTitle(segment.text);
+      md += `- [ ] ${title}
+`;
+    }
+    md += `
+---
+
+`;
+    const segmentFrameMap = mapFramesToSegments(transcriptSegments, extractedFrames);
+    for (let i = 0; i < transcriptSegments.length; i++) {
+      const segment = transcriptSegments[i];
+      const formattedTime = formatTimestamp(segment.startTime);
+      const title = generateSegmentTitle(segment.text);
+      md += `### [${formattedTime}] ${title}
+
+`;
+      md += `> ${segment.text}
+
+`;
+      const frames = segmentFrameMap.get(i);
+      if (frames && frames.length > 0) {
+        for (const frame of frames) {
+          const relativePath = computeRelativeFramePath(frame.path, sessionDir);
+          md += `![Screenshot](${relativePath})
+
+`;
+        }
+      }
+    }
+    md += `---
+_Captured by [markupr](https://markupr.com)_
+`;
+    return { content: md, fileExtension: ".md" };
+  }
+};
+
+// src/main/output/templates/jira.ts
+var jiraTemplate = {
+  name: "jira",
+  description: "Jira wiki markup with panels, tables, and {code} blocks",
+  fileExtension: ".jira",
+  render(context) {
+    const { result, sessionDir, timestamp } = context;
+    const { transcriptSegments, extractedFrames } = result;
+    const sessionTimestamp = formatDate(new Date(timestamp ?? Date.now()));
+    const duration = computeSessionDuration(transcriptSegments);
+    let content = `h1. Feedback Report
+
+`;
+    content += `{panel:title=Session Info|borderStyle=solid|borderColor=#ccc}
+`;
+    content += `*Captured:* ${sessionTimestamp}
+`;
+    content += `*Segments:* ${transcriptSegments.length} | *Frames:* ${extractedFrames.length} | *Duration:* ${duration}
+`;
+    content += `{panel}
+
+`;
+    if (transcriptSegments.length === 0) {
+      content += `_No feedback was captured during this recording._
+`;
+      return { content, fileExtension: ".jira" };
+    }
+    content += `h2. Summary
+
+`;
+    content += `||#||Timestamp||Feedback||
+`;
+    for (let i = 0; i < transcriptSegments.length; i++) {
+      const segment = transcriptSegments[i];
+      const formattedTime = formatTimestamp(segment.startTime);
+      const title = generateSegmentTitle(segment.text);
+      content += `|${i + 1}|${formattedTime}|${title}|
+`;
+    }
+    content += `
+`;
+    content += `h2. Details
+
+`;
+    const segmentFrameMap = mapFramesToSegments(transcriptSegments, extractedFrames);
+    for (let i = 0; i < transcriptSegments.length; i++) {
+      const segment = transcriptSegments[i];
+      const formattedTime = formatTimestamp(segment.startTime);
+      const title = generateSegmentTitle(segment.text);
+      content += `h3. \\[${formattedTime}\\] ${title}
+
+`;
+      content += `{quote}
+${segment.text}
+{quote}
+
+`;
+      const frames = segmentFrameMap.get(i);
+      if (frames && frames.length > 0) {
+        for (const frame of frames) {
+          const relativePath = computeRelativeFramePath(frame.path, sessionDir);
+          content += `!${relativePath}|thumbnail!
+
+`;
+        }
+      }
+    }
+    content += `----
+_Generated by [markupr|https://markupr.com]_
+`;
+    return { content, fileExtension: ".jira" };
+  }
+};
+
+// src/main/output/templates/index.ts
+templateRegistry.register(markdownTemplate);
+templateRegistry.register(jsonTemplate);
+templateRegistry.register(githubIssueTemplate);
+templateRegistry.register(linearTemplate);
+templateRegistry.register(jiraTemplate);
+
+// src/cli/CLIPipeline.ts
+var EXIT_SUCCESS = 0;
+var EXIT_USER_ERROR = 1;
+var EXIT_SYSTEM_ERROR = 2;
+var EXIT_SIGINT = 130;
+var CLIPipeline = class _CLIPipeline {
+  options;
+  log;
+  progress;
+  tempFiles = [];
+  activeProcesses = /* @__PURE__ */ new Set();
+  constructor(options, log, progress) {
+    this.options = options;
+    this.log = log;
+    this.progress = progress ?? (() => {
+    });
+  }
+  /**
+   * Run the full pipeline: audio extraction -> transcription -> analysis ->
+   * frame extraction -> markdown generation.
+   */
+  async run() {
+    try {
+      return await this.runPipeline();
+    } finally {
+      await this.cleanup();
+    }
+  }
+  async runPipeline() {
+    const startTime = Date.now();
+    await this.validateVideoFile();
+    if (!(this.options.audioPath && this.options.skipFrames)) {
+      await this.checkFfmpegAvailable();
+    }
+    try {
+      if (!existsSync3(this.options.outputDir)) {
+        mkdirSync2(this.options.outputDir, { recursive: true });
+      }
+    } catch (error) {
+      const code = error.code;
+      if (code === "EACCES") {
+        throw new CLIPipelineError(
+          `Permission denied: cannot create output directory: ${this.options.outputDir}`,
+          "user"
+        );
+      }
+      throw new CLIPipelineError(
+        `Cannot create output directory: ${this.options.outputDir} (${code})`,
+        "system"
+      );
+    }
+    this.progress("Extracting audio...");
+    const audioPath = await this.resolveAudioPath();
+    this.progress("Transcribing (this may take a while)...");
+    const segments = await this.transcribe(audioPath);
+    const analyzer = new TranscriptAnalyzer();
+    const keyMoments = analyzer.analyze(segments);
+    this.log(`  Found ${keyMoments.length} key moment(s)`);
+    let extractedFrames = [];
+    if (!this.options.skipFrames) {
+      this.progress("Extracting frames...");
+      extractedFrames = await this.extractFrames(keyMoments, segments);
+    } else {
+      this.log("  Frame extraction skipped (--no-frames)");
+    }
+    this.progress("Generating report...");
+    const result = {
+      transcriptSegments: segments,
+      extractedFrames,
+      reportPath: this.options.outputDir
+    };
+    let reportContent;
+    let reportExtension = ".md";
+    const templateName = this.options.template;
+    if (templateName && templateName !== "markdown") {
+      const template = templateRegistry.get(templateName);
+      if (!template) {
+        const available = templateRegistry.list().join(", ");
+        throw new CLIPipelineError(
+          `Unknown template "${templateName}". Available: ${available}`,
+          "user"
+        );
+      }
+      const output = template.render({ result, sessionDir: this.options.outputDir });
+      reportContent = output.content;
+      reportExtension = output.fileExtension;
+    } else {
+      const generator = new MarkdownGeneratorImpl();
+      reportContent = generator.generateFromPostProcess(result, this.options.outputDir);
+    }
+    const outputFilename = this.generateOutputFilename(reportExtension);
+    const outputPath = join3(this.options.outputDir, outputFilename);
+    try {
+      await writeFile(outputPath, reportContent, "utf-8");
+    } catch (error) {
+      const code = error.code;
+      throw new CLIPipelineError(
+        `Failed to write output file: ${outputPath}
+  Reason: ${code === "ENOSPC" ? "Disk is full" : error.message}`,
+        "system"
+      );
+    }
+    const durationSeconds = (Date.now() - startTime) / 1e3;
+    return {
+      outputPath,
+      transcriptSegments: segments.length,
+      extractedFrames: extractedFrames.length,
+      durationSeconds
+    };
+  }
+  /**
+   * Abort the pipeline: kill active child processes and clean up temp files.
+   */
+  async abort() {
+    for (const proc of this.activeProcesses) {
+      proc.kill("SIGTERM");
+    }
+    this.activeProcesses.clear();
+    await this.cleanup();
   }
   /**
    * Clean up temp files created during the pipeline run.
@@ -1592,11 +2746,11 @@ var CLIPipeline = class _CLIPipeline {
     TEMP: process.env.TEMP
   };
   execFileTracked(command, args) {
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve4, reject) => {
       const child = execFileCb2(command, args, { env: _CLIPipeline.SAFE_CHILD_ENV }, (error, stdout, stderr) => {
         this.activeProcesses.delete(child);
         if (error) reject(error);
-        else resolve2({ stdout: stdout?.toString() ?? "", stderr: stderr?.toString() ?? "" });
+        else resolve4({ stdout: stdout?.toString() ?? "", stderr: stderr?.toString() ?? "" });
       });
       this.activeProcesses.add(child);
     });
@@ -1651,8 +2805,8 @@ var CLIPipeline = class _CLIPipeline {
     try {
       await this.execFileTracked("ffmpeg", ["-version"]);
     } catch {
-      const platform = process.platform;
-      const installHint = platform === "darwin" ? "brew install ffmpeg" : platform === "win32" ? "winget install ffmpeg (or download from https://ffmpeg.org)" : "apt install ffmpeg (or your package manager)";
+      const platform2 = process.platform;
+      const installHint = platform2 === "darwin" ? "brew install ffmpeg" : platform2 === "win32" ? "winget install ffmpeg (or download from https://ffmpeg.org)" : "apt install ffmpeg (or your package manager)";
       throw new CLIPipelineError(
         `ffmpeg is required but not found on your system.
   Install via: ${installHint}
@@ -1812,56 +2966,599 @@ var CLIPipeline = class _CLIPipeline {
     return extractedFrames;
   }
   /**
-   * Find the transcript segment closest to a given timestamp.
+   * Find the transcript segment closest to a given timestamp.
+   */
+  findClosestSegment(timestamp, segments) {
+    if (segments.length === 0) return void 0;
+    for (const segment of segments) {
+      if (timestamp >= segment.startTime && timestamp <= segment.endTime) {
+        return segment;
+      }
+    }
+    let closest = segments[0];
+    let minDistance = Math.abs(timestamp - closest.startTime);
+    for (let i = 1; i < segments.length; i++) {
+      const distance = Math.abs(timestamp - segments[i].startTime);
+      if (distance < minDistance) {
+        minDistance = distance;
+        closest = segments[i];
+      }
+    }
+    return closest;
+  }
+  /**
+   * Generate the output filename based on the video filename and current date (UTC).
+   */
+  generateOutputFilename(extension = ".md") {
+    const videoName = basename2(this.options.videoPath).replace(/\.[^.]+$/, "").replace(/[^a-zA-Z0-9_-]/g, "-").replace(/-+/g, "-");
+    const now = /* @__PURE__ */ new Date();
+    const dateStr = [
+      now.getUTCFullYear(),
+      String(now.getUTCMonth() + 1).padStart(2, "0"),
+      String(now.getUTCDate()).padStart(2, "0")
+    ].join("");
+    const timeStr = [
+      String(now.getUTCHours()).padStart(2, "0"),
+      String(now.getUTCMinutes()).padStart(2, "0"),
+      String(now.getUTCSeconds()).padStart(2, "0")
+    ].join("");
+    const ext = extension.startsWith(".") ? extension : `.${extension}`;
+    return `${videoName}-feedback-${dateStr}-${timeStr}${ext}`;
+  }
+};
+var CLIPipelineError = class extends Error {
+  severity;
+  constructor(message, severity) {
+    super(message);
+    this.name = "CLIPipelineError";
+    this.severity = severity;
+  }
+};
+
+// src/cli/WatchMode.ts
+import { watch, existsSync as existsSync4, mkdirSync as mkdirSync3, readdirSync } from "fs";
+import { stat as stat2, readdir, appendFile } from "fs/promises";
+import { join as join4, resolve, extname, basename as basename3 } from "path";
+var VIDEO_EXTENSIONS = /* @__PURE__ */ new Set([".mov", ".mp4", ".webm"]);
+var WATCH_LOG_FILENAME = ".markupr-watch.log";
+var WatchMode = class {
+  options;
+  callbacks;
+  watcher = null;
+  processing = /* @__PURE__ */ new Set();
+  processed = /* @__PURE__ */ new Set();
+  pendingStabilityChecks = /* @__PURE__ */ new Map();
+  stopped = false;
+  stopResolve = null;
+  resolvedOutputDir;
+  constructor(options, callbacks) {
+    this.options = options;
+    this.callbacks = callbacks;
+    this.resolvedOutputDir = options.outputDir ? resolve(options.outputDir) : join4(resolve(options.watchDir), "markupr-output");
+  }
+  /**
+   * Start watching the directory. Returns a promise that resolves when
+   * the watcher is stopped (via stop() or SIGINT).
+   */
+  async start() {
+    const watchDir = resolve(this.options.watchDir);
+    if (!existsSync4(watchDir)) {
+      throw new Error(`Watch directory does not exist: ${watchDir}`);
+    }
+    if (!existsSync4(this.resolvedOutputDir)) {
+      mkdirSync3(this.resolvedOutputDir, { recursive: true });
+    }
+    await this.scanExistingFiles(watchDir);
+    this.callbacks.onLog(`Watching: ${watchDir}`);
+    this.callbacks.onLog(`Output:   ${this.resolvedOutputDir}`);
+    this.callbacks.onLog(`Watching for: ${[...VIDEO_EXTENSIONS].join(", ")}`);
+    this.watcher = watch(watchDir, (eventType, filename) => {
+      if (this.stopped || !filename) return;
+      this.handleFileEvent(watchDir, filename);
+    });
+    this.watcher.on("error", (err) => {
+      this.callbacks.onLog(`Watcher error: ${err.message}`);
+    });
+    return new Promise((resolvePromise) => {
+      if (this.stopped) {
+        resolvePromise();
+        return;
+      }
+      this.stopResolve = resolvePromise;
+    });
+  }
+  /**
+   * Stop watching and clean up.
+   */
+  stop() {
+    this.stopped = true;
+    for (const [, timeout] of this.pendingStabilityChecks) {
+      clearTimeout(timeout);
+    }
+    this.pendingStabilityChecks.clear();
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+    if (this.stopResolve) {
+      this.stopResolve();
+      this.stopResolve = null;
+    }
+  }
+  /**
+   * Check if the watcher has been stopped.
+   */
+  isStopped() {
+    return this.stopped;
+  }
+  /**
+   * Get the set of files currently being processed.
+   */
+  getProcessingFiles() {
+    return this.processing;
+  }
+  /**
+   * Get the set of files that have been processed.
+   */
+  getProcessedFiles() {
+    return this.processed;
+  }
+  // ==========================================================================
+  // Private Methods
+  // ==========================================================================
+  /**
+   * Scan existing files in the watch directory and mark ones that already
+   * have corresponding output as processed.
+   */
+  async scanExistingFiles(watchDir) {
+    try {
+      const entries = await readdir(watchDir);
+      for (const entry of entries) {
+        const ext = extname(entry).toLowerCase();
+        if (VIDEO_EXTENSIONS.has(ext)) {
+          const fullPath = join4(watchDir, entry);
+          if (this.hasExistingOutput(entry)) {
+            this.processed.add(fullPath);
+            if (this.options.verbose) {
+              this.callbacks.onLog(`Skipping (already processed): ${entry}`);
+            }
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  /**
+   * Check if a video file already has corresponding output in the output directory.
    */
-  findClosestSegment(timestamp, segments) {
-    if (segments.length === 0) return void 0;
-    for (const segment of segments) {
-      if (timestamp >= segment.startTime && timestamp <= segment.endTime) {
-        return segment;
-      }
+  hasExistingOutput(filename) {
+    const videoName = basename3(filename).replace(/\.[^.]+$/, "").replace(/[^a-zA-Z0-9_-]/g, "-").replace(/-+/g, "-");
+    if (!existsSync4(this.resolvedOutputDir)) return false;
+    try {
+      const outputFiles = readdirSync(this.resolvedOutputDir);
+      return outputFiles.some(
+        (f) => f.startsWith(videoName) && f.endsWith(".md")
+      );
+    } catch {
+      return false;
     }
-    let closest = segments[0];
-    let minDistance = Math.abs(timestamp - closest.startTime);
-    for (let i = 1; i < segments.length; i++) {
-      const distance = Math.abs(timestamp - segments[i].startTime);
-      if (distance < minDistance) {
-        minDistance = distance;
-        closest = segments[i];
+  }
+  /**
+   * Handle a file event from fs.watch.
+   */
+  handleFileEvent(watchDir, filename) {
+    const ext = extname(filename).toLowerCase();
+    if (!VIDEO_EXTENSIONS.has(ext)) return;
+    const fullPath = join4(watchDir, filename);
+    if (this.processed.has(fullPath) || this.processing.has(fullPath)) return;
+    if (this.pendingStabilityChecks.has(fullPath)) return;
+    this.callbacks.onFileDetected(fullPath);
+    this.startStabilityCheck(fullPath);
+  }
+  /**
+   * Start a stability check for a file. The file is considered stable when
+   * its size doesn't change over the configured interval (default: 2s).
+   */
+  startStabilityCheck(filePath, previousSize, checks = 0) {
+    const interval = this.options.stabilityInterval ?? 2e3;
+    const maxChecks = this.options.maxStabilityChecks ?? 30;
+    if (this.stopped) return;
+    if (checks >= maxChecks) {
+      this.callbacks.onLog(`Gave up waiting for file to stabilize: ${basename3(filePath)}`);
+      this.pendingStabilityChecks.delete(filePath);
+      return;
+    }
+    const timeout = setTimeout(async () => {
+      if (this.stopped) {
+        this.pendingStabilityChecks.delete(filePath);
+        return;
+      }
+      try {
+        if (!existsSync4(filePath)) {
+          this.pendingStabilityChecks.delete(filePath);
+          return;
+        }
+        const stats = await stat2(filePath);
+        const currentSize = stats.size;
+        if (currentSize === 0) {
+          this.pendingStabilityChecks.delete(filePath);
+          this.startStabilityCheck(filePath, currentSize, checks + 1);
+          return;
+        }
+        if (previousSize !== void 0 && currentSize === previousSize) {
+          this.pendingStabilityChecks.delete(filePath);
+          this.processFile(filePath);
+        } else {
+          if (this.options.verbose) {
+            this.callbacks.onLog(
+              `File size: ${currentSize} bytes (check ${checks + 1}/${maxChecks}): ${basename3(filePath)}`
+            );
+          }
+          this.pendingStabilityChecks.delete(filePath);
+          this.startStabilityCheck(filePath, currentSize, checks + 1);
+        }
+      } catch {
+        this.pendingStabilityChecks.delete(filePath);
       }
+    }, interval);
+    this.pendingStabilityChecks.set(filePath, timeout);
+  }
+  /**
+   * Process a stable video file through CLIPipeline.
+   */
+  async processFile(filePath) {
+    if (this.stopped || this.processing.has(filePath) || this.processed.has(filePath)) return;
+    this.processing.add(filePath);
+    this.callbacks.onProcessingStart(filePath);
+    const pipelineOptions = {
+      videoPath: filePath,
+      outputDir: this.resolvedOutputDir,
+      whisperModelPath: this.options.whisperModelPath,
+      openaiKey: this.options.openaiKey,
+      skipFrames: this.options.skipFrames,
+      verbose: this.options.verbose
+    };
+    const logFn = this.options.verbose ? this.callbacks.onLog : () => {
+    };
+    const pipeline = new CLIPipeline(pipelineOptions, logFn, this.callbacks.onLog);
+    try {
+      const result = await pipeline.run();
+      this.processed.add(filePath);
+      this.callbacks.onProcessingComplete(filePath, result.outputPath);
+      await this.appendToWatchLog(filePath, result.outputPath);
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.callbacks.onProcessingError(filePath, err);
+    } finally {
+      this.processing.delete(filePath);
     }
-    return closest;
   }
   /**
-   * Generate the output filename based on the video filename and current date (UTC).
+   * Append a processed file entry to the watch log.
    */
-  generateOutputFilename() {
-    const videoName = basename2(this.options.videoPath).replace(/\.[^.]+$/, "").replace(/[^a-zA-Z0-9_-]/g, "-").replace(/-+/g, "-");
-    const now = /* @__PURE__ */ new Date();
-    const dateStr = [
-      now.getUTCFullYear(),
-      String(now.getUTCMonth() + 1).padStart(2, "0"),
-      String(now.getUTCDate()).padStart(2, "0")
-    ].join("");
-    const timeStr = [
-      String(now.getUTCHours()).padStart(2, "0"),
-      String(now.getUTCMinutes()).padStart(2, "0"),
-      String(now.getUTCSeconds()).padStart(2, "0")
-    ].join("");
-    return `${videoName}-feedback-${dateStr}-${timeStr}.md`;
+  async appendToWatchLog(inputPath, outputPath) {
+    const logPath = join4(resolve(this.options.watchDir), WATCH_LOG_FILENAME);
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const entry = `${timestamp}	${inputPath}	${outputPath}
+`;
+    try {
+      await appendFile(logPath, entry, "utf-8");
+    } catch {
+    }
   }
 };
-var CLIPipelineError = class extends Error {
-  severity;
-  constructor(message, severity) {
-    super(message);
-    this.name = "CLIPipelineError";
-    this.severity = severity;
-  }
+
+// src/cli/doctor.ts
+import { existsSync as existsSync5 } from "fs";
+import { stat as stat3 } from "fs/promises";
+import { execFile as execFileCb3 } from "child_process";
+import { join as join5 } from "path";
+import { homedir as homedir2, platform } from "os";
+var SAFE_CHILD_ENV2 = {
+  PATH: process.env.PATH,
+  HOME: process.env.HOME || process.env.USERPROFILE,
+  USERPROFILE: process.env.USERPROFILE,
+  LANG: process.env.LANG
 };
+function execQuiet(command, args) {
+  return new Promise((resolve4) => {
+    execFileCb3(command, args, { env: SAFE_CHILD_ENV2 }, (error, stdout) => {
+      if (error) {
+        resolve4(null);
+      } else {
+        resolve4(stdout?.toString().trim() ?? "");
+      }
+    });
+  });
+}
+function getWhisperModelsDir() {
+  const home = process.env.HOME || process.env.USERPROFILE || homedir2();
+  return join5(home, ".markupr", "whisper-models");
+}
+function findWhisperModel(modelsDir) {
+  const modelNames = [
+    "ggml-tiny.bin",
+    "ggml-base.bin",
+    "ggml-small.bin",
+    "ggml-medium.bin",
+    "ggml-large-v3.bin"
+  ];
+  for (const name of modelNames) {
+    const modelPath = join5(modelsDir, name);
+    if (existsSync5(modelPath)) {
+      return name;
+    }
+  }
+  return null;
+}
+function parseSemver(version) {
+  const match = version.match(/(\d+)\.(\d+)\.(\d+)/);
+  if (!match) return null;
+  return [parseInt(match[1], 10), parseInt(match[2], 10), parseInt(match[3], 10)];
+}
+async function checkNodeVersion() {
+  const version = process.version;
+  const parsed = parseSemver(version);
+  if (!parsed) {
+    return {
+      name: "Node.js",
+      status: "warn",
+      message: `Unknown version: ${version}`,
+      hint: "markupr requires Node.js >= 18.0.0"
+    };
+  }
+  const [major] = parsed;
+  if (major >= 18) {
+    return {
+      name: "Node.js",
+      status: "pass",
+      message: `${version} (>= 18.0.0)`
+    };
+  }
+  return {
+    name: "Node.js",
+    status: "fail",
+    message: `${version} is too old`,
+    hint: "markupr requires Node.js >= 18.0.0. Upgrade at https://nodejs.org"
+  };
+}
+async function checkFfmpeg() {
+  const stdout = await execQuiet("ffmpeg", ["-version"]);
+  if (stdout === null) {
+    const os2 = platform();
+    const installHint = os2 === "darwin" ? "brew install ffmpeg" : os2 === "win32" ? "winget install ffmpeg (or download from https://ffmpeg.org)" : "apt install ffmpeg (or your package manager)";
+    return {
+      name: "ffmpeg",
+      status: "fail",
+      message: "Not found on PATH",
+      hint: `Install via: ${installHint}`
+    };
+  }
+  const versionMatch = stdout.match(/ffmpeg version (\S+)/);
+  const version = versionMatch ? versionMatch[1] : "unknown";
+  return {
+    name: "ffmpeg",
+    status: "pass",
+    message: `Installed (${version})`
+  };
+}
+async function checkFfprobe() {
+  const stdout = await execQuiet("ffprobe", ["-version"]);
+  if (stdout === null) {
+    return {
+      name: "ffprobe",
+      status: "fail",
+      message: "Not found on PATH",
+      hint: "ffprobe is usually installed alongside ffmpeg"
+    };
+  }
+  const versionMatch = stdout.match(/ffprobe version (\S+)/);
+  const version = versionMatch ? versionMatch[1] : "unknown";
+  return {
+    name: "ffprobe",
+    status: "pass",
+    message: `Installed (${version})`
+  };
+}
+async function checkWhisperModel() {
+  const modelsDir = getWhisperModelsDir();
+  if (!existsSync5(modelsDir)) {
+    return {
+      name: "Whisper model",
+      status: "warn",
+      message: "No models directory found",
+      hint: `Models directory: ${modelsDir}
+Download a model via the markupr desktop app, or manually place a ggml-*.bin file there`
+    };
+  }
+  const model = findWhisperModel(modelsDir);
+  if (!model) {
+    return {
+      name: "Whisper model",
+      status: "warn",
+      message: "No model files found",
+      hint: `Models directory: ${modelsDir}
+Download a model via the markupr desktop app, or manually place a ggml-*.bin file there`
+    };
+  }
+  return {
+    name: "Whisper model",
+    status: "pass",
+    message: `${model} found in ${modelsDir}`
+  };
+}
+async function checkAnthropicKey() {
+  const key = process.env.ANTHROPIC_API_KEY;
+  if (!key) {
+    return {
+      name: "Anthropic API key",
+      status: "warn",
+      message: "ANTHROPIC_API_KEY not set",
+      hint: "Optional. Set this env var to enable AI-powered analysis. Get a key at https://console.anthropic.com"
+    };
+  }
+  if (key.startsWith("sk-ant-")) {
+    return {
+      name: "Anthropic API key",
+      status: "pass",
+      message: "ANTHROPIC_API_KEY is set (sk-ant-...)"
+    };
+  }
+  return {
+    name: "Anthropic API key",
+    status: "pass",
+    message: "ANTHROPIC_API_KEY is set"
+  };
+}
+async function checkOpenAIKey() {
+  const key = process.env.OPENAI_API_KEY;
+  if (!key) {
+    return {
+      name: "OpenAI API key",
+      status: "warn",
+      message: "OPENAI_API_KEY not set",
+      hint: "Optional. Set this env var for cloud transcription via Whisper-1 API"
+    };
+  }
+  return {
+    name: "OpenAI API key",
+    status: "pass",
+    message: "OPENAI_API_KEY is set"
+  };
+}
+async function checkDiskSpace() {
+  try {
+    const tempDir = process.env.TMPDIR || process.env.TEMP || "/tmp";
+    if (platform() !== "win32") {
+      const dfOutput = await execQuiet("df", ["-k", tempDir]);
+      if (dfOutput) {
+        const lines = dfOutput.split("\n");
+        if (lines.length >= 2) {
+          const parts = lines[1].split(/\s+/);
+          if (parts.length >= 4) {
+            const availableKB = parseInt(parts[3], 10);
+            if (!isNaN(availableKB)) {
+              const availableGB = availableKB / (1024 * 1024);
+              if (availableGB < 1) {
+                return {
+                  name: "Disk space",
+                  status: "warn",
+                  message: `${availableGB.toFixed(1)} GB available (low)`,
+                  hint: "markupr recordings and output need disk space. Free up some space if you plan to record long sessions"
+                };
+              }
+              return {
+                name: "Disk space",
+                status: "pass",
+                message: `${availableGB.toFixed(1)} GB available`
+              };
+            }
+          }
+        }
+      }
+    }
+    await stat3(tempDir);
+    return {
+      name: "Disk space",
+      status: "pass",
+      message: "Temp directory accessible"
+    };
+  } catch {
+    return {
+      name: "Disk space",
+      status: "warn",
+      message: "Could not determine available disk space"
+    };
+  }
+}
+async function runDoctorChecks() {
+  const checks = await Promise.all([
+    checkNodeVersion(),
+    checkFfmpeg(),
+    checkFfprobe(),
+    checkWhisperModel(),
+    checkAnthropicKey(),
+    checkOpenAIKey(),
+    checkDiskSpace()
+  ]);
+  const passed = checks.filter((c) => c.status === "pass").length;
+  const warned = checks.filter((c) => c.status === "warn").length;
+  const failed = checks.filter((c) => c.status === "fail").length;
+  return { checks, passed, warned, failed };
+}
+
+// src/cli/init.ts
+import { existsSync as existsSync6 } from "fs";
+import { readFile as readFile2, writeFile as writeFile2, appendFile as appendFile2 } from "fs/promises";
+import { join as join6, resolve as resolve2 } from "path";
+var CONFIG_FILENAME = ".markupr.json";
+function createDefaultConfig(outputDir) {
+  return {
+    outputDir,
+    recording: {
+      skipFrames: false,
+      template: "markdown"
+    },
+    apiKeys: {
+      anthropic: "ANTHROPIC_API_KEY",
+      openai: "OPENAI_API_KEY"
+    }
+  };
+}
+async function updateGitignore(projectDir, outputDir) {
+  const gitignorePath = join6(projectDir, ".gitignore");
+  const entriesToAdd = [outputDir, ".markupr-watch.log"];
+  let existingContent = "";
+  if (existsSync6(gitignorePath)) {
+    existingContent = await readFile2(gitignorePath, "utf-8");
+  }
+  const lines = existingContent.split("\n");
+  const missingEntries = entriesToAdd.filter(
+    (entry) => !lines.some((line) => line.trim() === entry)
+  );
+  if (missingEntries.length === 0) {
+    return false;
+  }
+  const block = [
+    "",
+    "# markupr output",
+    ...missingEntries,
+    ""
+  ].join("\n");
+  await appendFile2(gitignorePath, block, "utf-8");
+  return true;
+}
+async function runInit(options) {
+  const projectDir = resolve2(options.directory);
+  const configPath = join6(projectDir, CONFIG_FILENAME);
+  if (existsSync6(configPath) && !options.force) {
+    return {
+      configPath,
+      created: false,
+      gitignoreUpdated: false,
+      alreadyExists: true
+    };
+  }
+  const config = createDefaultConfig(options.outputDir);
+  const content = JSON.stringify(config, null, 2) + "\n";
+  await writeFile2(configPath, content, "utf-8");
+  let gitignoreUpdated = false;
+  if (!options.skipGitignore) {
+    try {
+      gitignoreUpdated = await updateGitignore(projectDir, options.outputDir);
+    } catch {
+    }
+  }
+  return {
+    configPath,
+    created: true,
+    gitignoreUpdated,
+    alreadyExists: false
+  };
+}
 
 // src/cli/index.ts
-var VERSION = true ? "2.4.0" : "0.0.0-dev";
+var VERSION = true ? "2.6.0" : "0.0.0-dev";
 var SYMBOLS = {
   check: "\u2714",
   // checkmark
@@ -1873,8 +3570,10 @@ var SYMBOLS = {
   // bullet
   ellipsis: "\u2026",
   // ellipsis
-  line: "\u2500"
+  line: "\u2500",
   // horizontal line
+  warn: "\u26A0"
+  // warning sign
 };
 function banner() {
   console.log();
@@ -1891,6 +3590,9 @@ function success(message) {
 function fail(message) {
   console.log(`  ${SYMBOLS.cross} ${message}`);
 }
+function warn(message) {
+  console.log(`  ${SYMBOLS.warn} ${message}`);
+}
 var activePipeline = null;
 function setupSignalHandlers() {
   const handler = async () => {
@@ -1906,12 +3608,12 @@ function setupSignalHandlers() {
 setupSignalHandlers();
 var program = new Command();
 program.name("markupr").description("Analyze screen recordings and generate AI-ready Markdown reports").version(VERSION, "-v, --version").showHelpAfterError("(use --help for available options)");
-program.command("analyze").description("Analyze a video recording and generate a structured feedback report").argument("<video-file>", "Path to the video file to analyze").option("--audio <file>", "Separate audio file (if not embedded in video)").option("--output <dir>", "Output directory", "./markupr-output").option("--whisper-model <path>", "Path to Whisper model file").option("--openai-key <key>", "OpenAI API key for cloud transcription (prefer OPENAI_API_KEY env var)").option("--no-frames", "Skip frame extraction").option("--verbose", "Verbose output", false).action(async (videoFile, options) => {
+program.command("analyze").description("Analyze a video recording and generate a structured feedback report").argument("<video-file>", "Path to the video file to analyze").option("--audio <file>", "Separate audio file (if not embedded in video)").option("--output <dir>", "Output directory", "./markupr-output").option("--whisper-model <path>", "Path to Whisper model file").option("--openai-key <key>", "OpenAI API key for cloud transcription (prefer OPENAI_API_KEY env var)").option("--no-frames", "Skip frame extraction").option("--template <name>", `Output template (${templateRegistry.list().join(", ")})`, "markdown").option("--verbose", "Verbose output", false).action(async (videoFile, options) => {
   banner();
-  const videoPath = resolve(videoFile);
-  const outputDir = resolve(options.output);
-  const audioPath = options.audio ? resolve(options.audio) : void 0;
-  const whisperModelPath = options.whisperModel ? resolve(options.whisperModel) : void 0;
+  const videoPath = resolve3(videoFile);
+  const outputDir = resolve3(options.output);
+  const audioPath = options.audio ? resolve3(options.audio) : void 0;
+  const whisperModelPath = options.whisperModel ? resolve3(options.whisperModel) : void 0;
   let openaiKey;
   if (options.openaiKey) {
     console.warn("  WARNING: Passing API keys via CLI args is insecure (visible in ps, shell history).");
@@ -1921,15 +3623,15 @@ program.command("analyze").description("Analyze a video recording and generate a
   } else if (process.env.OPENAI_API_KEY) {
     openaiKey = process.env.OPENAI_API_KEY;
   }
-  if (!existsSync4(videoPath)) {
+  if (!existsSync7(videoPath)) {
     fail(`Video file not found: ${videoPath}`);
     process.exit(EXIT_USER_ERROR);
   }
-  if (audioPath && !existsSync4(audioPath)) {
+  if (audioPath && !existsSync7(audioPath)) {
     fail(`Audio file not found: ${audioPath}`);
     process.exit(EXIT_USER_ERROR);
   }
-  if (whisperModelPath && !existsSync4(whisperModelPath)) {
+  if (whisperModelPath && !existsSync7(whisperModelPath)) {
     fail(`Whisper model not found: ${whisperModelPath}`);
     process.exit(EXIT_USER_ERROR);
   }
@@ -1939,6 +3641,13 @@ program.command("analyze").description("Analyze a video recording and generate a
   }
   step(`Output: ${outputDir}`);
   console.log();
+  if (!templateRegistry.has(options.template)) {
+    fail(`Unknown template "${options.template}". Available: ${templateRegistry.list().join(", ")}`);
+    process.exit(EXIT_USER_ERROR);
+  }
+  if (options.template !== "markdown") {
+    step(`Template: ${options.template}`);
+  }
   const pipeline = new CLIPipeline(
     {
       videoPath,
@@ -1947,12 +3656,12 @@ program.command("analyze").description("Analyze a video recording and generate a
       whisperModelPath,
       openaiKey,
       skipFrames: !options.frames,
+      template: options.template,
       verbose: options.verbose
     },
     options.verbose ? step : () => {
     },
     step
-    // progress — always visible
   );
   activePipeline = pipeline;
   try {
@@ -1992,6 +3701,261 @@ program.command("analyze").description("Analyze a video recording and generate a
     activePipeline = null;
   }
 });
+program.command("watch").description("Watch a directory for new recordings and auto-process them").argument("[directory]", "Directory to watch for recordings", ".").option("--output <dir>", "Output directory (default: <watched-dir>/markupr-output)").option("--whisper-model <path>", "Path to Whisper model file").option("--openai-key <key>", "OpenAI API key for cloud transcription (prefer OPENAI_API_KEY env var)").option("--no-frames", "Skip frame extraction").option("--verbose", "Verbose output", false).action(async (directory, options) => {
+  banner();
+  const watchDir = resolve3(directory);
+  let openaiKey;
+  if (options.openaiKey) {
+    console.warn("  WARNING: Passing API keys via CLI args is insecure (visible in ps, shell history).");
+    console.warn("  Use OPENAI_API_KEY env var instead.");
+    console.warn();
+    openaiKey = options.openaiKey;
+  } else if (process.env.OPENAI_API_KEY) {
+    openaiKey = process.env.OPENAI_API_KEY;
+  }
+  if (!existsSync7(watchDir)) {
+    fail(`Directory not found: ${watchDir}`);
+    process.exit(EXIT_USER_ERROR);
+  }
+  const watchMode = new WatchMode(
+    {
+      watchDir,
+      outputDir: options.output ? resolve3(options.output) : void 0,
+      whisperModelPath: options.whisperModel ? resolve3(options.whisperModel) : void 0,
+      openaiKey,
+      skipFrames: !options.frames,
+      verbose: options.verbose
+    },
+    {
+      onLog: step,
+      onFileDetected: (filePath) => {
+        step(`Detected: ${filePath}`);
+      },
+      onProcessingStart: (filePath) => {
+        console.log();
+        step(`Processing: ${filePath}`);
+      },
+      onProcessingComplete: (filePath, outputPath) => {
+        success(`Done: ${filePath}`);
+        step(`Output: ${outputPath}`);
+      },
+      onProcessingError: (filePath, error) => {
+        fail(`Failed: ${filePath} \u2014 ${error.message}`);
+      }
+    }
+  );
+  const shutdown = () => {
+    console.log("\n  Stopping watcher...");
+    watchMode.stop();
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  step(`Watching for recordings in: ${watchDir}`);
+  step("Press Ctrl+C to stop");
+  console.log();
+  try {
+    await watchMode.start();
+    success("Watch mode stopped.");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    fail(`Watch mode error: ${message}`);
+    process.exit(EXIT_SYSTEM_ERROR);
+  }
+});
+program.command("doctor").description("Check your environment for markupr dependencies and configuration").action(async () => {
+  banner();
+  step("Checking environment...");
+  console.log();
+  const result = await runDoctorChecks();
+  for (const check of result.checks) {
+    if (check.status === "pass") {
+      success(`${check.name}: ${check.message}`);
+    } else if (check.status === "warn") {
+      warn(`${check.name}: ${check.message}`);
+    } else {
+      fail(`${check.name}: ${check.message}`);
+    }
+    if (check.hint) {
+      for (const line of check.hint.split("\n")) {
+        console.log(`      ${line}`);
+      }
+    }
+  }
+  console.log();
+  console.log(`  ${SYMBOLS.line.repeat(40)}`);
+  console.log(`  ${result.passed} passed, ${result.warned} warnings, ${result.failed} failed`);
+  console.log();
+  if (result.failed > 0) {
+    fail("Some required checks failed. Fix them to use markupr.");
+    process.exit(EXIT_USER_ERROR);
+  } else if (result.warned > 0) {
+    success("markupr is ready (some optional features are not configured).");
+  } else {
+    success("markupr is fully configured and ready to go!");
+  }
+  console.log();
+});
+program.command("init").description("Create a .markupr.json config file in the current project").option("--output <dir>", "Output directory for feedback sessions", "./markupr-output").option("--no-gitignore", "Skip updating .gitignore").option("--force", "Overwrite existing config file", false).action(async (options) => {
+  banner();
+  const result = await runInit({
+    directory: process.cwd(),
+    outputDir: options.output,
+    skipGitignore: !options.gitignore,
+    force: options.force
+  });
+  if (result.alreadyExists) {
+    warn(`${CONFIG_FILENAME} already exists at ${result.configPath}`);
+    console.log("      Use --force to overwrite.");
+    console.log();
+    process.exit(EXIT_USER_ERROR);
+  }
+  success(`Created ${result.configPath}`);
+  if (result.gitignoreUpdated) {
+    success("Updated .gitignore with markupr output directory");
+  }
+  console.log();
+  step("Next steps:");
+  console.log("    1. Run `markupr doctor` to verify your environment");
+  console.log("    2. Record a session with the markupr desktop app or screen recorder");
+  console.log("    3. Run `markupr analyze <video-file>` to generate a feedback report");
+  console.log();
+});
+var pushCmd = program.command("push").description("Push feedback to external services");
+pushCmd.command("linear").description("Create Linear issues from a markupr feedback report").argument("<report>", "Path to the markupr markdown report").requiredOption("--team <key>", "Linear team key (e.g., ENG, DES)").option("--token <token>", "Linear API key (prefer LINEAR_API_KEY env var)").option("--project <name>", "Linear project name to assign issues to").option("--dry-run", "Show what would be created without creating anything", false).action(async (report, options) => {
+  banner();
+  const reportPath = resolve3(report);
+  if (!existsSync7(reportPath)) {
+    fail(`Report file not found: ${reportPath}`);
+    process.exit(EXIT_USER_ERROR);
+  }
+  if (options.token) {
+    console.warn("  WARNING: Passing tokens via CLI args is insecure (visible in ps, shell history).");
+    console.warn("  Use LINEAR_API_KEY env var instead.");
+    console.warn();
+  }
+  const apiToken = options.token || process.env.LINEAR_API_KEY;
+  if (!apiToken) {
+    fail("No Linear API token found.");
+    console.log("  Provide via --token flag or LINEAR_API_KEY env var.");
+    process.exit(EXIT_USER_ERROR);
+  }
+  const { LinearIssueCreator: LinearIssueCreator2 } = await Promise.resolve().then(() => (init_LinearIssueCreator(), LinearIssueCreator_exports));
+  try {
+    step(`Report: ${reportPath}`);
+    step(`Team:   ${options.team}`);
+    if (options.project) {
+      step(`Project: ${options.project}`);
+    }
+    if (options.dryRun) {
+      step("Mode:   DRY RUN");
+    }
+    console.log();
+    step("Parsing feedback report...");
+    const creator = new LinearIssueCreator2(apiToken);
+    const result = await creator.pushReport(reportPath, {
+      token: apiToken,
+      teamKey: options.team,
+      projectName: options.project,
+      dryRun: options.dryRun
+    });
+    console.log();
+    if (options.dryRun) {
+      success(`Dry run complete \u2014 ${result.created} issue(s) would be created:`);
+      console.log();
+      for (const issue of result.issues) {
+        if (issue.success) {
+          step(`${issue.identifier}: ${issue.issueUrl}`);
+        }
+      }
+    } else {
+      success(`Created ${result.created} issue(s):`);
+      console.log();
+      for (const issue of result.issues) {
+        if (issue.success) {
+          step(`${issue.identifier}: ${issue.issueUrl}`);
+        }
+      }
+    }
+    if (result.failed > 0) {
+      console.log();
+      fail(`${result.failed} error(s):`);
+      for (const issue of result.issues) {
+        if (!issue.success) {
+          fail(`  ${issue.error}`);
+        }
+      }
+    }
+    console.log();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    fail(message);
+    process.exit(EXIT_USER_ERROR);
+  }
+});
+pushCmd.command("github").description("Create GitHub issues from a markupr feedback report").argument("<report>", "Path to the markupr markdown report").requiredOption("--repo <owner/repo>", "Target GitHub repository (e.g., myorg/myapp)").option("--token <token>", "GitHub token (prefer GITHUB_TOKEN env var or gh auth login)").option("--items <ids...>", "Specific FB-XXX item IDs to push (default: all)").option("--dry-run", "Show what would be created without creating anything", false).action(async (report, options) => {
+  banner();
+  const reportPath = resolve3(report);
+  if (!existsSync7(reportPath)) {
+    fail(`Report file not found: ${reportPath}`);
+    process.exit(EXIT_USER_ERROR);
+  }
+  if (options.token) {
+    console.warn("  WARNING: Passing tokens via CLI args is insecure (visible in ps, shell history).");
+    console.warn("  Use GITHUB_TOKEN env var or `gh auth login` instead.");
+    console.warn();
+  }
+  const { resolveAuth: resolveAuth2, parseRepoString: parseRepoString2, pushToGitHub: pushToGitHub2 } = await Promise.resolve().then(() => (init_GitHubIssueCreator(), GitHubIssueCreator_exports));
+  try {
+    const parsedRepo = parseRepoString2(options.repo);
+    const auth = await resolveAuth2(options.token);
+    step(`Report: ${reportPath}`);
+    step(`Repo:   ${parsedRepo.owner}/${parsedRepo.repo}`);
+    step(`Auth:   ${auth.source}`);
+    if (options.dryRun) {
+      step("Mode:   DRY RUN");
+    }
+    console.log();
+    step("Parsing feedback report and creating issues...");
+    const result = await pushToGitHub2({
+      repo: parsedRepo,
+      auth,
+      reportPath,
+      dryRun: options.dryRun,
+      items: options.items
+    });
+    console.log();
+    if (options.dryRun) {
+      success(`Dry run complete \u2014 ${result.created.length} issue(s) would be created:`);
+      console.log();
+      for (const issue of result.created) {
+        step(`  ${issue.title}`);
+      }
+    } else {
+      success(`Created ${result.created.length} issue(s):`);
+      console.log();
+      for (const issue of result.created) {
+        step(`#${issue.number}: ${issue.title}`);
+        step(`  ${issue.url}`);
+      }
+    }
+    if (result.labelsCreated.length > 0) {
+      console.log();
+      step(`Labels created: ${result.labelsCreated.join(", ")}`);
+    }
+    if (result.errors.length > 0) {
+      console.log();
+      fail(`${result.errors.length} error(s):`);
+      for (const err of result.errors) {
+        fail(`  ${err.itemId}: ${err.error}`);
+      }
+    }
+    console.log();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    fail(message);
+    process.exit(EXIT_USER_ERROR);
+  }
+});
 if (process.argv.length <= 2) {
   banner();
   program.outputHelp();