@minhpnq1807/contextos 0.1.0

package/plugins/ctx/lib/stats.js

@@ -0,0 +1,127 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import { safeReadText } from "./fs-utils.js";
+
+function readJsonLines(filePath) {
+  return safeReadText(filePath)
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean);
+}
+
+function readJsonIfExists(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function average(values) {
+  const nums = values.filter((value) => typeof value === "number" && Number.isFinite(value));
+  if (!nums.length) return null;
+  return Math.round(nums.reduce((sum, value) => sum + value, 0) / nums.length);
+}
+
+function percent(numerator, denominator) {
+  if (!denominator) return 0;
+  return Math.round((numerator / denominator) * 100);
+}
+
+export function loadStats(dataDir) {
+  const prompts = readJsonLines(path.join(dataDir, "prompt-history.jsonl"));
+  const reportsFromHistory = readJsonLines(path.join(dataDir, "report-history.jsonl"));
+  const lastPrompt = readJsonIfExists(path.join(dataDir, "last-prompt-context.json"));
+  const lastReport = readJsonIfExists(path.join(dataDir, "last-report.json"));
+  const events = readJsonLines(path.join(dataDir, "debug.log"));
+  const reports = reportsFromHistory.length ? reportsFromHistory : [lastReport].filter(Boolean);
+
+  const byEvent = new Map();
+  for (const item of events) {
+    byEvent.set(item.event, (byEvent.get(item.event) || 0) + 1);
+  }
+
+  const promptCount = prompts.length || (lastPrompt ? 1 : 0);
+  const injectedCount = prompts.filter((item) => item.injected).length + (!prompts.length && lastPrompt?.injected ? 1 : 0);
+  const analyzedPrompts = prompts.length ? prompts : [lastPrompt].filter(Boolean);
+  const knownEfficiency = reports.map((report) => report.efficiencyScore).filter((score) => score != null);
+  const followed = reports.reduce((sum, report) => sum + (report.followed?.length || 0), 0);
+  const ignored = reports.reduce((sum, report) => sum + (report.ignored?.length || 0), 0);
+  const unknown = reports.reduce((sum, report) => sum + (report.unknown?.length || 0), 0);
+
+  return {
+    dataDir,
+    events: Object.fromEntries([...byEvent.entries()].sort()),
+    promptCount,
+    reportCount: reports.length,
+    injectedCount,
+    quietCount: Math.max(0, promptCount - injectedCount),
+    injectionRate: percent(injectedCount, promptCount),
+    averagePromptMs: average(analyzedPrompts.map((item) => item.elapsedMs)),
+    averageEfficiency: average(knownEfficiency),
+    followed,
+    ignored,
+    unknown,
+    lastPrompt: analyzedPrompts.at(-1) || null,
+    lastReport: reports.at(-1) || null
+  };
+}
+
+export function formatStats(stats) {
+  const lines = [];
+  lines.push("ContextOS stats");
+  lines.push(`Data dir: ${stats.dataDir}`);
+  lines.push(`Prompts analyzed: ${stats.promptCount}`);
+  lines.push(`Reports generated: ${stats.reportCount}`);
+  lines.push(`Prompt mode: ${stats.injectedCount} injected, ${stats.quietCount} quiet (${stats.injectionRate}% injected)`);
+  lines.push(`Average prompt analysis: ${stats.averagePromptMs == null ? "unknown" : `${stats.averagePromptMs}ms`}`);
+  lines.push(`Average efficiency: ${formatAverageEfficiency(stats)}`);
+  lines.push(`Rule outcomes: ${stats.followed} followed, ${stats.ignored} ignored, ${stats.unknown} unknown`);
+
+  const eventSummary = Object.entries(stats.events)
+    .map(([event, count]) => `${event}:${count}`)
+    .join(", ");
+  lines.push(`Hook events: ${eventSummary || "none"}`);
+
+  if (stats.lastPrompt) {
+    lines.push(`Last prompt: ${truncateLine(stats.lastPrompt.prompt || "", 100) || "(empty)"}`);
+    lines.push(`Last scheduled rules: ${scheduledRuleCount(stats.lastPrompt)}`);
+    const files = (stats.lastPrompt.relevantFiles || []).map((file) => file.path).join(", ");
+    if (files) lines.push(`Last suggested files: ${files}`);
+  }
+
+  if (stats.lastReport) {
+    lines.push(`Last report efficiency: ${stats.lastReport.efficiencyScore == null ? "unknown" : `${stats.lastReport.efficiencyScore}%`}`);
+    lines.push(`Last report measured rules: ${stats.lastReport.measuredRuleCount ?? ((stats.lastReport.followed?.length || 0) + (stats.lastReport.ignored?.length || 0))}`);
+    lines.push(`Last report unknown rules: ${stats.lastReport.unknownRuleCount ?? (stats.lastReport.unknown?.length || 0)}`);
+    const changed = stats.lastReport.changedFiles?.join(", ");
+    if (changed) lines.push(`Last changed files: ${changed}`);
+  }
+
+  return lines.join("\n");
+}
+
+function formatAverageEfficiency(stats) {
+  if (stats.averageEfficiency != null) return `${stats.averageEfficiency}%`;
+  if (!stats.reportCount) return "unknown (no Stop reports yet)";
+  if (stats.followed + stats.ignored === 0) return "unknown (no measurable followed/ignored rule evidence yet)";
+  return "unknown";
+}
+
+function scheduledRuleCount(prompt) {
+  return (prompt.scheduled?.highRules?.length || 0) + (prompt.scheduled?.midRules?.length || 0);
+}
+
+function truncateLine(value, max) {
+  const normalized = String(value).replace(/\s+/g, " ").trim();
+  return normalized.length > max ? `${normalized.slice(0, max - 3)}...` : normalized;
+}

package/plugins/ctx/lib/stop-hook.js

@@ -0,0 +1,32 @@
+import fs from "node:fs";
+
+import { appendJsonLine, readJsonFile, writeJsonFile } from "./fs-utils.js";
+import { readGitSnapshot, checkCompliance } from "./measure.js";
+import { buildReport, formatReport } from "./reporter.js";
+
+export function handleStopPayload(payload, { contextPath, reportPath, historyPath } = {}) {
+  const cwd = payload.cwd || payload.working_directory || process.cwd();
+  const promptContext = contextPath && fs.existsSync(contextPath) ? readJsonFile(contextPath) : null;
+  const scheduledRules = [
+    ...(promptContext?.scheduled?.highRules || []),
+    ...(promptContext?.scheduled?.midRules || [])
+  ];
+  const gitSnapshot = readGitSnapshot({ cwd });
+  const compliance = checkCompliance({ rules: scheduledRules, addedLines: gitSnapshot.addedLines });
+  const report = buildReport({
+    cwd,
+    prompt: promptContext?.prompt || "",
+    relevantFiles: promptContext?.relevantFiles || [],
+    scheduled: promptContext?.scheduled || null,
+    gitSnapshot,
+    compliance
+  });
+
+  if (reportPath) writeJsonFile(reportPath, report);
+  if (historyPath) appendJsonLine(historyPath, report);
+
+  return {
+    continue: true,
+    systemMessage: formatReport(report)
+  };
+}

package/plugins/ctx/mcp/contextos-server.js

@@ -0,0 +1,50 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+
+import { scoreContext } from "../lib/score-context.js";
+
+export function createContextOSMcpServer({ dataDir }) {
+  const server = new McpServer({
+    name: "ctx-mcp",
+    version: "0.1.0"
+  });
+
+  server.registerTool("ctx_score_context", {
+    title: "Score ContextOS prompt context",
+    description: "Scores AGENTS.md rules and suggests files for a Codex prompt.",
+    inputSchema: {
+      cwd: z.string().optional(),
+      prompt: z.string(),
+      openFiles: z.array(z.string()).optional(),
+      maxFiles: z.number().int().positive().max(20).optional()
+    },
+    outputSchema: {
+      scoredRules: z.array(z.any()),
+      suggestedFiles: z.array(z.any()),
+      telemetry: z.record(z.string(), z.any())
+    }
+  }, async (args) => {
+    const result = await scoreContext({
+      cwd: args.cwd || process.cwd(),
+      prompt: args.prompt || "",
+      openFiles: args.openFiles || [],
+      dataDir,
+      maxFiles: args.maxFiles || 5
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(result.telemetry)
+        }
+      ],
+      structuredContent: {
+        scoredRules: result.scoredRules,
+        suggestedFiles: result.suggestedFiles,
+        telemetry: result.telemetry
+      }
+    };
+  });
+
+  return server;
+}

