laconic-skill 0.1.0 → 0.1.1

package/MCP.md

@@ -0,0 +1,47 @@
+# laconic-skill MCP
+
+Use `laconic-skill` from MCP-compatible agents.
+
+## Claude Desktop
+
+```json
+{
+  "mcpServers": {
+    "laconic-skill": {
+      "command": "npx",
+      "args": ["-y", "laconic-skill", "laconic-skill-mcp"]
+    }
+  }
+}
+```
+
+## Tools
+
+### laconic_check
+
+Input:
+
+```json
+{
+  "text": "Short direct answer.",
+  "receipt": true
+}
+```
+
+Output:
+
+- check result
+- metrics
+- optional tamper-evident CLI receipt
+
+## Not Shipped In MCP v0
+
+`laconic_rewrite`, `laconic_pipeline`, and `laconic_memory_search` are intentionally not exposed yet. This npm package currently ships real check/receipt behavior only.
+
+## Smoke Test
+
+```bash
+npx laconic-skill-mcp smoke
+```
+
+The smoke test starts the MCP server over stdio, lists tools, calls `laconic_check`, and prints the returned check result JSON.

package/bin/laconic-skill-mcp.mjs

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+
+import { fileURLToPath } from "node:url";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { VERSION, checkText } from "../lib/core.mjs";
+
+function createServer() {
+  const server = new McpServer({
+    name: "laconic-skill",
+    version: VERSION,
+  });
+
+  server.registerTool(
+    "laconic_check",
+    {
+      title: "Laconic Check",
+      description: "Check answer text for Laconic output rules and optionally return a tamper-evident receipt.",
+      inputSchema: {
+        text: z.string().describe("Answer text to check."),
+        receipt: z.boolean().optional().describe("Include a tamper-evident CLI receipt."),
+      },
+    },
+    async ({ text, receipt = false }) => {
+      const result = checkText({ text, file: "mcp-input", receipt });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2),
+          },
+        ],
+        structuredContent: result,
+      };
+    },
+  );
+
+  return server;
+}
+
+async function runServer() {
+  const server = createServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+async function runSmoke() {
+  const transport = new StdioClientTransport({
+    command: process.execPath,
+    args: [fileURLToPath(import.meta.url)],
+    stderr: "pipe",
+  });
+  const client = new Client({
+    name: "laconic-skill-smoke",
+    version: VERSION,
+  });
+
+  await client.connect(transport);
+  try {
+    const tools = await client.listTools();
+    const checkResult = await client.callTool({
+      name: "laconic_check",
+      arguments: {
+        text: "Short direct answer.",
+        receipt: true,
+      },
+    });
+
+    console.log(
+      JSON.stringify(
+        {
+          ok: true,
+          tools: tools.tools.map((tool) => tool.name),
+          laconic_check: JSON.parse(checkResult.content[0].text),
+        },
+        null,
+        2,
+      ),
+    );
+  } finally {
+    await client.close();
+  }
+}
+
+const command = process.argv[2];
+if (command === "smoke") {
+  runSmoke().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  });
+} else {
+  runServer().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  });
+}

package/bin/laconic-skill.mjs

@@ -1,19 +1,7 @@
 #!/usr/bin/env node
 
-import { createHash } from "node:crypto";
 import { readFile } from "node:fs/promises";
-import { basename } from "node:path";
-
-const VERSION = "0.1.0";
-const FILLER_PREFIXES = [
-  "sure",
-  "certainly",
-  "of course",
-  "absolutely",
-  "as an ai",
-  "i'd be happy to",
-  "i can help",
-];
+import { VERSION, checkText } from "../lib/core.mjs";
 
 function printHelp() {
   console.log(`laconic-skill ${VERSION}
@@ -35,67 +23,6 @@ Options:
 `);
 }
 
