l-log-mcp-server 0.1.6 → 0.1.7

package/README.md

@@ -2,23 +2,32 @@
 
 The standalone MCP (Model Context Protocol) server for `llm-lean-log`. It allows AI agents to search and access your coding task history.
 
-## Installation
+## MCP server with llm-lean-log
 
-### Global Installation (Recommended)
+The pairing looks like:
 
-Install globally using `bun`:
-
-```bash
-bun i -g l-log-mcp-server
+```text
+LLM runtime
+-[use CLI to write log]->
+llm-lean-log (token-cheap, structured CSV)
+->
+mcp-server
+<-[use MCP to read log]->
+LLM runtime
 ```
 
-### From Source
+`llm-lean-log` become MCP memory, which gives you:
 
-```bash
-cd packages/mcp-server
-bun i
-bun run build
-```
+- auditability (what did the model think last week?)
+- debugging (why did it choose X?)
+- analytics (token burn, drift, behavior change)
+- training data for fine-tuning or evals
+
+## How to use?
+
+1. Install globally: `bun i -g l-log-mcp-server`.
+2. Add the configuration to your AI client's config file.
+3. Restart your AI client to pick up the new configuration.
 
 ## Quick Start Configuration
 
@@ -46,6 +55,8 @@ Add this to your `~/.opencode.json`:
 }
 ```
 
+Read more at: [docs/config-for-opencode.md](docs/config-for-opencode.md)
+
 ### Claude Desktop / Claude Code Configuration
 
 Add this to your `claude_config.json` (Desktop) or `.claude/settings.json` (Code):
@@ -63,21 +74,46 @@ Add this to your `claude_config.json` (Desktop) or `.claude/settings.json` (Code
 }
 ```
 
-## Features
+## Features / usesage
 
 ### Resources
 
-- `memory://recent`: View the last 50 log entries.
-- `memory://stats`: View statistics about your logs.
+- `memory://recent`: View the last 50 log entries from the project history.
+- `memory://stats`: View statistics about your logs (total entries, last entry date, unique tags).
+- `memory://last`: View the very last log entry from the project history.
+
+Example User Prompts:
+
+- "Show me the last 50 log entries to see what I've been working on recently"
+- "What are my project statistics? How many entries do I have and what tags have I used?"
+- "What was the very last thing I worked on?"
 
 ### Tools
 
-- `search_logs(query)`: Search for specific topics or errors in your history.
-- `get_task_history(taskName)`: Get all logs related to a specific task.
+- `search_logs(query)`: Search the log history for past problems, solutions, or topics.
+- `get_task_history(taskName)`: Get all log entries related to a specific task name.
+
+Example User Prompts:
+
+- "Search my logs for 'database migration' using llm-memory MCP to see how I handled similar issues before"
+- "Find all entries related to 'authentication system' using llm-memory MCP to understand the development history"
+- "Look up any past 'build errors' using llm-memory MCP to see common solutions"
+- "Look up how I solved 'TypeScript compilation errors' using llm-memory MCP in the past"
 
 ### Prompts
 
-- `summarize_recent_work`: A prompt template to summarize recent activities.
+- `up`: A prompt for daily standup meetings - "What did I do last time and what's next?"
+- `recent_work`: A prompt template to summarize recent activities based on logs.
+- `learned`: Review past mistakes and lessons learned to avoid repeating them.
+
+Example User Prompts:
+
+- "up from llm-memory mcp"
+- "recent_work from llm-memory"
+- "learned from llm-memory"
+- "Help me with my daily standup - what did I do last time and what's next?"
+- "Summarize what I've been working on recently"
+- "Based on my past mistakes, what should I be careful about in this project?"
 
 ### Postinstall
 
