memory-journal-mcp 7.3.0 → 7.4.0

package/dist/{chunk-ZJJD2F5T.js → chunk-P5V2VY6N.js}

@@ -114,7 +114,7 @@ var SIGNIFICANCE_TYPES = [
   "release"
 ];
 var MAX_CONTENT_LENGTH = 5e4;
-var MAX_QUERY_LIMIT = 500;
+var MAX_QUERY_LIMIT = Number("500");
 var DATE_MIN_SENTINEL = "1970-01-01";
 var DATE_MAX_SENTINEL = "2999-12-31";
 var DATE_FORMAT_REGEX = /^\d{4}-\d{2}-\d{2}$/;
@@ -140,7 +140,8 @@ var EntryOutputSchema = z.object({
   workflowRunId: z.number().nullable().optional(),
   workflowName: z.string().nullable().optional(),
   workflowStatus: z.string().nullable().optional(),
-  source: z.enum(["personal", "team"]).optional()
+  source: z.enum(["personal", "team"]).optional(),
+  importanceScore: z.number().optional().describe("Importance score (0.0-1.0), present when sort_by=importance")
 }).extend(ErrorFieldsMixin.shape);
 var EntriesListOutputSchema = z.object({
   entries: z.array(EntryOutputSchema).optional(),
@@ -217,11 +218,13 @@ var GetEntryByIdSchemaMcp = z.object({
 });
 var GetRecentEntriesSchema = z.object({
   limit: z.number().min(1).max(MAX_QUERY_LIMIT).optional().default(5),
-  is_personal: z.boolean().optional()
+  is_personal: z.boolean().optional(),
+  sort_by: z.enum(["timestamp", "importance"]).optional().default("timestamp").describe("Sort results by timestamp (default) or importance score")
 });
 var GetRecentEntriesSchemaMcp = z.object({
   limit: relaxedNumber().optional().default(5),
-  is_personal: z.boolean().optional()
+  is_personal: z.boolean().optional(),
+  sort_by: z.string().optional().default("timestamp").describe("Sort results by timestamp (default) or importance score")
 });
 var CreateEntryMinimalSchema = z.object({
   content: z.string().min(1).max(MAX_CONTENT_LENGTH)
@@ -389,8 +392,8 @@ function getCoreTools(context) {
       annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
       handler: (params) => {
         try {
-          const { limit, is_personal } = GetRecentEntriesSchema.parse(params);
-          const entries = db.getRecentEntries(limit, is_personal);
+          const { limit, is_personal, sort_by } = GetRecentEntriesSchema.parse(params);
+          const entries = db.getRecentEntries(limit, is_personal, sort_by);
           return { success: true, entries, count: entries.length };
         } catch (err) {
           return formatHandlerError(err);
@@ -459,10 +462,19 @@ var DEDUP_KEY_LENGTH = 200;
 function calcPerDbLimit(limit, hasTeamDb) {
   return hasTeamDb ? Math.min(limit * 2, MAX_QUERY_LIMIT) : limit;
 }
-function mergeAndDedup(personal, team, limit) {
+function mergeAndDedup(personal, team, limit, sortBy = "timestamp") {
   const seen = /* @__PURE__ */ new Set();
   const merged = [];
-  const all = [...personal, ...team].sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+  const all = [...personal, ...team].sort((a, b) => {
+    if (sortBy === "importance") {
+      const scoreA = Number(a["importanceScore"]) || 0;
+      const scoreB = Number(b["importanceScore"]) || 0;
+      if (scoreA !== scoreB) {
+        return scoreB - scoreA;
+      }
+    }
+    return b.timestamp.localeCompare(a.timestamp);
+  });
   for (const entry of all) {
     const key = entry.content.slice(0, DEDUP_KEY_LENGTH);
     if (!seen.has(key)) {
@@ -536,7 +548,7 @@ function ftsSearch(query, db, teamDb, options) {
   const perDbLimit = calcPerDbLimit(options.limit, !!teamDb);
   let personalEntries;
   if (!query && !hasFilters) {
-    personalEntries = db.getRecentEntries(perDbLimit, options.isPersonal);
+    personalEntries = db.getRecentEntries(perDbLimit, options.isPersonal, options.sortBy);
   } else {
     personalEntries = db.searchEntries(query || "", {
       limit: perDbLimit,
@@ -549,13 +561,14 @@ function ftsSearch(query, db, teamDb, options) {
       tags: options.tags,
       entryType: options.entryType,
       startDate: options.startDate,
-      endDate: options.endDate
+      endDate: options.endDate,
+      sortBy: options.sortBy
     });
   }
   if (teamDb && options.isPersonal !== true) {
     let teamEntries;
     if (!query && !hasFilters) {
-      teamEntries = teamDb.getRecentEntries(perDbLimit);
+      teamEntries = teamDb.getRecentEntries(perDbLimit, void 0, options.sortBy);
     } else {
       teamEntries = teamDb.searchEntries(query || "", {
         limit: perDbLimit,
@@ -567,13 +580,15 @@ function ftsSearch(query, db, teamDb, options) {
         tags: options.tags,
         entryType: options.entryType,
         startDate: options.startDate,
-        endDate: options.endDate
+        endDate: options.endDate,
+        sortBy: options.sortBy
       });
     }
     const merged = mergeAndDedup(
       personalEntries.map((e) => ({ ...e, source: "personal" })),
       teamEntries.map((e) => ({ ...e, source: "team" })),
-      options.limit
+      options.limit,
+      options.sortBy
     );
     return { entries: merged, count: merged.length };
   }
@@ -651,7 +666,8 @@ var SearchEntriesSchema = z.object({
   tags: z.array(z.string()).optional(),
   entry_type: z.enum(ENTRY_TYPES).optional(),
   start_date: z.string().regex(DATE_FORMAT_REGEX, DATE_FORMAT_MESSAGE).optional(),
-  end_date: z.string().regex(DATE_FORMAT_REGEX, DATE_FORMAT_MESSAGE).optional()
+  end_date: z.string().regex(DATE_FORMAT_REGEX, DATE_FORMAT_MESSAGE).optional(),
+  sort_by: z.enum(["timestamp", "importance"]).optional().default("timestamp").describe("Sort results by timestamp (default) or importance score")
 });
 var SearchEntriesSchemaMcp = z.object({
   query: z.string().optional(),
@@ -668,7 +684,8 @@ var SearchEntriesSchemaMcp = z.object({
   tags: z.array(z.string()).optional(),
   entry_type: z.string().optional(),
   start_date: z.string().optional(),
-  end_date: z.string().optional()
+  end_date: z.string().optional(),
+  sort_by: z.string().optional().default("timestamp").describe("Sort results by timestamp (default) or importance score")
 });
 var SearchByDateRangeSchema = z.object({
   start_date: z.string().regex(DATE_FORMAT_REGEX, DATE_FORMAT_MESSAGE),
@@ -680,7 +697,8 @@ var SearchByDateRangeSchema = z.object({
   issue_number: z.number().optional(),
   pr_number: z.number().optional(),
   workflow_run_id: z.number().optional(),
-  limit: z.number().max(MAX_QUERY_LIMIT).optional().default(500)
+  limit: z.number().max(MAX_QUERY_LIMIT).optional().default(500),
+  sort_by: z.enum(["timestamp", "importance"]).optional().default("timestamp").describe("Sort results by timestamp (default) or importance score")
 });
 var SearchByDateRangeSchemaMcp = z.object({
   start_date: z.string(),
@@ -692,7 +710,8 @@ var SearchByDateRangeSchemaMcp = z.object({
   issue_number: relaxedNumber().optional(),
   pr_number: relaxedNumber().optional(),
   workflow_run_id: relaxedNumber().optional(),
-  limit: relaxedNumber().optional().default(500)
+  limit: relaxedNumber().optional().default(500),
+  sort_by: z.string().optional().default("timestamp").describe("Sort results by timestamp (default) or importance score")
 });
 var SemanticSearchSchema = z.object({
   query: z.string().optional(),
@@ -786,7 +805,8 @@ function getSearchTools(context) {
             tags: input.tags,
             entryType: input.entry_type,
             startDate: input.start_date,
-            endDate: input.end_date
+            endDate: input.end_date,
+            sortBy: input.sort_by
           };
           switch (effectiveMode) {
             case "semantic": {
@@ -805,9 +825,29 @@ function getSearchTools(context) {
               const entries = semanticResults.map((r) => {
                 const entry = entriesMap.get(r.entryId);
                 if (!entry) return null;
-                if (!passMetadataFilters(entry, searchOptions, db)) return null;
+                if (!passMetadataFilters(
+                  entry,
+                  searchOptions,
+                  db
+                ))
+                  return null;
                 return { ...entry, source: "personal" };
-              }).filter((e) => e !== null);
+              }).filter((e) => e !== null).slice(0, input.limit);
+              if (input.sort_by === "importance") {
+                const scored = entries.map((e) => {
+                  const { score } = db.calculateImportance(e.id);
+                  return { ...e, importanceScore: Math.round(score * 100) / 100 };
+                });
+                scored.sort(
+                  (a, b) => (b.importanceScore ?? 0) - (a.importanceScore ?? 0)
+                );
+                return {
+                  success: true,
+                  entries: scored,
+                  count: scored.length,
+                  searchMode: isAuto ? "semantic (auto)" : "semantic"
+                };
+              }
               return {
                 success: true,
                 entries,
@@ -826,6 +866,22 @@ function getSearchTools(context) {
                 vectorManager,
                 searchOptions
               );
+              if (input.sort_by === "importance") {
+                const scored = entries.map((e) => {
+                  const entryId = e["id"];
+                  const { score } = db.calculateImportance(entryId);
+                  return { ...e, importanceScore: Math.round(score * 100) / 100 };
+                });
+                scored.sort(
+                  (a, b) => (b.importanceScore ?? 0) - (a.importanceScore ?? 0)
+                );
+                return {
+                  success: true,
+                  entries: scored,
+                  count: scored.length,
+                  searchMode: isAuto ? "hybrid (auto)" : "hybrid"
+                };
+              }
               return {
                 success: true,
                 entries,
@@ -878,7 +934,8 @@ function getSearchTools(context) {
             issueNumber: input.issue_number,
             prNumber: input.pr_number,
             workflowRunId: input.workflow_run_id,
-            limit: perDbLimit
+            limit: perDbLimit,
+            sortBy: input.sort_by
           });
           if (teamDb && input.is_personal !== true) {
             const teamEntries = teamDb.searchByDateRange(
@@ -891,13 +948,15 @@ function getSearchTools(context) {
                 issueNumber: input.issue_number,
                 prNumber: input.pr_number,
                 workflowRunId: input.workflow_run_id,
-                limit: perDbLimit
+                limit: perDbLimit,
+                sortBy: input.sort_by
               }
             );
             const merged = mergeAndDedup(
               personalEntries.map((e) => ({ ...e, source: "personal" })),
               teamEntries.map((e) => ({ ...e, source: "team" })),
-              input.limit
+              input.limit,
+              input.sort_by
             );
             return { success: true, entries: merged, count: merged.length };
           }
@@ -975,7 +1034,8 @@ function getSearchTools(context) {
               startDate: input.start_date,
               endDate: input.end_date
             };
-            if (!passMetadataFilters(entry, filterOptions, db)) return null;
+            if (!passMetadataFilters(entry, filterOptions, db))
+              return null;
             if (input.entry_id !== void 0 && entry.id === input.entry_id)
               return null;
             return {
@@ -2697,7 +2757,8 @@ var CloseGitHubIssueWithEntryOutputSchema = z.object({
   }).optional(),
   kanban: z.object({
     moved: z.boolean(),
-    projectNumber: z.number(),
+    projectNumber: z.number().optional(),
+    error: z.string().optional(),
     message: z.string().optional()
   }).optional(),
   message: z.string().optional(),
@@ -4720,20 +4781,24 @@ var TeamCreateEntrySchemaMcp = z.object({
   author: z.string().optional()
 });
 var TeamGetRecentSchema = z.object({
-  limit: z.number().min(1).max(500).optional().default(10)
+  limit: z.number().min(1).max(500).optional().default(10),
+  sort_by: z.enum(["timestamp", "importance"]).optional().default("timestamp").describe("Sort results by timestamp (default) or importance score")
 });
 var TeamGetRecentSchemaMcp = z.object({
-  limit: relaxedNumber().optional().default(10)
+  limit: relaxedNumber().optional().default(10),
+  sort_by: z.string().optional().default("timestamp").describe("Sort results by timestamp (default) or importance score")
 });
 var TeamSearchSchema = z.object({
   query: z.string().optional(),
   tags: z.array(z.string()).optional(),
-  limit: z.number().max(500).optional().default(10)
+  limit: z.number().max(500).optional().default(10),
+  sort_by: z.enum(["timestamp", "importance"]).optional().default("timestamp").describe("Sort results by timestamp (default) or importance score")
 });
 var TeamSearchSchemaMcp = z.object({
   query: z.string().optional(),
   tags: z.array(z.string()).optional(),
-  limit: relaxedNumber().optional().default(10)
+  limit: relaxedNumber().optional().default(10),
+  sort_by: z.string().optional().default("timestamp").describe("Sort results by timestamp (default) or importance score")
 });
 var TeamGetEntryByIdSchema = z.object({
   entry_id: z.number(),
@@ -4748,14 +4813,16 @@ var TeamSearchByDateRangeSchema = z.object({
   end_date: z.string().regex(DATE_FORMAT_REGEX, DATE_FORMAT_MESSAGE),
   entry_type: z.enum(ENTRY_TYPES).optional(),
   tags: z.array(z.string()).optional(),
-  limit: z.number().max(500).optional().default(50)
+  limit: z.number().max(500).optional().default(50),
+  sort_by: z.enum(["timestamp", "importance"]).optional().default("timestamp").describe("Sort results by timestamp (default) or importance score")
 });
 var TeamSearchByDateRangeSchemaMcp = z.object({
   start_date: z.string().optional().describe("Start date (YYYY-MM-DD)"),
   end_date: z.string().optional().describe("End date (YYYY-MM-DD)"),
   entry_type: z.string().optional(),
   tags: z.array(z.string()).optional(),
-  limit: relaxedNumber().optional().default(50)
+  limit: relaxedNumber().optional().default(50),
+  sort_by: z.string().optional().default("timestamp").describe("Sort results by timestamp (default) or importance score")
 });
 var TeamUpdateEntrySchema = z.object({
   entry_id: z.number(),
@@ -5042,6 +5109,40 @@ var TeamCrossProjectInsightsOutputSchema = z.object({
   success: z.boolean().optional(),
   error: z.string().optional()
 }).extend(ErrorFieldsMixin.shape);
+var TeamCollaborationMatrixSchema = z.object({
+  period: z.enum(["week", "month", "quarter"]).optional().default("month").describe("Time granularity for the activity heatmap"),
+  limit: z.number().max(100).optional().default(20).describe("Max authors to include")
+});
+var TeamCollaborationMatrixSchemaMcp = z.object({
+  period: z.string().optional().default("month"),
+  limit: relaxedNumber().optional().default(20)
+});
+var TeamCollaborationMatrixOutputSchema = z.object({
+  success: z.boolean().optional(),
+  totalAuthors: z.number().optional(),
+  totalEntries: z.number().optional(),
+  authorActivity: z.array(
+    z.object({
+      author: z.string(),
+      period: z.string(),
+      entryCount: z.number()
+    })
+  ).optional(),
+  crossAuthorLinks: z.array(
+    z.object({
+      fromAuthor: z.string(),
+      toAuthor: z.string(),
+      linkCount: z.number()
+    })
+  ).optional(),
+  impactFactor: z.array(
+    z.object({
+      author: z.string(),
+      inboundLinks: z.number()
+    })
+  ).optional(),
+  error: z.string().optional()
+}).extend(ErrorFieldsMixin.shape);
 
 // src/handlers/tools/team/core-tools.ts
 function getTeamCoreTools(context) {
@@ -5154,8 +5255,8 @@ function getTeamCoreTools(context) {
           if (!teamDb) {
             return { ...TEAM_DB_ERROR_RESPONSE };
           }
-          const { limit } = TeamGetRecentSchema.parse(params);
-          const entries = teamDb.getRecentEntries(limit);
+          const { limit, sort_by } = TeamGetRecentSchema.parse(params);
+          const entries = teamDb.getRecentEntries(limit, void 0, sort_by);
           const authorMap = batchFetchAuthors(
             teamDb,
             entries.map((e) => e.id)
@@ -5211,13 +5312,16 @@ function getTeamSearchTools(context) {
           if (!teamDb) {
             return { ...TEAM_DB_ERROR_RESPONSE };
           }
-          const { query, tags, limit } = TeamSearchSchema.parse(params);
-          const searchLimit = tags && tags.length > 0 ? Math.max(limit * 5, 50) : limit;
+          const { query, tags, limit, sort_by } = TeamSearchSchema.parse(params);
+          const searchLimit = tags && tags.length > 0 ? Math.min(Math.max(limit * 5, 50), 1e3) : limit;
           let entries;
           if (query) {
-            entries = teamDb.searchEntries(query, { limit: searchLimit });
+            entries = teamDb.searchEntries(query, {
+              limit: searchLimit,
+              sortBy: sort_by
+            });
           } else {
-            entries = teamDb.getRecentEntries(searchLimit);
+            entries = teamDb.getRecentEntries(searchLimit, void 0, sort_by);
           }
           if (tags && tags.length > 0) {
             const entryIds = entries.map((e) => e.id);
@@ -5271,7 +5375,7 @@ function getTeamSearchTools(context) {
           if (!teamDb) {
             return { ...TEAM_DB_ERROR_RESPONSE };
           }
-          const { start_date, end_date, entry_type, tags, limit } = TeamSearchByDateRangeSchema.parse(params);
+          const { start_date, end_date, entry_type, tags, limit, sort_by } = TeamSearchByDateRangeSchema.parse(params);
           if (start_date > end_date) {
             return {
               success: false,
@@ -5285,7 +5389,8 @@ function getTeamSearchTools(context) {
           const entries = teamDb.searchByDateRange(start_date, end_date, {
             entryType: entry_type,
             tags,
-            limit
+            limit,
+            sortBy: sort_by
           });
           const authorMap = batchFetchAuthors(
             teamDb,
@@ -5516,6 +5621,7 @@ function getTeamAnalyticsTools(context) {
           );
           if (!projectsResult[0] || projectsResult[0].values.length === 0) {
             return {
+              success: true,
               project_count: 0,
               total_entries: 0,
               projects: [],
@@ -5592,6 +5698,7 @@ function getTeamAnalyticsTools(context) {
             )
           }));
           return {
+            success: true,
             project_count: projects.length,
             total_entries: totalEntries,
             projects: projects.map((p) => ({
@@ -5606,6 +5713,97 @@ function getTeamAnalyticsTools(context) {
           return formatHandlerError(err);
         }
       }
+    },
+    {
+      name: "team_get_collaboration_matrix",
+      title: "Team Collaboration Matrix",
+      description: "Analyze cross-author collaboration: activity heatmap per period, cross-linking patterns between authors, and impact factor (inbound links). Requires TEAM_DB_PATH.",
+      group: "team",
+      inputSchema: TeamCollaborationMatrixSchemaMcp,
+      outputSchema: TeamCollaborationMatrixOutputSchema,
+      annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
+      handler: (params) => {
+        try {
+          if (!teamDb) {
+            return { ...TEAM_DB_ERROR_RESPONSE };
+          }
+          const { period, limit } = TeamCollaborationMatrixSchema.parse(params);
+          const dateFormat = period === "week" ? "%Y-W%W" : period === "quarter" ? "%Y-Q" : "%Y-%m";
+          const activityResult = teamDb.executeRawQuery(
+            `SELECT
+                            COALESCE(author, 'unknown') AS author,
+                            strftime('${dateFormat}', timestamp) AS period,
+                            COUNT(*) AS entry_count
+                        FROM memory_journal
+                        WHERE deleted_at IS NULL
+                        GROUP BY author, period
+                        ORDER BY period DESC, entry_count DESC
+                        LIMIT ?`,
+            [limit * 10]
+            // Up to 10 periods per author
+          );
+          const authorActivity = activityResult[0]?.values.map((row) => ({
+            author: row[0],
+            period: row[1],
+            entryCount: row[2]
+          })) ?? [];
+          const crossLinkResult = teamDb.executeRawQuery(
+            `SELECT
+                            COALESCE(m1.author, 'unknown') AS from_author,
+                            COALESCE(m2.author, 'unknown') AS to_author,
+                            COUNT(*) AS link_count
+                        FROM relationships r
+                        JOIN memory_journal m1 ON r.from_entry_id = m1.id
+                        JOIN memory_journal m2 ON r.to_entry_id = m2.id
+                        WHERE m1.deleted_at IS NULL AND m2.deleted_at IS NULL
+                            AND COALESCE(m1.author, 'unknown') != COALESCE(m2.author, 'unknown')
+                        GROUP BY from_author, to_author
+                        ORDER BY link_count DESC
+                        LIMIT ?`,
+            [limit]
+          );
+          const crossAuthorLinks = crossLinkResult[0]?.values.map((row) => ({
+            fromAuthor: row[0],
+            toAuthor: row[1],
+            linkCount: row[2]
+          })) ?? [];
+          const impactResult = teamDb.executeRawQuery(
+            `SELECT
+                            COALESCE(m2.author, 'unknown') AS author,
+                            COUNT(*) AS inbound_links
+                        FROM relationships r
+                        JOIN memory_journal m2 ON r.to_entry_id = m2.id
+                        WHERE m2.deleted_at IS NULL
+                        GROUP BY author
+                        ORDER BY inbound_links DESC
+                        LIMIT ?`,
+            [limit]
+          );
+          const impactFactor = impactResult[0]?.values.map((row) => ({
+            author: row[0],
+            inboundLinks: row[1]
+          })) ?? [];
+          const totalsResult = teamDb.executeRawQuery(
+            `SELECT
+                            COUNT(DISTINCT COALESCE(author, 'unknown')) AS total_authors,
+                            COUNT(*) AS total_entries
+                        FROM memory_journal
+                        WHERE deleted_at IS NULL`
+          );
+          const totalAuthors = totalsResult[0]?.values[0]?.[0] ?? 0;
+          const totalEntries = totalsResult[0]?.values[0]?.[1] ?? 0;
+          return {
+            success: true,
+            totalAuthors,
+            totalEntries,
+            authorActivity,
+            crossAuthorLinks,
+            impactFactor
+          };
+        } catch (err) {
+          return formatHandlerError(err);
+        }
+      }
     }
   ];
 }
@@ -7774,7 +7972,8 @@ var TOOL_GROUPS = {
     "team_get_vector_index_stats",
     "team_rebuild_vector_index",
     "team_add_to_vector_index",
-    "team_get_cross_project_insights"
+    "team_get_cross_project_insights",
+    "team_get_collaboration_matrix"
   ],
   codemode: ["mj_execute_code"]
 };

package/dist/cli.js

@@ -1,5 +1,5 @@
-import { VERSION, createServer } from './chunk-CHWIPVQN.js';
-import { DEFAULT_AUDIT_LOG_MAX_SIZE_BYTES } from './chunk-ZJJD2F5T.js';
+import { VERSION, createServer } from './chunk-5ZA77VUW.js';
+import { DEFAULT_AUDIT_LOG_MAX_SIZE_BYTES } from './chunk-P5V2VY6N.js';
 import './chunk-OKOVZ5QE.js';
 import { logger } from './chunk-WXDEVIFL.js';
 import { Command } from 'commander';
@@ -35,6 +35,10 @@ program.name("memory-journal-mcp").description("Project context management for A
   "--rebuild-index-interval <minutes>",
   "Vector index rebuild interval in minutes, HTTP only (0 = disabled)",
   "0"
+).option(
+  "--digest-interval <minutes>",
+  "Analytics digest interval in minutes, HTTP only (0 = disabled; recommended: 1440 for daily)",
+  "0"
 ).option(
   "--sandbox-mode <mode>",
   'Code Mode sandbox: "worker" (production, default) or "vm" (lightweight)',
@@ -150,7 +154,8 @@ program.name("memory-journal-mcp").description("Project context management for A
           backupIntervalMinutes: parseInt(options.backupInterval, 10),
           keepBackups: parseInt(options.keepBackups, 10),
           vacuumIntervalMinutes: parseInt(options.vacuumInterval, 10),
-          rebuildIndexIntervalMinutes: parseInt(options.rebuildIndexInterval, 10)
+          rebuildIndexIntervalMinutes: parseInt(options.rebuildIndexInterval, 10),
+          digestIntervalMinutes: parseInt(options.digestInterval, 10)
         },
         sandboxMode: options.sandboxMode,
         // OAuth 2.1

package/dist/index.d.ts

@@ -383,7 +383,7 @@ interface IDatabaseAdapter {
     getEntryByIdIncludeDeleted(id: number): JournalEntry | null;
     getEntriesByIds(ids: number[]): Map<number, JournalEntry>;
     calculateImportance(entryId: number): ImportanceResult;
-    getRecentEntries(limit?: number, isPersonal?: boolean): JournalEntry[];
+    getRecentEntries(limit?: number, isPersonal?: boolean, sortBy?: 'timestamp' | 'importance'): JournalEntry[];
     getEntriesPage(offset: number, limit: number): JournalEntry[];
     getActiveEntryCount(): number;
     updateEntry(id: number, updates: {
@@ -405,6 +405,7 @@ interface IDatabaseAdapter {
         entryType?: EntryType;
         startDate?: string;
         endDate?: string;
+        sortBy?: 'timestamp' | 'importance';
     }): JournalEntry[];
     searchByDateRange(startDate: string, endDate: string, options?: {
         entryType?: EntryType;
@@ -415,6 +416,7 @@ interface IDatabaseAdapter {
         prNumber?: number;
         workflowRunId?: number;
         limit?: number;
+        sortBy?: 'timestamp' | 'importance';
     }): JournalEntry[];
     getStatistics(groupBy?: 'day' | 'week' | 'month' | 'year', startDate?: string, endDate?: string, projectBreakdown?: boolean): Record<string, unknown>;
     getTagsForEntry(entryId: number): string[];
@@ -468,6 +470,17 @@ interface IDatabaseAdapter {
     getRawDb(): unknown;
     pragma(command: string): void;
     executeRawQuery(sql: string, params?: unknown[]): QueryResult[];
+    saveAnalyticsSnapshot(type: string, data: Record<string, unknown>): number;
+    getLatestAnalyticsSnapshot(type: string): {
+        id: number;
+        createdAt: string;
+        data: Record<string, unknown>;
+    } | null;
+    getAnalyticsSnapshots(type: string, limit?: number): {
+        id: number;
+        createdAt: string;
+        data: Record<string, unknown>;
+    }[];
 }
 
 /**
@@ -488,6 +501,8 @@ interface SchedulerOptions {
     vacuumIntervalMinutes: number;
     /** Vector index rebuild interval in minutes (0 = disabled) */
     rebuildIndexIntervalMinutes: number;
+    /** Analytics digest interval in minutes (0 = disabled; recommended: 1440 for daily) */
+    digestIntervalMinutes: number;
 }
 
 /**
@@ -510,7 +525,7 @@ type SandboxMode = 'vm' | 'worker';
 /**
  * Tool group definitions mapping group names to tool names
  *
- * All 67 tools are categorized here for filtering support.
+ * All 68 tools are categorized here for filtering support.
  */
 declare const TOOL_GROUPS: Record<ToolGroup, string[]>;
 /**

package/dist/index.js

@@ -1,5 +1,5 @@
-export { VERSION, createServer } from './chunk-CHWIPVQN.js';
-export { META_GROUPS, TOOL_GROUPS, calculateTokenSavings, filterTools, getAllToolNames, getFilterSummary, getToolFilterFromEnv, getToolGroup, isToolEnabled, parseToolFilter } from './chunk-ZJJD2F5T.js';
+export { VERSION, createServer } from './chunk-5ZA77VUW.js';
+export { META_GROUPS, TOOL_GROUPS, calculateTokenSavings, filterTools, getAllToolNames, getFilterSummary, getToolFilterFromEnv, getToolGroup, isToolEnabled, parseToolFilter } from './chunk-P5V2VY6N.js';
 import './chunk-OKOVZ5QE.js';
 export { logger } from './chunk-WXDEVIFL.js';
 

package/dist/{tools-MNMGDTQI.js → tools-WZUENKJ6.js}

@@ -1,3 +1,3 @@
-export { callTool, getGlobalAuditLogger, getTools, initializeAuditLogger } from './chunk-ZJJD2F5T.js';
+export { callTool, getGlobalAuditLogger, getTools, initializeAuditLogger } from './chunk-P5V2VY6N.js';
 import './chunk-OKOVZ5QE.js';
 import './chunk-WXDEVIFL.js';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "memory-journal-mcp",
-    "version": "7.3.0",
+    "version": "7.4.0",
     "description": "Project context management for AI-assisted development - Persistent knowledge graphs and intelligent context recall across fragmented AI threads",
     "type": "module",
     "main": "dist/index.js",

package/skills/README.md

@@ -42,18 +42,22 @@ The markdown body contains the full instructions the agent follows once the skil
 | ---------------------- | --------------------------------------------------------------------------------------------------------------------- |
 | `autonomous-dev`       | Harness for autonomous software development — alignment gates, adversarial agents, Git workflows, and CI/CD pipelines |
 | `bun`                  | Master the Bun all-in-one toolkit — runtime, package manager, test runner, and bundler                                |
+| `docker`               | Production-grade Docker — multi-stage builds, security hardening, Compose v2, BuildKit, and CI/CD integration         |
+| `github-actions`       | GitHub Actions CI/CD — SHA pinning, reusable workflows, caching, matrix strategies, and artifacts v4                  |
 | `github-commander`     | GitHub pipeline workflows for orchestrating issues, regressions, and deployments                                      |
 | `gitlab`               | Specialized assistant skill for managing repositories, code search, and CI/CD in GitLab                               |
 | `golang`               | Master Go development with production-grade best practices from Google and Uber style guides                          |
-| `typescript`           | Enterprise-grade TypeScript development with type-safe patterns, Zod validation, and modern tooling                   |
 | `mysql`                | Enterprise MySQL production rules — query safety, connection pooling, strict schema configurations                    |
 | `playwright-standard`  | Opinionated guidance for Playwright E2E/API tests, Page Object Models, and CI/CD resilience                           |
 | `postgres`             | Advanced PostgreSQL patterns — indexing layouts, JSONB querying, transactional guardrails, and RLS                    |
+| `python`               | Modern Python engineering — uv, ruff, type hints, pytest, Pydantic v2, and src/ layout project structure              |
 | `react-best-practices` | Vercel engineering guidelines for React/Next.js performance, hooks, and bundle optimization                           |
 | `rust`                 | Master Rust development using a layer-based "meta-cognition" framework for borrowing, lifetimes, and architecture     |
 | `shadcn-ui`            | Deep knowledge of shadcn/ui components, patterns, forms, and best practices                                           |
 | `skill-builder`        | Guide for creating, evaluating, and refining agent skills — progressive disclosure, triggers, and testing             |
 | `sqlite`               | Production configurations for concurrency (WAL), typing (STRICT), and data integrity                                  |
+| `tailwind-css`         | Tailwind CSS v4 — CSS-first configuration, @theme directive, dark mode, responsive design, and v3 migration           |
+| `typescript`           | Enterprise-grade TypeScript development with type-safe patterns, Zod validation, and modern tooling                   |
 | `vitest-standard`      | Comprehensive unit testing expertise covering Vitest, TDD, mocking strategies, and test architecture                  |
 
 ## GitHub Commander Workflows