-function sha256(text) {
-  return createHash("sha256").update(text).digest("hex");
-}
-
-function stableJson(value) {
-  if (Array.isArray(value)) {
-    return `[${value.map(stableJson).join(",")}]`;
-  }
-  if (value && typeof value === "object") {
-    return `{${Object.keys(value)
-      .sort()
-      .map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`)
-      .join(",")}}`;
-  }
-  return JSON.stringify(value);
-}
-
-function countWords(text) {
-  const matches = text.trim().match(/\S+/g);
-  return matches ? matches.length : 0;
-}
-
-function readingTimeSeconds(text) {
-  return Math.max(1, Math.ceil((countWords(text) / 225) * 60));
-}
-
-function runChecks(answer) {
-  const trimmed = answer.trim();
-  const normalized = trimmed.toLowerCase();
-  const hasMarkdownBold = /\*\*[^*]+\*\*|__[^_]+__/.test(answer);
-  const direct = normalized.length > 0 && !FILLER_PREFIXES.some((prefix) => normalized.startsWith(prefix));
-  const complete = normalized.length > 0 && !normalized.endsWith("...");
-  const brief = countWords(answer) <= 120;
-
-  return {
-    direct,
-    complete,
-    brief,
-    no_markdown_bold: !hasMarkdownBold,
-  };
-}
-
-function buildReceipt({ file, answer, checks }) {
-  const timestamp = new Date().toISOString();
-  const canonical = {
-    tool: "laconic-skill",
-    version: VERSION,
-    file: basename(file),
-    answer_hash: sha256(answer),
-    answer_length: countWords(answer),
-    reading_time_seconds: readingTimeSeconds(answer),
-    checks,
-    timestamp,
-  };
-
-  return {
-    ...canonical,
-    receipt_hash: sha256(stableJson(canonical)),
-  };
-}
-
 async function readStdin() {
   const chunks = [];
   for await (const chunk of process.stdin) {
@@ -118,32 +45,18 @@ async function checkCommand(args) {
   }
 
   const answer = file === "-" ? await readStdin() : await readFile(file, "utf8");
-  const checks = runChecks(answer);
-  const passed = Object.values(checks).every(Boolean);
-  const result = {
-    ok: passed,
-    file,
-    checks,
-    metrics: {
-      answer_length: countWords(answer),
-      reading_time_seconds: readingTimeSeconds(answer),
-    },
-  };
-
-  if (includeReceipt) {
-    result.receipt = buildReceipt({ file, answer, checks });
-  }
+  const result = checkText({ text: answer, file, receipt: includeReceipt });
 
   if (jsonOnly || includeReceipt) {
     console.log(JSON.stringify(result, null, 2));
   } else {
-    console.log(passed ? "OK" : "FAILED");
-    for (const [name, value] of Object.entries(checks)) {
+    console.log(result.ok ? "OK" : "FAILED");
+    for (const [name, value] of Object.entries(result.checks)) {
       console.log(`${name}: ${value}`);
     }
   }
 
-  process.exitCode = passed ? 0 : 1;
+  process.exitCode = result.ok ? 0 : 1;
 }
 
 async function main() {

package/lib/core.mjs

@@ -0,0 +1,95 @@
+import { createHash } from "node:crypto";
+import { basename } from "node:path";
+
+export const VERSION = "0.1.1";
+
+const FILLER_PREFIXES = [
+  "sure",
+  "certainly",
+  "of course",
+  "absolutely",
+  "as an ai",
+  "i'd be happy to",
+  "i can help",
+];
+
+export function sha256(text) {
+  return createHash("sha256").update(text).digest("hex");
+}
+
+export function stableJson(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map(stableJson).join(",")}]`;
+  }
+  if (value && typeof value === "object") {
+    return `{${Object.keys(value)
+      .sort()
+      .map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`)
+      .join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+
+export function countWords(text) {
+  const matches = text.trim().match(/\S+/g);
+  return matches ? matches.length : 0;
+}
+
+export function readingTimeSeconds(text) {
+  return Math.max(1, Math.ceil((countWords(text) / 225) * 60));
+}
+
+export function runChecks(answer) {
+  const trimmed = answer.trim();
+  const normalized = trimmed.toLowerCase();
+  const hasMarkdownBold = /\*\*[^*]+\*\*|__[^_]+__/.test(answer);
+  const direct = normalized.length > 0 && !FILLER_PREFIXES.some((prefix) => normalized.startsWith(prefix));
+  const complete = normalized.length > 0 && !normalized.endsWith("...");
+  const brief = countWords(answer) <= 120;
+
+  return {
+    direct,
+    complete,
+    brief,
+    no_markdown_bold: !hasMarkdownBold,
+  };
+}
+
+export function buildReceipt({ file, answer, checks }) {
+  const timestamp = new Date().toISOString();
+  const canonical = {
+    tool: "laconic-skill",
+    version: VERSION,
+    file: file === "-" ? "-" : basename(file),
+    answer_hash: sha256(answer),
+    answer_length: countWords(answer),
+    reading_time_seconds: readingTimeSeconds(answer),
+    checks,
+    timestamp,
+  };
+
+  return {
+    ...canonical,
+    receipt_hash: sha256(stableJson(canonical)),
+  };
+}
+
+export function checkText({ text, file = "text", receipt = false }) {
+  const checks = runChecks(text);
+  const passed = Object.values(checks).every(Boolean);
+  const result = {
+    ok: passed,
+    file,
+    checks,
+    metrics: {
+      answer_length: countWords(text),
+      reading_time_seconds: readingTimeSeconds(text),
+    },
+  };
+
+  if (receipt) {
+    result.receipt = buildReceipt({ file, answer: text, checks });
+  }
+
+  return result;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "laconic-skill",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "A command-line checker for Laconic answers and tamper-evident receipts.",
   "type": "module",
   "scripts": {
@@ -8,10 +8,13 @@
   },
   "bin": {
     "laconic-skill": "bin/laconic-skill.mjs",
-    "laconic": "bin/laconic-skill.mjs"
+    "laconic": "bin/laconic-skill.mjs",
+    "laconic-skill-mcp": "bin/laconic-skill-mcp.mjs"
   },
   "files": [
     "bin",
+    "lib",
+    "MCP.md",
     "README.md"
   ],
   "keywords": [
@@ -32,5 +35,8 @@
   "license": "MIT",
   "engines": {
     "node": ">=18"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0"
   }
 }