@@ -116,6 +152,14 @@ You can also get this config anytime by running: l-log-mcp-server --config
 l-log-mcp-server --help
 ```
 
+### Install from source
+
+```bash
+cd packages/mcp-server
+bun i
+bun run build
+```
+
 ---
 
 For more details about the core logic, see [mcp/README.md](../mcp/README.md).

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AA6CA;;;;;GAKG;AACH,wBAAsB,GAAG,CACxB,IAAI,GAAE,MAAM,EAA0B,EACtC,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAe,iBAsErD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AA8CA;;;;;GAKG;AACH,wBAAsB,GAAG,CACxB,IAAI,GAAE,MAAM,EAA0B,EACtC,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAe,iBAsErD"}

package/dist/index.js

@@ -1,11 +1,13 @@
 #!/usr/bin/env node
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/index.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 // ../mcp/dist/index.js
-import { createRequire } from "node:module";
+import { createRequire as createRequire2 } from "node:module";
 import { readFile } from "node:fs/promises";
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
@@ -13474,7 +13476,7 @@ var __toESM = (mod, isNodeMode, target) => {
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
+var __require2 = /* @__PURE__ */ createRequire2(import.meta.url);
 var require_core = __commonJS((exports, module) => {
   function deepFreeze(obj) {
     if (obj instanceof Map) {
@@ -53651,8 +53653,8 @@ var require_has_flag = __commonJS((exports, module) => {
   };
 });
 var require_supports_color = __commonJS((exports, module) => {
-  var os = __require("os");
-  var tty = __require("tty");
+  var os = __require2("os");
+  var tty = __require2("tty");
   var hasFlag = require_has_flag();
   var { env } = process;
   var forceColor;
@@ -54523,6 +54525,11 @@ ${text}`
 // src/index.ts
 import { existsSync } from "node:fs";
 import path from "node:path";