package/plugins/ctx/mcp/server.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import net from "node:net";
+import os from "node:os";
+import path from "node:path";
+
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+import { modelCacheDir, warmRuleEmbeddings } from "../lib/embedding-scorer.js";
+import { scoreContext } from "../lib/score-context.js";
+import { ctxMcpSocketPath } from "../lib/ctx-mcp-client.js";
+import { createContextOSMcpServer } from "./contextos-server.js";
+
+const dataDir = process.env.PLUGIN_DATA || path.join(process.env.CODEX_HOME || path.join(os.homedir(), ".codex"), "contextos");
+const socketPath = ctxMcpSocketPath(dataDir);
+
+fs.mkdirSync(dataDir, { recursive: true });
+await ensureModelReady();
+if (process.env.CONTEXTOS_DISABLE_BRIDGE !== "1") startBridge();
+const keepAlive = setInterval(() => {}, 2 ** 31 - 1);
+
+const server = createContextOSMcpServer({ dataDir });
+console.error("ctx-mcp ready");
+await server.connect(new StdioServerTransport());
+
+async function ensureModelReady() {
+  const modelDir = modelCacheDir(dataDir);
+  if (!fs.existsSync(modelDir)) {
+    throw new Error(`ContextOS model cache missing: ${modelDir}. Run ctx install first.`);
+  }
+  await warmRuleEmbeddings({
+    task: "contextos mcp model ready",
+    rules: [{ content: "ContextOS semantic scorer is ready." }],
+    dataDir,
+    allowRemote: false
+  });
+}
+
+function startBridge() {
+  fs.rmSync(socketPath, { force: true });
+  const bridge = net.createServer((socket) => {
+    let raw = "";
+    socket.on("data", (chunk) => {
+      raw += chunk.toString("utf8");
+      if (raw.includes("\n")) handleBridgeRequest(socket, raw);
+    });
+  });
+  bridge.on("error", (error) => {
+    console.error(`ctx-mcp bridge disabled: ${error?.message || String(error)}`);
+  });
+  bridge.listen(socketPath);
+  process.on("exit", () => {
+    clearInterval(keepAlive);
+    fs.rmSync(socketPath, { force: true });
+  });
+  process.on("SIGTERM", () => {
+    clearInterval(keepAlive);
+    fs.rmSync(socketPath, { force: true });
+    process.exit(0);
+  });
+}
+
+async function handleBridgeRequest(socket, raw) {
+  socket.pause();
+  try {
+    const payload = JSON.parse(raw.trim() || "{}");
+    const result = await scoreContext({
+      cwd: payload.cwd || process.cwd(),
+      prompt: payload.prompt || "",
+      openFiles: payload.openFiles || [],
+      dataDir,
+      maxFiles: payload.maxFiles || 5
+    });
+    socket.end(JSON.stringify(result));
+  } catch (error) {
+    socket.end(JSON.stringify({
+      error: error?.message || String(error),
+      scoredRules: [],
+      suggestedFiles: [],
+      telemetry: { elapsedMs: 0, modelStatus: "error" }
+    }));
+  }
+}