cursor-history-mcp 0.1.6 → 0.2.0

package/dist/index.cjs

@@ -1957,7 +1957,7 @@ var require_adm_zip = __commonJS({
         }
       }
       const _zip = new ZipFile(inBuffer, opts);
-      const { canonical, sanitize, zipnamefix } = Utils;
+      const { canonical, sanitize: sanitize2, zipnamefix } = Utils;
       function getEntry(entry) {
         if (entry && _zip) {
           var item;
@@ -2459,7 +2459,7 @@ var require_adm_zip = __commonJS({
             throw Utils.Errors.NO_ENTRY();
           }
           var entryName = canonical(item.entryName);
-          var target = sanitize(targetPath, outFileName && !item.isDirectory ? outFileName : maintainEntryPath ? entryName : pth.basename(entryName));
+          var target = sanitize2(targetPath, outFileName && !item.isDirectory ? outFileName : maintainEntryPath ? entryName : pth.basename(entryName));
           if (item.isDirectory) {
             var children = _zip.getEntryChildren(item);
             children.forEach(function(child) {
@@ -2469,7 +2469,7 @@ var require_adm_zip = __commonJS({
                 throw Utils.Errors.CANT_EXTRACT_FILE();
               }
               var name = canonical(child.entryName);
-              var childName = sanitize(targetPath, maintainEntryPath ? name : pth.basename(name));
+              var childName = sanitize2(targetPath, maintainEntryPath ? name : pth.basename(name));
               const fileAttr2 = keepOriginalPermission ? child.header.fileAttr : void 0;
               filetools.writeFileTo(childName, content2, overwrite, fileAttr2);
             });
@@ -2523,7 +2523,7 @@ var require_adm_zip = __commonJS({
           overwrite = get_Bool(false, overwrite);
           if (!_zip) throw Utils.Errors.NO_ZIP();
           _zip.entries.forEach(function(entry) {
-            var entryName = sanitize(targetPath, canonical(entry.entryName));
+            var entryName = sanitize2(targetPath, canonical(entry.entryName));
             if (entry.isDirectory) {
               filetools.makeDir(entryName);
               return;
@@ -2571,7 +2571,7 @@ var require_adm_zip = __commonJS({
             return;
           }
           targetPath = pth.resolve(targetPath);
-          const getPath = (entry) => sanitize(targetPath, pth.normalize(canonical(entry.entryName)));
+          const getPath = (entry) => sanitize2(targetPath, pth.normalize(canonical(entry.entryName)));
           const getError = (msg, file) => new Error(msg + ': "' + file + '"');
           const dirEntries = [];
           const fileEntries = [];
@@ -2599,7 +2599,7 @@ var require_adm_zip = __commonJS({
                 next(err);
               } else {
                 const entryName = pth.normalize(canonical(entry.entryName));
-                const filePath = sanitize(targetPath, entryName);
+                const filePath = sanitize2(targetPath, entryName);
                 entry.getDataAsync(function(content, err_1) {
                   if (err_1) {
                     next(err_1);
@@ -11973,6 +11973,1356 @@ async function handleMigrate(args) {
   }
 }
 
+// src/tools/year-pack/types.ts
+var YearPackInputSchema = z.object({
+  year: z.number().int().min(1970).max((/* @__PURE__ */ new Date()).getFullYear()).optional().default(() => (/* @__PURE__ */ new Date()).getFullYear()),
+  language: z.enum(["en", "zh"]).optional().default("en"),
+  workspace: z.string().optional(),
+  maxSamples: z.number().int().min(0).max(100).optional().default(30),
+  maxSampleLength: z.number().int().min(50).max(500).optional().default(120),
+  topicsCount: z.number().int().min(3).max(15).optional().default(7)
+});
+var SAFETY_GUARANTEES = [
+  "no_executable_content",
+  "no_file_paths",
+  "no_urls",
+  "no_credentials"
+];
+var MIN_QUESTIONS_FOR_TOPICS = 50;
+var DEFAULT_CONFIG = {
+  maxLineChars: 280,
+  maxSamples: 30,
+  maxSampleLength: 120,
+  maxVocab: 3e3,
+  minDf: 5,
+  maxDfRatio: 0.6,
+  kTopics: 7,
+  kmeansIterations: 25,
+  topTermsPerTopic: 5,
+  topUnigrams: 50,
+  topBigrams: 30
+};
+
+// src/tools/year-pack/sanitizer.ts
+var CODE_BLOCK_PATTERN = /```[\s\S]*?```|~~~[\s\S]*?~~~/g;
+var INLINE_CODE_PATTERN = /`[^`]+`/g;
+var COMMAND_LINE_PATTERN = /^[\s]*[$>#]\s*.+$|^[\s]*(npm|yarn|pnpm|git|python|pip|node|deno|bun|cargo|go|make|docker|kubectl|helm|terraform|aws|gcloud|az)\s+.+$/gim;
+var FILE_PATH_PATTERN = /(?:~\/|\.\.?\/|\/(?!\/)|[A-Za-z]:\\)[^\s\n\r<>"|?*]+/g;
+var URL_PATTERN = /(?:https?|ftp|file):\/\/[^\s<>"\])}]+|www\.[^\s<>"\])}]+/gi;
+var EMAIL_PATTERN = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g;
+var IPV4_PATTERN = /\b(?:\d{1,3}\.){3}\d{1,3}\b/g;
+var IPV6_PATTERN = /\b(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}\b|\b(?:[0-9a-fA-F]{1,4}:){1,7}:|::(?:[0-9a-fA-F]{1,4}:){0,6}[0-9a-fA-F]{1,4}\b/g;
+var SECRET_PATTERNS = [
+  // API keys with common prefixes (sk_live_, pk_test_, etc.)
+  /\b(?:sk|pk|api|token|key|secret|password|auth|bearer|access)[-_][a-zA-Z0-9_-]{16,}\b/gi,
+  // Long hex strings (likely hashes or tokens)
+  /\b[0-9a-fA-F]{32,}\b/g,
+  // Long alphanumeric strings that look like tokens
+  /\b[A-Za-z0-9+/=]{40,}\b/g,
+  // AWS-style keys
+  /\bAKIA[0-9A-Z]{16}\b/g,
+  // GitHub tokens
+  /\bghp_[a-zA-Z0-9]{36}\b/g,
+  /\bgho_[a-zA-Z0-9]{36}\b/g,
+  /\bghu_[a-zA-Z0-9]{36}\b/g,
+  /\bghs_[a-zA-Z0-9]{36}\b/g,
+  /\bghr_[a-zA-Z0-9]{36}\b/g,
+  // npm tokens
+  /\bnpm_[a-zA-Z0-9]{36}\b/g
+];
+function removeCodeBlocks(text) {
+  return text.replace(CODE_BLOCK_PATTERN, " ").replace(INLINE_CODE_PATTERN, " ");
+}
+function removeCommands(text) {
+  return text.replace(COMMAND_LINE_PATTERN, " ");
+}
+function maskPaths(text) {
+  return text.replace(FILE_PATH_PATTERN, "[PATH]");
+}
+function maskUrls(text) {
+  return text.replace(URL_PATTERN, "[URL]");
+}
+function maskEmails(text) {
+  return text.replace(EMAIL_PATTERN, "[EMAIL]");
+}
+function maskIps(text) {
+  return text.replace(IPV4_PATTERN, "[IP]").replace(IPV6_PATTERN, "[IP]");
+}
+function maskSecrets(text) {
+  let result = text;
+  for (const pattern of SECRET_PATTERNS) {
+    result = result.replace(pattern, "[SECRET]");
+  }
+  return result;
+}
+function truncateText(text, maxLength = DEFAULT_CONFIG.maxLineChars) {
+  if (text.length <= maxLength) {
+    return text;
+  }
+  const cutoff = maxLength - 12;
+  return text.slice(0, cutoff) + " [TRUNCATED]";
+}
+function normalizeWhitespace(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+var DEFAULT_SANITIZE_OPTIONS = {
+  maxLength: DEFAULT_CONFIG.maxLineChars,
+  removeCode: true,
+  removeCommands: true,
+  maskPaths: true,
+  maskUrls: true,
+  maskEmails: true,
+  maskIps: true,
+  maskSecrets: true,
+  truncate: true
+};
+function sanitize(text, options = {}) {
+  const opts = { ...DEFAULT_SANITIZE_OPTIONS, ...options };
+  let result = text;
+  if (opts.removeCode) {
+    result = removeCodeBlocks(result);
+  }
+  if (opts.removeCommands) {
+    result = removeCommands(result);
+  }
+  if (opts.maskUrls) {
+    result = maskUrls(result);
+  }
+  if (opts.maskPaths) {
+    result = maskPaths(result);
+  }
+  if (opts.maskEmails) {
+    result = maskEmails(result);
+  }
+  if (opts.maskIps) {
+    result = maskIps(result);
+  }
+  if (opts.maskSecrets) {
+    result = maskSecrets(result);
+  }
+  result = normalizeWhitespace(result);
+  if (opts.truncate) {
+    result = truncateText(result, opts.maxLength);
+  }
+  return result;
+}
+function containsSensitiveContent(text) {
+  if (FILE_PATH_PATTERN.test(text)) return true;
+  if (URL_PATTERN.test(text)) return true;
+  if (EMAIL_PATTERN.test(text)) return true;
+  if (IPV4_PATTERN.test(text)) return true;
+  if (/[{}();]/.test(text) && /[a-z]+\s*[({]/.test(text)) return true;
+  for (const pattern of SECRET_PATTERNS) {
+    if (pattern.test(text)) return true;
+  }
+  return false;
+}
+function getAppliedFilters(options = {}) {
+  const opts = { ...DEFAULT_SANITIZE_OPTIONS, ...options };
+  const filters = ["user_messages_only"];
+  if (opts.removeCode) filters.push("code_blocks_removed");
+  if (opts.removeCommands) filters.push("commands_removed");
+  if (opts.maskPaths) filters.push("paths_masked");
+  if (opts.maskUrls) filters.push("urls_masked");
+  if (opts.maskEmails) filters.push("emails_masked");
+  if (opts.maskIps) filters.push("ips_masked");
+  if (opts.maskSecrets) filters.push("secrets_masked");
+  if (opts.truncate) filters.push("truncated_long_text");
+  return filters;
+}
+
+// src/tools/year-pack/stopwords.ts
+var ENGLISH_STOPWORDS = /* @__PURE__ */ new Set([
+  // Articles
+  "a",
+  "an",
+  "the",
+  // Pronouns
+  "i",
+  "me",
+  "my",
+  "myself",
+  "we",
+  "our",
+  "ours",
+  "ourselves",
+  "you",
+  "your",
+  "yours",
+  "yourself",
+  "yourselves",
+  "he",
+  "him",
+  "his",
+  "himself",
+  "she",
+  "her",
+  "hers",
+  "herself",
+  "it",
+  "its",
+  "itself",
+  "they",
+  "them",
+  "their",
+  "theirs",
+  "themselves",
+  "what",
+  "which",
+  "who",
+  "whom",
+  "this",
+  "that",
+  "these",
+  "those",
+  // Verbs (common)
+  "am",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "have",
+  "has",
+  "had",
+  "having",
+  "do",
+  "does",
+  "did",
+  "doing",
+  "would",
+  "should",
+  "could",
+  "ought",
+  "might",
+  "must",
+  "shall",
+  "will",
+  "can",
+  // Prepositions
+  "at",
+  "by",
+  "for",
+  "from",
+  "in",
+  "into",
+  "of",
+  "on",
+  "to",
+  "with",
+  "about",
+  "against",
+  "between",
+  "through",
+  "during",
+  "before",
+  "after",
+  "above",
+  "below",
+  "up",
+  "down",
+  "out",
+  "off",
+  "over",
+  "under",
+  "again",
+  "further",
+  // Conjunctions
+  "and",
+  "but",
+  "or",
+  "nor",
+  "so",
+  "yet",
+  "both",
+  "either",
+  "neither",
+  "not",
+  "only",
+  "own",
+  "same",
+  "than",
+  "too",
+  "very",
+  "just",
+  // Other common words
+  "then",
+  "now",
+  "here",
+  "there",
+  "when",
+  "where",
+  "why",
+  "how",
+  "all",
+  "each",
+  "few",
+  "more",
+  "most",
+  "other",
+  "some",
+  "such",
+  "no",
+  "any",
+  "if",
+  "because",
+  "as",
+  "until",
+  "while",
+  "once",
+  // Common tech words that don't add meaning
+  "use",
+  "using",
+  "used",
+  "get",
+  "got",
+  "make",
+  "made",
+  "want",
+  "need",
+  "like",
+  "know",
+  "see",
+  "look",
+  "think",
+  "also",
+  "new",
+  "one",
+  "two",
+  "first",
+  "way",
+  "even",
+  "well",
+  "back",
+  "still",
+  "going",
+  "come",
+  "take",
+  "give",
+  "let",
+  "try",
+  "keep",
+  "put",
+  "say",
+  "said",
+  "tell",
+  "told",
+  "ask",
+  "work",
+  "works",
+  "working",
+  "right",
+  "good",
+  "bad",
+  "best",
+  "better",
+  "worst",
+  "worse",
+  "long",
+  "short",
+  "big",
+  "small",
+  // Placeholders (our sanitization markers)
+  "path",
+  "url",
+  "email",
+  "secret",
+  "truncated"
+]);
+var CHINESE_STOPWORDS = /* @__PURE__ */ new Set([
+  // Particles
+  "\u7684",
+  "\u5730",
+  "\u5F97",
+  "\u4E86",
+  "\u7740",
+  "\u8FC7",
+  "\u5417",
+  "\u5462",
+  "\u5427",
+  "\u554A",
+  "\u5440",
+  "\u54E6",
+  "\u54C8",
+  "\u561B",
+  "\u5566",
+  "\u55EF",
+  // Pronouns
+  "\u6211",
+  "\u4F60",
+  "\u4ED6",
+  "\u5979",
+  "\u5B83",
+  "\u6211\u4EEC",
+  "\u4F60\u4EEC",
+  "\u4ED6\u4EEC",
+  "\u5979\u4EEC",
+  "\u5B83\u4EEC",
+  "\u81EA\u5DF1",
+  "\u8FD9",
+  "\u90A3",
+  "\u8FD9\u4E2A",
+  "\u90A3\u4E2A",
+  "\u8FD9\u4E9B",
+  "\u90A3\u4E9B",
+  "\u4EC0\u4E48",
+  "\u54EA",
+  "\u54EA\u4E2A",
+  "\u8C01",
+  "\u600E\u4E48",
+  "\u600E\u6837",
+  "\u5982\u4F55",
+  "\u4E3A\u4EC0\u4E48",
+  "\u54EA\u91CC",
+  "\u54EA\u513F",
+  // Verbs (common auxiliary)
+  "\u662F",
+  "\u6709",
+  "\u5728",
+  "\u88AB",
+  "\u628A",
+  "\u8BA9",
+  "\u7ED9",
+  "\u8DDF",
+  "\u548C",
+  "\u4E0E",
+  "\u5BF9",
+  "\u5411",
+  "\u4ECE",
+  "\u5230",
+  "\u7528",
+  "\u4EE5",
+  "\u4E3A",
+  "\u56E0\u4E3A",
+  "\u6240\u4EE5",
+  "\u4F46\u662F",
+  "\u4F46",
+  "\u800C",
+  "\u6216",
+  "\u6216\u8005",
+  "\u5982\u679C",
+  "\u867D\u7136",
+  "\u867D",
+  "\u5373\u4F7F",
+  "\u5C31",
+  "\u624D",
+  "\u90FD",
+  "\u4E5F",
+  "\u8FD8",
+  "\u53C8",
+  "\u518D",
+  "\u53EA",
+  "\u53EA\u662F",
+  "\u4E0D",
+  "\u6CA1",
+  "\u6CA1\u6709",
+  "\u522B",
+  "\u4E0D\u8981",
+  "\u80FD",
+  "\u4F1A",
+  "\u53EF\u4EE5",
+  "\u53EF\u80FD",
+  "\u5E94\u8BE5",
+  "\u5FC5\u987B",
+  "\u9700\u8981",
+  "\u60F3",
+  "\u8981",
+  // Conjunctions and connectives
+  "\u7136\u540E",
+  "\u63A5\u7740",
+  "\u9996\u5148",
+  "\u5176\u6B21",
+  "\u6700\u540E",
+  "\u53E6\u5916",
+  "\u6B64\u5916",
+  "\u800C\u4E14",
+  "\u5E76\u4E14",
+  "\u4EE5\u53CA",
+  "\u4E0D\u4EC5",
+  "\u4E0D\u4F46",
+  "\u65E2",
+  "\u53C8",
+  // Adverbs
+  "\u5F88",
+  "\u975E\u5E38",
+  "\u592A",
+  "\u66F4",
+  "\u6700",
+  "\u771F",
+  "\u6BD4\u8F83",
+  "\u76F8\u5F53",
+  "\u7279\u522B",
+  "\u5C24\u5176",
+  "\u5DF2\u7ECF",
+  "\u66FE\u7ECF",
+  "\u6B63\u5728",
+  "\u5C06",
+  "\u5C06\u8981",
+  "\u521A",
+  "\u521A\u521A",
+  "\u9A6C\u4E0A",
+  "\u7ACB\u523B",
+  "\u4E00\u76F4",
+  "\u603B\u662F",
+  "\u7ECF\u5E38",
+  "\u5E38\u5E38",
+  "\u5F80\u5F80",
+  "\u5927\u6982",
+  "\u53EF\u80FD",
+  "\u4E5F\u8BB8",
+  "\u5927\u7EA6",
+  // Measure words
+  "\u4E2A",
+  "\u4E9B",
+  "\u79CD",
+  "\u6B21",
+  "\u4EF6",
+  "\u6761",
+  "\u70B9",
+  // Other common words
+  "\u4E00",
+  "\u4E8C",
+  "\u4E24",
+  "\u4E09",
+  "\u7B2C",
+  "\u4E0A",
+  "\u4E0B",
+  "\u524D",
+  "\u540E",
+  "\u91CC",
+  "\u4E2D",
+  "\u5916",
+  "\u5185",
+  "\u5DE6",
+  "\u53F3",
+  "\u591A",
+  "\u5C11",
+  "\u5927",
+  "\u5C0F",
+  "\u597D",
+  "\u574F",
+  "\u65B0",
+  "\u65E7",
+  "\u957F",
+  "\u77ED",
+  "\u9AD8",
+  "\u4F4E",
+  "\u5FEB",
+  "\u6162",
+  "\u65E9",
+  "\u665A",
+  "\u5148",
+  "\u540E",
+  "\u65F6",
+  "\u65F6\u5019",
+  "\u5730\u65B9",
+  "\u4E1C\u897F",
+  "\u4E8B\u60C5",
+  "\u95EE\u9898",
+  "\u60C5\u51B5",
+  "\u65B9\u9762",
+  "\u65B9\u6CD5",
+  "\u65B9\u5F0F"
+]);
+function getStopwords(language) {
+  return language === "zh" ? CHINESE_STOPWORDS : ENGLISH_STOPWORDS;
+}
+
+// src/tools/year-pack/analyzer.ts
+function tokenize(text) {
+  const tokens = text.toLowerCase().match(/[a-z][a-z0-9_-]*[a-z0-9]|[a-z]{3,}/g);
+  if (!tokens) return [];
+  return tokens.filter((t) => t.length >= 3);
+}
+function tokenizeWithoutStopwords(text, language = "en") {
+  const tokens = tokenize(text);
+  const stopwords = getStopwords(language);
+  return tokens.filter((t) => !stopwords.has(t));
+}
+function generateBigrams(tokens) {
+  if (tokens.length < 2) return [];
+  const bigrams = [];
+  for (let i = 0; i < tokens.length - 1; i++) {
+    const token1 = tokens[i];
+    const token2 = tokens[i + 1];
+    if (token1 && token2) {
+      bigrams.push(`${token1} ${token2}`);
+    }
+  }
+  return bigrams;
+}
+function countFrequencies(terms) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const term of terms) {
+    counts.set(term, (counts.get(term) ?? 0) + 1);
+  }
+  return counts;
+}
+function getTopTerms(frequencies, n) {
+  return Array.from(frequencies.entries()).sort((a, b) => b[1] - a[1]).slice(0, n).map(([term, count]) => ({ term, count }));
+}
+function extractKeywords(texts, language = "en", topUnigrams = DEFAULT_CONFIG.topUnigrams, topBigrams = DEFAULT_CONFIG.topBigrams) {
+  const allUnigrams = [];
+  const allBigrams = [];
+  for (const text of texts) {
+    const tokens = tokenizeWithoutStopwords(text, language);
+    allUnigrams.push(...tokens);
+    allBigrams.push(...generateBigrams(tokens));
+  }
+  const unigramFreq = countFrequencies(allUnigrams);
+  const bigramFreq = countFrequencies(allBigrams);
+  return {
+    topUnigrams: getTopTerms(unigramFreq, topUnigrams),
+    topBigrams: getTopTerms(bigramFreq, topBigrams)
+  };
+}
+function getWeekNumber(date) {
+  const d = new Date(
+    Date.UTC(date.getFullYear(), date.getMonth(), date.getDate())
+  );
+  const dayNum = d.getUTCDay() || 7;
+  d.setUTCDate(d.getUTCDate() + 4 - dayNum);
+  const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
+  return Math.ceil(((d.getTime() - yearStart.getTime()) / 864e5 + 1) / 7);
+}
+function getLengthBucket(length) {
+  if (length <= 100) return "short";
+  if (length <= 280) return "medium";
+  return "long";
+}
+function calculateStats(questions) {
+  const monthlyDistribution = {};
+  const lengthBuckets = { short: 0, medium: 0, long: 0 };
+  for (const q of questions) {
+    monthlyDistribution[q.month] = (monthlyDistribution[q.month] ?? 0) + 1;
+    const bucket = getLengthBucket(q.originalLength);
+    lengthBuckets[bucket]++;
+  }
+  const activeMonths = Object.keys(monthlyDistribution).length;
+  return {
+    totalQuestions: questions.length,
+    activeMonths,
+    monthlyDistribution,
+    lengthBuckets
+  };
+}
+function processQuestion(content, timestamp, maxLength = DEFAULT_CONFIG.maxLineChars) {
+  const originalLength = content.length;
+  const sanitized = sanitize(content, { maxLength });
+  const month = `${timestamp.getFullYear()}-${String(
+    timestamp.getMonth() + 1
+  ).padStart(2, "0")}`;
+  const week = getWeekNumber(timestamp);
+  return {
+    content: sanitized,
+    originalLength,
+    timestamp,
+    month,
+    week
+  };
+}
+function isQuestionFormat(text) {
+  if (text.trim().endsWith("?")) return true;
+  const questionWords = [
+    "how",
+    "what",
+    "why",
+    "when",
+    "where",
+    "who",
+    "which",
+    "can",
+    "could",
+    "would",
+    "should",
+    "is",
+    "are",
+    "does",
+    "do",
+    "will"
+  ];
+  const firstWord = text.trim().toLowerCase().split(/\s+/)[0];
+  return firstWord ? questionWords.includes(firstWord) : false;
+}
+function selectSafeSamples(questions, maxSamples = DEFAULT_CONFIG.maxSamples, maxLength = DEFAULT_CONFIG.maxSampleLength) {
+  const candidates = questions.filter((q) => {
+    if (q.content.length > maxLength) return false;
+    if (containsSensitiveContent(q.content)) return false;
+    if (q.content.length < 20) return false;
+    if (/^\s*\[(?:PATH|URL|EMAIL|IP|SECRET|TRUNCATED)\]\s*$/.test(q.content))
+      return false;
+    return true;
+  }).map((q) => ({
+    content: q.content,
+    isQuestion: isQuestionFormat(q.content),
+    length: q.content.length
+  }));
+  candidates.sort((a, b) => {
+    if (a.isQuestion !== b.isQuestion) {
+      return a.isQuestion ? -1 : 1;
+    }
+    return a.length - b.length;
+  });
+  const selected = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const candidate of candidates) {
+    const normalized = candidate.content.toLowerCase().trim();
+    if (seen.has(normalized)) continue;
+    selected.push(candidate.content);
+    seen.add(normalized);
+    if (selected.length >= maxSamples) break;
+  }
+  return {
+    questions: selected,
+    maxLength
+  };
+}
+
+// src/tools/year-pack/topics.ts
+function aggregateByWeek(questions, year) {
+  const weekMap = /* @__PURE__ */ new Map();
+  for (const q of questions) {
+    if (q.timestamp.getFullYear() !== year) continue;
+    const existing = weekMap.get(q.week) ?? { content: [], count: 0 };
+    existing.content.push(q.content);
+    existing.count++;
+    weekMap.set(q.week, existing);
+  }
+  const documents = [];
+  for (const [week, data] of weekMap) {
+    let period;
+    if (week <= 17) period = "early";
+    else if (week <= 35) period = "mid";
+    else period = "late";
+    documents.push({
+      week,
+      year,
+      period,
+      content: data.content.join(" "),
+      questionCount: data.count
+    });
+  }
+  return documents.sort((a, b) => a.week - b.week);
+}
+function calculateTf(tokens) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const token of tokens) {
+    counts.set(token, (counts.get(token) ?? 0) + 1);
+  }
+  const length = tokens.length;
+  const tf = /* @__PURE__ */ new Map();
+  for (const [term, count] of counts) {
+    tf.set(term, count / length);
+  }
+  return tf;
+}
+function calculateDf(documents, minDf, maxDfRatio) {
+  const df = /* @__PURE__ */ new Map();
+  const docCount = documents.length;
+  for (const tokens of documents) {
+    const uniqueTerms = new Set(tokens);
+    for (const term of uniqueTerms) {
+      df.set(term, (df.get(term) ?? 0) + 1);
+    }
+  }
+  const maxDf = Math.floor(docCount * maxDfRatio);
+  const filtered = /* @__PURE__ */ new Map();
+  for (const [term, count] of df) {
+    if (count >= minDf && count <= maxDf) {
+      filtered.set(term, count);
+    }
+  }
+  return filtered;
+}
+function calculateTfIdf(documents, language = "en", minDf = DEFAULT_CONFIG.minDf, maxDfRatio = DEFAULT_CONFIG.maxDfRatio) {
+  const tokenizedDocs = documents.map(
+    (doc) => tokenizeWithoutStopwords(doc.content, language)
+  );
+  const df = calculateDf(tokenizedDocs, minDf, maxDfRatio);
+  const vocabulary = Array.from(df.keys());
+  const N = documents.length;
+  const vectors = [];
+  for (let i = 0; i < tokenizedDocs.length; i++) {
+    const tokens = tokenizedDocs[i];
+    if (!tokens) continue;
+    const tf = calculateTf(tokens);
+    const tfidf = /* @__PURE__ */ new Map();
+    for (const term of vocabulary) {
+      const tfVal = tf.get(term) ?? 0;
+      if (tfVal === 0) continue;
+      const dfVal = df.get(term) ?? 1;
+      const idf = Math.log(N / dfVal);
+      tfidf.set(term, tfVal * idf);
+    }
+    vectors.push({ docId: i, terms: tfidf });
+  }
+  return { vectors, vocabulary };
+}
+function vectorDistance(v1, v2) {
+  const allTerms = /* @__PURE__ */ new Set([...v1.keys(), ...v2.keys()]);
+  let sum = 0;
+  for (const term of allTerms) {
+    const diff = (v1.get(term) ?? 0) - (v2.get(term) ?? 0);
+    sum += diff * diff;
+  }
+  return Math.sqrt(sum);
+}
+function calculateCentroid(vectors, memberIds) {
+  if (memberIds.length === 0) return /* @__PURE__ */ new Map();
+  const sum = /* @__PURE__ */ new Map();
+  for (const id of memberIds) {
+    const vector = vectors.find((v) => v.docId === id);
+    if (!vector) continue;
+    for (const [term, value] of vector.terms) {
+      sum.set(term, (sum.get(term) ?? 0) + value);
+    }
+  }
+  const centroid = /* @__PURE__ */ new Map();
+  for (const [term, value] of sum) {
+    centroid.set(term, value / memberIds.length);
+  }
+  return centroid;
+}
+function kMeansPlusPlusInit(vectors, k) {
+  if (vectors.length === 0) return [];
+  if (vectors.length <= k) {
+    return vectors.map((v) => new Map(v.terms));
+  }
+  const centroids = [];
+  const firstIdx = Math.floor(Math.random() * vectors.length);
+  const firstVector = vectors[firstIdx];
+  if (firstVector) {
+    centroids.push(new Map(firstVector.terms));
+  }
+  while (centroids.length < k) {
+    const distances = [];
+    let totalDist = 0;
+    for (const vector of vectors) {
+      let minDist = Infinity;
+      for (const centroid of centroids) {
+        const dist = vectorDistance(vector.terms, centroid);
+        minDist = Math.min(minDist, dist);
+      }
+      distances.push(minDist * minDist);
+      totalDist += minDist * minDist;
+    }
+    let threshold = Math.random() * totalDist;
+    for (let i = 0; i < distances.length; i++) {
+      const dist = distances[i];
+      if (dist === void 0) continue;
+      threshold -= dist;
+      if (threshold <= 0) {
+        const selectedVector = vectors[i];
+        if (selectedVector) {
+          centroids.push(new Map(selectedVector.terms));
+        }
+        break;
+      }
+    }
+  }
+  return centroids;
+}
+function assignToClusters(vectors, centroids) {
+  const clusters = centroids.map(() => []);
+  for (const vector of vectors) {
+    let minDist = Infinity;
+    let closestCluster = 0;
+    for (let i = 0; i < centroids.length; i++) {
+      const centroid = centroids[i];
+      if (!centroid) continue;
+      const dist = vectorDistance(vector.terms, centroid);
+      if (dist < minDist) {
+        minDist = dist;
+        closestCluster = i;
+      }
+    }
+    clusters[closestCluster]?.push(vector.docId);
+  }
+  return clusters;
+}
+function kMeansClustering(vectors, k, maxIterations = DEFAULT_CONFIG.kmeansIterations) {
+  if (vectors.length === 0) return [];
+  const actualK = Math.min(k, vectors.length);
+  let centroids = kMeansPlusPlusInit(vectors, actualK);
+  let assignments = [];
+  for (let iter = 0; iter < maxIterations; iter++) {
+    assignments = assignToClusters(vectors, centroids);
+    const newCentroids = [];
+    for (let i = 0; i < actualK; i++) {
+      const members = assignments[i] ?? [];
+      if (members.length > 0) {
+        newCentroids.push(calculateCentroid(vectors, members));
+      } else {
+        const oldCentroid = centroids[i];
+        if (oldCentroid) {
+          newCentroids.push(oldCentroid);
+        }
+      }
+    }
+    centroids = newCentroids;
+  }
+  const clusters = [];
+  for (let i = 0; i < actualK; i++) {
+    const members = assignments[i] ?? [];
+    const centroid = centroids[i] ?? /* @__PURE__ */ new Map();
+    const topTerms = Array.from(centroid.entries()).sort((a, b) => b[1] - a[1]).slice(0, DEFAULT_CONFIG.topTermsPerTopic).map(([term]) => term);
+    clusters.push({
+      id: i,
+      centroid,
+      members,
+      topTerms
+    });
+  }
+  return clusters;
+}
+function generateTopicName(keywords) {
+  if (keywords.length === 0) return "General";
+  const primary = keywords[0];
+  if (!primary) return "General";
+  const formatted = primary.charAt(0).toUpperCase() + primary.slice(1).replace(/-/g, " ");
+  if (keywords.length > 1 && keywords[1]) {
+    const secondary = keywords[1].replace(/-/g, " ");
+    return `${formatted} & ${secondary}`;
+  }
+  return formatted;
+}
+function calculateTopicTrend(cluster, documents) {
+  const periodCounts = { early: 0, mid: 0, late: 0 };
+  let totalQuestions = 0;
+  for (const docId of cluster.members) {
+    const doc = documents[docId];
+    if (!doc) continue;
+    periodCounts[doc.period] += doc.questionCount;
+    totalQuestions += doc.questionCount;
+  }
+  if (totalQuestions === 0) {
+    return { early: 0, mid: 0, late: 0 };
+  }
+  return {
+    early: periodCounts.early / totalQuestions,
+    mid: periodCounts.mid / totalQuestions,
+    late: periodCounts.late / totalQuestions
+  };
+}
+function extractTopics(questions, year, language = "en", k = DEFAULT_CONFIG.kTopics) {
+  if (questions.length < MIN_QUESTIONS_FOR_TOPICS) {
+    return [];
+  }
+  const documents = aggregateByWeek(questions, year);
+  if (documents.length < k) {
+    k = Math.max(1, documents.length);
+  }
+  const { vectors } = calculateTfIdf(documents, language);
+  const clusters = kMeansClustering(vectors, k);
+  const totalQuestions = questions.filter(
+    (q) => q.timestamp.getFullYear() === year
+  ).length;
+  const topics = [];
+  for (const cluster of clusters) {
+    let clusterQuestions = 0;
+    for (const docId of cluster.members) {
+      const doc = documents[docId];
+      if (doc) clusterQuestions += doc.questionCount;
+    }
+    const share = totalQuestions > 0 ? clusterQuestions / totalQuestions : 0;
+    if (share < 0.02) continue;
+    topics.push({
+      id: cluster.id,
+      name: generateTopicName(cluster.topTerms),
+      share,
+      keywords: cluster.topTerms,
+      trend: calculateTopicTrend(cluster, documents)
+    });
+  }
+  topics.sort((a, b) => b.share - a.share);
+  topics.forEach((t, i) => t.id = i);
+  return topics;
+}
+function shouldSkipTopics(questionCount) {
+  return questionCount < MIN_QUESTIONS_FOR_TOPICS;
+}
+
+// src/tools/year-pack/prompt.ts
+var SECTION_ALLOWLISTS = {
+  title: ["meta.year", "topics[0..1].name", "keywords.topUnigrams[0..5]"],
+  poem: ["topics", "keywords.topUnigrams", "keywords.topBigrams"],
+  highlights: [
+    "topics (share + trend)",
+    "keywords.topBigrams[0..2]",
+    "stats.monthlyDistribution"
+  ],
+  stats: ["stats.*", "lengthBuckets", "keywords (optional)"],
+  style: ["lengthBuckets", "keywords", "samples (max 2-3, \u2264120 chars)"],
+  awards: ["topics", "keywords", "stats"],
+  archetype: ["topics.trend", "lengthBuckets", "keywords.topBigrams"],
+  timeline: ["stats.monthlyDistribution", "topics.trend"],
+  future: ["topics.trend (ascending)", "keywords"]
+};
+function generateEnglishPrompt(yearPack) {
+  const { meta, stats, topics } = yearPack;
+  const yearPackJson = JSON.stringify(yearPack, null, 2);
+  const hasTopics = topics.length > 0;
+  const topTopicNames = topics.slice(0, 3).map((t) => t.name).join(", ");
+  return `# Year in Review Report Generator
+
+You are generating a personalized, entertainment-focused "Year in Review" report based on the user's AI assistant chat history from ${meta.year}.
+
+## Important Guidelines
+
+1. **Tone**: Fun, insightful, celebratory - like Spotify Wrapped but for coding
+2. **Language**: English
+3. **Data Source**: Use ONLY the year_pack data provided below
+4. **Privacy**: The data has been sanitized. Do not speculate about personal details.
+5. **No Fabrication**: Only mention themes/topics that appear in the data
+
+## Report Sections
+
+Generate the following 9 sections in order:
+
+### 1. Title / Cover
+Create a catchy title for this year's coding journey.
+**Allowed data**: ${SECTION_ALLOWLISTS.title.join(", ")}
+
+### 2. Poem of Reflection
+Write a short, creative poem (4-8 lines) capturing the year's themes.
+**Allowed data**: ${SECTION_ALLOWLISTS.poem.join(", ")}
+**Note**: Do NOT use the samples field for poetry.
+
+### 3. Three Highlights of the Year
+Identify 3 standout themes or achievements based on topic trends.
+**Allowed data**: ${SECTION_ALLOWLISTS.highlights.join(", ")}
+
+### 4. Chat Stats
+Present the key statistics in an engaging way.
+**Allowed data**: ${SECTION_ALLOWLISTS.stats.join(", ")}
+- Total questions: ${stats.totalQuestions.toLocaleString()}
+- Active months: ${stats.activeMonths}
+- Most active period: [calculate from monthlyDistribution]
+
+### 5. Conversation Style
+Describe the user's questioning style based on length patterns and keywords.
+**Allowed data**: ${SECTION_ALLOWLISTS.style.join(", ")}
+
+### 6. Annual Awards
+Create 3-5 fun awards based on the data (e.g., "Most Consistent Topic", "Late-Night Coder").
+**Allowed data**: ${SECTION_ALLOWLISTS.awards.join(", ")}
+
+### 7. Archetype
+Assign a developer archetype (e.g., "The System Architect", "The Bug Hunter", "The Feature Builder").
+**Allowed data**: ${SECTION_ALLOWLISTS.archetype.join(", ")}
+**Rules**:
+- Do NOT mention MBTI or personality types
+- Do NOT infer personal attributes
+- Base it purely on coding patterns
+
+### 8. Timeline & Inflection Points
+Describe how focus shifted across the year (early \u2192 mid \u2192 late).
+**Allowed data**: ${SECTION_ALLOWLISTS.timeline.join(", ")}
+${hasTopics ? `Key topics: ${topTopicNames}` : "Note: Topic data unavailable (insufficient data)"}
+
+### 9. Future Surprise Lines
+Based on rising trends, suggest what might be next.
+**Allowed data**: ${SECTION_ALLOWLISTS.future.join(", ")}
+
+## Year Pack Data
+
+\`\`\`json
+${yearPackJson}
+\`\`\`
+
+## Output Format
+
+Generate the report with clear section headers (##) and engaging content. Make it feel personal and celebratory while staying grounded in the data provided.
+
+Remember: This is entertainment, not analysis. Have fun with it!`;
+}
+function generateChinesePrompt(yearPack) {
+  const { meta, stats, topics } = yearPack;
+  const yearPackJson = JSON.stringify(yearPack, null, 2);
+  const hasTopics = topics.length > 0;
+  const topTopicNames = topics.slice(0, 3).map((t) => t.name).join("\u3001");
+  return `# \u5E74\u5EA6\u56DE\u987E\u62A5\u544A\u751F\u6210\u5668
+
+\u4F60\u6B63\u5728\u6839\u636E\u7528\u6237 ${meta.year} \u5E74\u7684 AI \u52A9\u624B\u804A\u5929\u8BB0\u5F55\uFF0C\u751F\u6210\u4E00\u4EFD\u4E2A\u6027\u5316\u3001\u5A31\u4E50\u6027\u7684"\u5E74\u5EA6\u56DE\u987E"\u62A5\u544A\u3002
+
+## \u91CD\u8981\u6307\u5357
+
+1. **\u8BED\u6C14**\uFF1A\u6709\u8DA3\u3001\u6D1E\u5BDF\u529B\u5F3A\u3001\u5E86\u795D\u6027\u7684 - \u7C7B\u4F3C\u4E8E Spotify Wrapped\uFF0C\u4F46\u7528\u4E8E\u7F16\u7A0B
+2. **\u8BED\u8A00**\uFF1A\u4E2D\u6587
+3. **\u6570\u636E\u6765\u6E90**\uFF1A\u4EC5\u4F7F\u7528\u4E0B\u65B9\u63D0\u4F9B\u7684 year_pack \u6570\u636E
+4. **\u9690\u79C1**\uFF1A\u6570\u636E\u5DF2\u7ECF\u8FC7\u8131\u654F\u5904\u7406\u3002\u4E0D\u8981\u63A8\u6D4B\u4E2A\u4EBA\u8BE6\u60C5\u3002
+5. **\u4E0D\u8981\u865A\u6784**\uFF1A\u53EA\u63D0\u53CA\u6570\u636E\u4E2D\u51FA\u73B0\u7684\u4E3B\u9898
+
+## \u62A5\u544A\u7AE0\u8282
+
+\u6309\u987A\u5E8F\u751F\u6210\u4EE5\u4E0B 9 \u4E2A\u7AE0\u8282\uFF1A
+
+### 1. \u6807\u9898 / \u5C01\u9762
+\u4E3A\u4ECA\u5E74\u7684\u7F16\u7A0B\u4E4B\u65C5\u521B\u5EFA\u4E00\u4E2A\u5438\u5F15\u4EBA\u7684\u6807\u9898\u3002
+**\u53EF\u7528\u6570\u636E**: ${SECTION_ALLOWLISTS.title.join(", ")}
+
+### 2. \u5E74\u5EA6\u8BD7\u7BC7
+\u5199\u4E00\u9996\u7B80\u77ED\u7684\u521B\u610F\u8BD7\uFF084-8\u884C\uFF09\uFF0C\u6355\u6349\u4ECA\u5E74\u7684\u4E3B\u9898\u3002
+**\u53EF\u7528\u6570\u636E**: ${SECTION_ALLOWLISTS.poem.join(", ")}
+**\u6CE8\u610F**\uFF1A\u8BD7\u6B4C\u4E2D\u4E0D\u8981\u4F7F\u7528 samples \u5B57\u6BB5\u3002
+
+### 3. \u5E74\u5EA6\u4E09\u5927\u4EAE\u70B9
+\u6839\u636E\u4E3B\u9898\u8D8B\u52BF\uFF0C\u8BC6\u522B 3 \u4E2A\u7A81\u51FA\u7684\u4E3B\u9898\u6216\u6210\u5C31\u3002
+**\u53EF\u7528\u6570\u636E**: ${SECTION_ALLOWLISTS.highlights.join(", ")}
+
+### 4. \u804A\u5929\u7EDF\u8BA1
+\u4EE5\u6709\u8DA3\u7684\u65B9\u5F0F\u5448\u73B0\u5173\u952E\u7EDF\u8BA1\u6570\u636E\u3002
+**\u53EF\u7528\u6570\u636E**: ${SECTION_ALLOWLISTS.stats.join(", ")}
+- \u603B\u95EE\u9898\u6570\uFF1A${stats.totalQuestions.toLocaleString()}
+- \u6D3B\u8DC3\u6708\u4EFD\uFF1A${stats.activeMonths}
+- \u6700\u6D3B\u8DC3\u65F6\u671F\uFF1A[\u4ECE monthlyDistribution \u8BA1\u7B97]
+
+### 5. \u5BF9\u8BDD\u98CE\u683C
+\u6839\u636E\u95EE\u9898\u957F\u5EA6\u6A21\u5F0F\u548C\u5173\u952E\u8BCD\u63CF\u8FF0\u7528\u6237\u7684\u63D0\u95EE\u98CE\u683C\u3002
+**\u53EF\u7528\u6570\u636E**: ${SECTION_ALLOWLISTS.style.join(", ")}
+
+### 6. \u5E74\u5EA6\u5956\u9879
+\u6839\u636E\u6570\u636E\u521B\u5EFA 3-5 \u4E2A\u6709\u8DA3\u7684\u5956\u9879\uFF08\u4F8B\u5982\uFF1A"\u6700\u7A33\u5B9A\u4E3B\u9898\u5956"\u3001"\u6DF1\u591C\u7F16\u7A0B\u5956"\uFF09\u3002
+**\u53EF\u7528\u6570\u636E**: ${SECTION_ALLOWLISTS.awards.join(", ")}
+
+### 7. \u5F00\u53D1\u8005\u4EBA\u8BBE
+\u5206\u914D\u4E00\u4E2A\u5F00\u53D1\u8005\u4EBA\u8BBE\uFF08\u4F8B\u5982\uFF1A"\u7CFB\u7EDF\u67B6\u6784\u5E08"\u3001"Bug \u730E\u624B"\u3001"\u529F\u80FD\u6784\u5EFA\u8005"\uFF09\u3002
+**\u53EF\u7528\u6570\u636E**: ${SECTION_ALLOWLISTS.archetype.join(", ")}
+**\u89C4\u5219**\uFF1A
+- \u4E0D\u8981\u63D0\u53CA MBTI \u6216\u6027\u683C\u7C7B\u578B
+- \u4E0D\u8981\u63A8\u65AD\u4E2A\u4EBA\u5C5E\u6027
+- \u7EAF\u7CB9\u57FA\u4E8E\u7F16\u7A0B\u6A21\u5F0F
+
+### 8. \u65F6\u95F4\u7EBF\u4E0E\u8F6C\u6298\u70B9
+\u63CF\u8FF0\u5168\u5E74\u7126\u70B9\u7684\u53D8\u5316\uFF08\u5E74\u521D \u2192 \u5E74\u4E2D \u2192 \u5E74\u672B\uFF09\u3002
+**\u53EF\u7528\u6570\u636E**: ${SECTION_ALLOWLISTS.timeline.join(", ")}
+${hasTopics ? `\u4E3B\u8981\u4E3B\u9898\uFF1A${topTopicNames}` : "\u6CE8\u610F\uFF1A\u4E3B\u9898\u6570\u636E\u4E0D\u53EF\u7528\uFF08\u6570\u636E\u4E0D\u8DB3\uFF09"}
+
+### 9. \u672A\u6765\u5C55\u671B
+\u6839\u636E\u4E0A\u5347\u8D8B\u52BF\uFF0C\u9884\u6D4B\u63A5\u4E0B\u6765\u53EF\u80FD\u7684\u65B9\u5411\u3002
+**\u53EF\u7528\u6570\u636E**: ${SECTION_ALLOWLISTS.future.join(", ")}
+
+## Year Pack \u6570\u636E
+
+\`\`\`json
+${yearPackJson}
+\`\`\`
+
+## \u8F93\u51FA\u683C\u5F0F
+
+\u751F\u6210\u5E26\u6709\u6E05\u6670\u7AE0\u8282\u6807\u9898\uFF08##\uFF09\u548C\u5438\u5F15\u4EBA\u5185\u5BB9\u7684\u62A5\u544A\u3002\u8BA9\u5B83\u65E2\u4E2A\u6027\u5316\u53C8\u6709\u5E86\u795D\u611F\uFF0C\u540C\u65F6\u4FDD\u6301\u57FA\u4E8E\u63D0\u4F9B\u7684\u6570\u636E\u3002
+
+\u8BB0\u4F4F\uFF1A\u8FD9\u662F\u5A31\u4E50\u6027\u62A5\u544A\uFF0C\u4E0D\u662F\u5206\u6790\u62A5\u544A\u3002\u5C3D\u60C5\u53D1\u6325\uFF01`;
+}
+function generatePromptTemplate(yearPack, language = "en") {
+  return language === "zh" ? generateChinesePrompt(yearPack) : generateEnglishPrompt(yearPack);
+}
+
+// src/tools/year-pack/index.ts
+var yearPackTool = {
+  name: "cursor_history_year_pack",
+  description: "Generate a year-in-review data package from Cursor AI chat history. Produces a sanitized JSON summary with statistics, topics, and keywords, plus a prompt template for LLM-based report generation. Read-only operation.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      year: {
+        type: "integer",
+        description: `Calendar year to analyze (default: current year)`,
+        minimum: 1970,
+        maximum: (/* @__PURE__ */ new Date()).getFullYear()
+      },
+      language: {
+        type: "string",
+        description: "Report language preference (default: en)",
+        enum: ["en", "zh"]
+      },
+      workspace: {
+        type: "string",
+        description: "Optional workspace path to filter sessions"
+      },
+      maxSamples: {
+        type: "integer",
+        description: "Maximum sample questions to include (default: 30)",
+        minimum: 0,
+        maximum: 100
+      },
+      maxSampleLength: {
+        type: "integer",
+        description: "Maximum characters per sample (default: 120)",
+        minimum: 50,
+        maximum: 500
+      },
+      topicsCount: {
+        type: "integer",
+        description: "Number of topics to extract (default: 7)",
+        minimum: 3,
+        maximum: 15
+      }
+    },
+    additionalProperties: false
+  }
+};
+async function fetchSessionsForYear(year, workspace) {
+  const yearStart = new Date(year, 0, 1);
+  const yearEnd = new Date(year + 1, 0, 1);
+  const sessions = [];
+  let offset = 0;
+  const limit = 100;
+  let hasMore = true;
+  while (hasMore) {
+    const result = await listSessions2({ limit, offset, workspace });
+    const batch = result.data;
+    for (let i = 0; i < batch.length; i++) {
+      const session = batch[i];
+      if (!session) continue;
+      const sessionDate = new Date(session.timestamp);
+      if (sessionDate >= yearStart && sessionDate < yearEnd) {
+        const sessionIndex = offset + i;
+        const fullSession = await getSession2(sessionIndex);
+        sessions.push(fullSession);
+      }
+    }
+    hasMore = result.pagination.hasMore;
+    offset += limit;
+    if (offset > 1e5) break;
+  }
+  return { sessions, sessionCount: sessions.length };
+}
+function extractUserQuestions(sessions, year, maxLength) {
+  const questions = [];
+  for (const session of sessions) {
+    const messages = session.messages ?? [];
+    for (const msg of messages) {
+      if (msg.role !== "user") continue;
+      if (!msg.content || msg.content.trim().length === 0) continue;
+      let timestamp;
+      if (msg.timestamp) {
+        timestamp = new Date(msg.timestamp);
+      } else if (session.timestamp) {
+        timestamp = new Date(session.timestamp);
+      } else {
+        continue;
+      }
+      if (timestamp.getFullYear() !== year) continue;
+      const processed = processQuestion(msg.content, timestamp, maxLength);
+      if (processed.content.trim().length < 10) continue;
+      questions.push(processed);
+    }
+  }
+  return questions;
+}
+function buildYearPack(questions, input, sessionCount) {
+  const { year, language, workspace, maxSamples, maxSampleLength, topicsCount } = input;
+  const { totalQuestions, activeMonths, monthlyDistribution, lengthBuckets } = calculateStats(questions);
+  const keywords = extractKeywords(
+    questions.map((q) => q.content),
+    language,
+    DEFAULT_CONFIG.topUnigrams,
+    DEFAULT_CONFIG.topBigrams
+  );
+  const topics = shouldSkipTopics(totalQuestions) ? [] : extractTopics(questions, year, language, topicsCount);
+  const samples = selectSafeSamples(questions, maxSamples, maxSampleLength);
+  const meta = {
+    year,
+    language,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    workspace: workspace ?? null,
+    questionCount: totalQuestions,
+    sessionCount
+  };
+  const safety = {
+    filtersApplied: getAppliedFilters(),
+    guarantees: [...SAFETY_GUARANTEES]
+  };
+  const notes = [
+    "Data is aggregated and sanitized for entertainment purposes.",
+    "Topic trends indicate focus shifts, not exact timelines."
+  ];
+  if (shouldSkipTopics(totalQuestions)) {
+    notes.push(
+      `Topic extraction skipped: fewer than 50 questions (${totalQuestions} found).`
+    );
+  }
+  return {
+    meta,
+    stats: {
+      totalQuestions,
+      activeMonths,
+      monthlyDistribution
+    },
+    lengthBuckets,
+    keywords,
+    topics,
+    samples,
+    safety,
+    notes
+  };
+}
+async function handleYearPack(args) {
+  const startTime = Date.now();
+  try {
+    const input = YearPackInputSchema.parse(args);
+    const { year, language, workspace } = input;
+    const { sessions, sessionCount } = await fetchSessionsForYear(
+      year,
+      workspace
+    );
+    if (sessionCount === 0) {
+      const workspaceMsg = workspace ? ` in workspace "${workspace}"` : "";
+      return `No chat sessions found for year ${year}${workspaceMsg}. Make sure you have Cursor AI chat history for this period.`;
+    }
+    const questions = extractUserQuestions(
+      sessions,
+      year,
+      DEFAULT_CONFIG.maxLineChars
+    );
+    if (questions.length === 0) {
+      return `Found ${sessionCount} session(s) for year ${year}, but no user questions were extracted. Sessions may only contain assistant responses or tool calls.`;
+    }
+    const yearPack = buildYearPack(questions, input, sessionCount);
+    const promptTemplate = generatePromptTemplate(yearPack, language);
+    const response = {
+      yearPack,
+      promptTemplate
+    };
+    const processingTimeMs = Date.now() - startTime;
+    const processingTimeSec = (processingTimeMs / 1e3).toFixed(2);
+    const output = [
+      `# Year Pack Generated Successfully`,
+      ``,
+      `**Year**: ${year}`,
+      `**Language**: ${language}`,
+      `**Sessions Analyzed**: ${sessionCount}`,
+      `**Questions Processed**: ${questions.length}`,
+      `**Topics Extracted**: ${yearPack.topics.length}`,
+      `**Processing Time**: ${processingTimeSec}s`,
+      ``,
+      `## Year Pack JSON`,
+      ``,
+      "```json",
+      JSON.stringify(response.yearPack, null, 2),
+      "```",
+      ``,
+      `## Prompt Template`,
+      ``,
+      `The prompt template is included below. Copy it and use it with any LLM to generate your annual report.`,
+      ``,
+      "---",
+      ``,
+      response.promptTemplate
+    ];
+    return output.join("\n");
+  } catch (error) {
+    const mcpError = mapCursorHistoryError(error);
+    if (isMcpError(mcpError)) {
+      throw new Error(mcpError.message);
+    }
+    throw error;
+  }
+}
+
 // src/index.ts
 var TOOLS = [
   listSessionsTool,
@@ -11981,7 +13331,8 @@ var TOOLS = [
   exportTool,
   backupTool,
   restoreTool,
-  migrateTool
+  migrateTool,
+  yearPackTool
 ];
 var TOOL_HANDLERS = {
   cursor_history_list: handleListSessions,
@@ -11990,7 +13341,8 @@ var TOOL_HANDLERS = {
   cursor_history_export: handleExport,
   cursor_history_backup: handleBackup,
   cursor_history_restore: handleRestore,
-  cursor_history_migrate: handleMigrate
+  cursor_history_migrate: handleMigrate,
+  cursor_history_year_pack: handleYearPack
 };
 function createServer() {
   const server = new Server(