+
+// src/utils/const.ts
+var MCP_SERVER_VERSION = "0.1.6";
+
+// src/index.ts
 function printConfig() {
   const config2 = {
     mcp: {
@@ -54563,7 +54570,7 @@ async function run(args = process.argv.slice(2), env = process.env) {
     return;
   }
   if (args.includes("--version") || args.includes("-v") || args.includes("-V")) {
-    console.log("0.1.6");
+    console.log(MCP_SERVER_VERSION);
     return;
   }
   if (args.includes("--help") || args.includes("-h")) {
@@ -54589,7 +54596,7 @@ Options:
   }
   const server = new McpServer({
     name: "l-log-mcp-server",
-    version: "0.1.6"
+    version: MCP_SERVER_VERSION
   });
   const refresh = registerMemoryMcpHandlers(server, LOG_PATH);
   await refresh();
@@ -54597,10 +54604,12 @@ Options:
   await server.connect(transport);
   console.error("MCP Server is running on stdio");
 }
-run().catch((error48) => {
-  console.error("Fatal error in MCP server:", error48);
-  process.exit(1);
-});
+if (__require.main == __require.module) {
+  run().catch((error48) => {
+    console.error("Fatal error in MCP server:", error48);
+    process.exit(1);
+  });
+}
 export {
   run
 };

package/dist/utils/const.d.ts

@@ -0,0 +1,2 @@
+export declare const MCP_SERVER_VERSION = "0.1.6";
+//# sourceMappingURL=const.d.ts.map

package/dist/utils/const.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"const.d.ts","sourceRoot":"","sources":["../../src/utils/const.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,UAAU,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "l-log-mcp-server",
-	"version": "0.1.6",
+	"version": "0.1.7",
 	"type": "module",
 	"main": "dist/index.js",
 	"module": "dist/index.js",
@@ -34,7 +34,7 @@
 	},
 	"devDependencies": {
 		"@types/bun": "latest",
-		"l-log-mcp": "0.1.0",
+		"l-log-mcp": "0.1.2",
 		"typescript": "^5.9.3"
 	}
 }

package/scripts/release.zig

@@ -0,0 +1,130 @@
+// script to release a new version of the package
+// run `zig run scripts/release.zig`
+// Plus 0.0.1 to the version number in package.json
+// Commit and tag the new version
+// Push the new version to GitHub
+// Publish the new version to npm
+
+const std = @import("std");
+const json = std.json;
+const process = std.process;
+
+/// Parse version string and increment patch version
+fn incrementVersion(version: []const u8, allocator: std.mem.Allocator) ![]const u8 {
+    var iter = std.mem.splitScalar(u8, version, '.');
+    const major = try std.fmt.parseInt(u32, iter.next().?, 10);
+    const minor = try std.fmt.parseInt(u32, iter.next().?, 10);
+    var patch = try std.fmt.parseInt(u32, iter.next().?, 10);
+
+    patch += 1;
+
+    return std.fmt.allocPrint(allocator, "{}.{}.{}", .{ major, minor, patch });
+}
+
+/// Execute a command and return output
+fn execCommand(allocator: std.mem.Allocator, args: []const []const u8) ![]const u8 {
+    const result = try process.Child.run(.{
+        .allocator = allocator,
+        .argv = args,
+        // 1MB = 1024 * 1024
+        .max_output_bytes = 1048576,
+    });
+
+    defer allocator.free(result.stdout);
+    defer allocator.free(result.stderr);
+
+    if (result.term.Exited != 0) {
+        std.log.err("Command failed: {s}\nStderr: {s}", .{ args[0], result.stderr });
+        return error.CommandFailed;
+    }
+
+    return allocator.dupe(u8, std.mem.trim(u8, result.stdout, "\n"));
+}
+
+/// Read package.json and update version
+fn updatePackageVersion(allocator: std.mem.Allocator) ![]const u8 {
+    const file = std.fs.cwd().openFile("package.json", .{}) catch |err| switch (err) {
+        error.FileNotFound => {
+            std.log.err("package.json not found", .{});
+            return error.FileNotFound;
+        },
+        else => return err,
+    };
+    defer file.close();
+
+    const contents = try file.readToEndAlloc(allocator, 1024 * 1024);
+    defer allocator.free(contents);
+
+    var parsed = try json.parseFromSlice(json.Value, allocator, contents, .{});
+    defer parsed.deinit();
+
+    var root = parsed.value.object;
+    const current_version = root.get("version").?.string;
+    const new_version = try incrementVersion(current_version, allocator);
+
+    // Update version in parsed JSON
+    root.put("version", .{ .string = new_version }) catch unreachable;
+
+    // Write back to file using simple string replacement
+    var new_contents = allocator.alloc(u8, contents.len + 10) catch unreachable;
+    defer allocator.free(new_contents);
+
+    // Find and replace version in the JSON string
+    const version_pattern = "\"version\": \"";
+    const version_start = std.mem.indexOf(u8, contents, version_pattern).? + version_pattern.len;
+    const version_end = std.mem.indexOf(u8, contents[version_start..], "\"").? + version_start;
+
+    // Copy before version
+    std.mem.copyForwards(u8, new_contents[0..version_start], contents[0..version_start]);
+    // Copy new version
+    std.mem.copyForwards(u8, new_contents[version_start .. version_start + new_version.len], new_version);
+    // Copy after version
+    std.mem.copyForwards(u8, new_contents[version_start + new_version.len ..], contents[version_end..]);
+
+    const actual_len = version_start + new_version.len + (contents.len - version_end);
+    try std.fs.cwd().writeFile(.{ .sub_path = "package.json", .data = new_contents[0..actual_len] });
+
+    std.log.info("Updated version from {s} to {s}", .{ current_version, new_version });
+    return new_version;
+}
+
+pub fn main() !void {
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    defer _ = gpa.deinit();
+    const allocator = gpa.allocator();
+
+    std.log.info("Starting release process...", .{});
+
+    // Update version in package.json
+    const new_version = try updatePackageVersion(allocator);
+    defer allocator.free(new_version);
+
+    // Build the package
+    std.log.info("Building package...", .{});
+    _ = try execCommand(allocator, &[_][]const u8{ "bun", "run", "build" });
+
+    // Run tests
+    std.log.info("Running tests...", .{});
+    _ = try execCommand(allocator, &[_][]const u8{ "bun", "test" });
+
+    // Commit changes
+    std.log.info("Committing changes...", .{});
+    _ = try execCommand(allocator, &[_][]const u8{ "git", "add", "package.json" });
+    const commit_message = try std.fmt.allocPrint(allocator, "chore: release v{s}", .{new_version});
+    defer allocator.free(commit_message);
+    _ = try execCommand(allocator, &[_][]const u8{ "git", "commit", "-m", commit_message });
+
+    // Create and push tag
+    std.log.info("Creating and pushing tag...", .{});
+    const tag_name = try std.fmt.allocPrint(allocator, "v{s}", .{new_version});
+    defer allocator.free(tag_name);
+    _ = try execCommand(allocator, &[_][]const u8{ "git", "tag", tag_name });
+    _ = try execCommand(allocator, &[_][]const u8{ "git", "push", "origin", "main" });
+    _ = try execCommand(allocator, &[_][]const u8{ "git", "push", "origin", tag_name });
+
+    // TODO: Publish to npm
+    // std.log.info("Publishing to npm...", .{});
+    // try execCommand(allocator, &[_][]const u8{ "npm", "publish" });
+
+    std.log.info("Release v{s} completed successfully!", .{new_version});
+}