@minhpnq1807/contextos 0.1.0

package/plugins/ctx/lib/file-embedding-retriever.js

@@ -0,0 +1,116 @@
+import fs from "node:fs";
+import path from "node:path";
+import { enhanceRuleScoresWithEmbeddings, warmRuleEmbeddings } from "./embedding-scorer.js";
+
+const SOURCE_EXTENSIONS = new Set([
+  ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", ".sql", ".md", ".json"
+]);
+const IGNORE_DIRS = new Set([
+  ".git", ".next", ".turbo", "coverage", "dist", "build", "node_modules", "vendor"
+]);
+const DEFAULT_TIMEOUT_MS = 80;
+const DEFAULT_MAX_FILES = 1200;
+
+export async function findEmbeddingRelevantFiles({
+  cwd = process.cwd(),
+  task = "",
+  dataDir,
+  limit = 10,
+  timeoutMs = Number(process.env.CONTEXTOS_FILE_EMBEDDING_TIMEOUT_MS || DEFAULT_TIMEOUT_MS),
+  maxFiles = Number(process.env.CONTEXTOS_FILE_EMBEDDING_MAX_FILES || DEFAULT_MAX_FILES),
+  embeddingOptions = {}
+} = {}) {
+  if (process.env.CONTEXTOS_FILE_EMBEDDINGS === "0") return [];
+  if (!dataDir) return [];
+  if (!String(task || "").trim()) return [];
+
+  const files = listSourceFiles(cwd, { maxFiles });
+  if (!files.length) return [];
+
+  const fileRules = files.map((filePath, index) => ({
+    id: `f${index + 1}`,
+    content: fileSearchText(filePath),
+    path: filePath,
+    score: 0,
+    reasons: [],
+    originalOrder: index
+  }));
+
+  const result = await enhanceRuleScoresWithEmbeddings(fileRules, task, {
+    dataDir,
+    sources: [path.join(cwd, "AGENTS.md")],
+    timeoutMs,
+    allowRemote: false,
+    ...embeddingOptions
+  });
+
+  if (result.status !== "enabled") return [];
+
+  return result.rules
+    .filter((rule) => Number(rule.embeddingScore || 0) >= 0.45)
+    .sort((a, b) => Number(b.embeddingScore || 0) - Number(a.embeddingScore || 0) || a.path.localeCompare(b.path))
+    .slice(0, limit)
+    .map((rule) => ({
+      path: rule.path,
+      score: Math.round(Number(rule.embeddingScore || 0) * 10),
+      source: "embedding",
+      reasons: [`file-embedding:${Number(rule.embeddingScore || 0).toFixed(2)}`]
+    }));
+}
+
+export async function warmFileEmbeddings({
+  cwd = process.cwd(),
+  dataDir,
+  allowRemote = true,
+  maxFiles = Number(process.env.CONTEXTOS_FILE_EMBEDDING_MAX_FILES || DEFAULT_MAX_FILES)
+} = {}) {
+  if (!dataDir) return { count: 0, cachePath: null };
+  const files = listSourceFiles(cwd, { maxFiles });
+  const rules = files.map((filePath) => ({ content: fileSearchText(filePath) }));
+  return warmRuleEmbeddings({
+    rules,
+    task: "project file semantic retrieval",
+    dataDir,
+    sources: [path.join(cwd, "AGENTS.md")],
+    allowRemote
+  });
+}
+
+function listSourceFiles(cwd, { maxFiles }) {
+  const files = [];
+  walkFiles(cwd, (filePath) => {
+    if (files.length >= maxFiles) return;
+    files.push(path.relative(cwd, filePath));
+  });
+  return files;
+}
+
+function walkFiles(directory, onFile, depth = 0) {
+  if (depth > 7) return;
+  let entries = [];
+  try {
+    entries = fs.readdirSync(directory, { withFileTypes: true });
+  } catch {
+    return;
+  }
+
+  for (const entry of entries) {
+    if (entry.name.startsWith(".") && entry.name !== ".github") continue;
+    if (IGNORE_DIRS.has(entry.name)) continue;
+
+    const fullPath = path.join(directory, entry.name);
+    if (entry.isDirectory()) {
+      walkFiles(fullPath, onFile, depth + 1);
+    } else if (entry.isFile() && SOURCE_EXTENSIONS.has(path.extname(entry.name))) {
+      onFile(fullPath);
+    }
+  }
+}
+
+function fileSearchText(filePath) {
+  const normalized = String(filePath || "")
+    .replace(/\.[^.]+$/, "")
+    .replace(/[._/-]+/g, " ")
+    .replace(/([a-z])([A-Z])/g, "$1 $2");
+  return `${filePath} ${normalized}`;
+}

package/plugins/ctx/lib/fs-utils.js

@@ -0,0 +1,28 @@
+import fs from "node:fs";
+import path from "node:path";
+
+export function ensureDir(filePath) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+}
+
+export function writeJsonFile(filePath, value) {
+  ensureDir(filePath);
+  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+
+export function appendJsonLine(filePath, value) {
+  ensureDir(filePath);
+  fs.appendFileSync(filePath, `${JSON.stringify(value)}\n`, "utf8");
+}
+
+export function readJsonFile(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, "utf8"));
+}
+
+export function safeReadText(filePath) {
+  try {
+    return fs.readFileSync(filePath, "utf8");
+  } catch {
+    return "";
+  }
+}

package/plugins/ctx/lib/global-hooks.js

@@ -0,0 +1,110 @@
+import fs from "node:fs";
+import path from "node:path";
+
+const CONTEXTOS_COMMAND_MARKER = "/contextos/plugins/ctx/bin/on-";
+const QUIET_CODE_REVIEW_GRAPH_STATUS_COMMAND =
+  "git rev-parse --git-dir >/dev/null 2>&1 && code-review-graph status >/dev/null 2>&1 || true";
+
+function shellQuote(value) {
+  return `'${String(value).replaceAll("'", "'\\''")}'`;
+}
+
+function readHooksFile(hooksPath) {
+  if (!fs.existsSync(hooksPath)) return { hooks: {} };
+  const raw = fs.readFileSync(hooksPath, "utf8").trim();
+  if (!raw) return { hooks: {} };
+  const parsed = JSON.parse(raw);
+  if (!parsed.hooks || typeof parsed.hooks !== "object") parsed.hooks = {};
+  return parsed;
+}
+
+function isContextOSHookEntry(entry) {
+  return (entry.hooks || []).some((hook) => {
+    return typeof hook.command === "string" && hook.command.includes(CONTEXTOS_COMMAND_MARKER);
+  });
+}
+
+function withoutContextOSEntries(entries = []) {
+  return entries.filter((entry) => !isContextOSHookEntry(entry));
+}
+
+function quietCodeReviewGraphSessionStart(entries = []) {
+  return entries.map((entry) => ({
+    ...entry,
+    hooks: (entry.hooks || []).map((hook) => {
+      if (typeof hook.command === "string" && hook.command.includes("code-review-graph status")) {
+        return {
+          ...hook,
+          command: QUIET_CODE_REVIEW_GRAPH_STATUS_COMMAND
+        };
+      }
+      return hook;
+    })
+  }));
+}
+
+function commandFor(marketplaceRoot, scriptName, { injectPromptContext = true } = {}) {
+  const envPrefix = scriptName === "on-prompt.js" && !injectPromptContext ? "CONTEXTOS_INJECT=0 " : "";
+  return `${envPrefix}node ${shellQuote(path.join(marketplaceRoot, "plugins", "ctx", "bin", scriptName))}`;
+}
+
+function contextOSEntry({ marketplaceRoot, scriptName, matcher, timeout, statusMessage, injectPromptContext = true }) {
+  const entry = {
+    hooks: [
+      {
+        type: "command",
+        command: commandFor(marketplaceRoot, scriptName, { injectPromptContext }),
+        timeout,
+        statusMessage
+      }
+    ]
+  };
+
+  if (matcher) entry.matcher = matcher;
+  return entry;
+}
+
+export function buildGlobalHooksConfig(existingConfig, { marketplaceRoot, injectPromptContext = true }) {
+  const config = existingConfig && typeof existingConfig === "object" ? structuredClone(existingConfig) : {};
+  if (!config.hooks || typeof config.hooks !== "object") config.hooks = {};
+
+  const additions = {
+    SessionStart: contextOSEntry({
+      marketplaceRoot,
+      scriptName: "on-session-start.js",
+      matcher: "startup|resume",
+      timeout: 10,
+      statusMessage: "ContextOS session start"
+    }),
+    UserPromptSubmit: contextOSEntry({
+      marketplaceRoot,
+      scriptName: "on-prompt.js",
+      timeout: 10,
+      statusMessage: "ContextOS scheduling context",
+      injectPromptContext
+    }),
+    Stop: contextOSEntry({
+      marketplaceRoot,
+      scriptName: "on-stop.js",
+      timeout: 10,
+      statusMessage: "ContextOS reporting"
+    })
+  };
+
+  for (const [eventName, entry] of Object.entries(additions)) {
+    config.hooks[eventName] = [...withoutContextOSEntries(config.hooks[eventName]), entry];
+  }
+
+  config.hooks.SessionStart = quietCodeReviewGraphSessionStart(config.hooks.SessionStart);
+
+  return config;
+}
+
+export function installGlobalHooks({ codexHome, marketplaceRoot, injectPromptContext = true }) {
+  const hooksPath = path.join(codexHome, "hooks.json");
+  const existing = readHooksFile(hooksPath);
+  const next = buildGlobalHooksConfig(existing, { marketplaceRoot, injectPromptContext });
+  fs.mkdirSync(path.dirname(hooksPath), { recursive: true });
+  fs.writeFileSync(hooksPath, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+  return hooksPath;
+}

package/plugins/ctx/lib/graph-retriever.js

@@ -0,0 +1,226 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+
+const DEFAULT_TIMEOUT_MS = 80;
+const MAX_GRAPH_QUERIES = 10;
+const DEFAULT_CRG_PYTHON = path.join(
+  os.homedir(),
+  ".local/share/pipx/venvs/code-review-graph/bin/python"
+);
+
+const QUERY_STOP_WORDS = new Set([
+  "a", "an", "and", "are", "before", "cho", "for", "from", "into", "khi", "must",
+  "not", "the", "then", "this", "that", "trong", "use", "using", "with"
+]);
+
+export function hasGraphIndex(cwd = process.cwd()) {
+  return fs.existsSync(path.join(cwd, ".code-review-graph", "graph.db"));
+}
+
+export function findGraphRelevantFiles({
+  cwd = process.cwd(),
+  task = "",
+  rules = [],
+  seedFiles = [],
+  limit = 6,
+  timeoutMs = Number(process.env.CONTEXTOS_GRAPH_TIMEOUT_MS || DEFAULT_TIMEOUT_MS)
+} = {}) {
+  if (process.env.CONTEXTOS_GRAPH_RETRIEVAL === "0") return [];
+  if (!hasGraphIndex(cwd)) return [];
+
+  const python = process.env.CONTEXTOS_CRG_PYTHON || DEFAULT_CRG_PYTHON;
+  if (!fs.existsSync(python)) return [];
+
+  const queries = buildGraphQueries({ task, rules, seedFiles });
+  if (!queries.length) return [];
+
+  const script = `
+import json
+import sys
+
+from code_review_graph.tools.query import semantic_search_nodes
+
+payload = json.loads(sys.stdin.read() or "{}")
+repo_root = payload.get("repoRoot")
+queries = payload.get("queries") or []
+limit = int(payload.get("limit") or 8)
+seen = set()
+results = []
+
+for query in queries:
+    try:
+        response = semantic_search_nodes(
+            query=query,
+            repo_root=repo_root,
+            detail_level="minimal",
+            limit=limit,
+        )
+    except Exception:
+        continue
+
+    for item in response.get("results", []) or []:
+        file_path = item.get("file_path") or item.get("path")
+        if not file_path:
+            continue
+        key = (file_path, query)
+        if key in seen:
+            continue
+        seen.add(key)
+        results.append({
+            "path": file_path,
+            "query": query,
+            "name": item.get("name"),
+            "kind": item.get("kind"),
+            "score": item.get("score"),
+        })
+
+print(json.dumps(results))
+`;
+
+  try {
+    const output = execFileSync(python, ["-c", script], {
+      cwd,
+      input: JSON.stringify({ repoRoot: cwd, queries, limit }),
+      encoding: "utf8",
+      timeout: timeoutMs,
+      env: {
+        ...process.env,
+        MPLCONFIGDIR: process.env.MPLCONFIGDIR || path.join(os.tmpdir(), "contextos-mpl")
+      },
+      stdio: ["pipe", "pipe", "ignore"]
+    });
+    const raw = JSON.parse(output || "[]");
+    return mergeGraphResults({ cwd, results: raw, limit });
+  } catch {
+    return [];
+  }
+}
+
+export function buildGraphQueries({ task = "", rules = [], seedFiles = [], maxQueries = MAX_GRAPH_QUERIES } = {}) {
+  const queries = [];
+  addQuery(queries, task);
+
+  for (const file of seedFiles.slice(0, 5)) {
+    const filePath = file.path || "";
+    const basename = path.basename(filePath).replace(/\.[^.]+$/, "");
+    addQuery(queries, basename);
+  }
+
+  const topRules = seedFiles.length ? [] : [...rules]
+    .filter((rule) => Number(rule.score || 0) >= 0.1)
+    .sort((a, b) => Number(b.score || 0) - Number(a.score || 0))
+    .slice(0, 4);
+
+  for (const rule of topRules) {
+    const content = rule.content || "";
+    for (const identifier of extractIdentifiers(content)) addQuery(queries, identifier);
+
+    const terms = extractTerms(content);
+    for (const phrase of importantPhrases(terms)) addQuery(queries, phrase);
+  }
+
+  return queries.slice(0, maxQueries);
+}
+
+export function mergeRelevantFiles({ graphFiles = [], heuristicFiles = [], limit = 3 } = {}) {
+  const byPath = new Map();
+  for (const file of heuristicFiles) {
+    if (!file?.path) continue;
+    byPath.set(file.path, {
+      ...file,
+      source: file.source || "heuristic",
+      reasons: [...new Set(file.reasons || [])]
+    });
+  }
+
+  for (const file of graphFiles) {
+    if (!file?.path) continue;
+    const existing = byPath.get(file.path);
+    const reasons = [...new Set([...(file.reasons || []), ...(existing?.reasons || [])])];
+    byPath.set(file.path, {
+      ...existing,
+      ...file,
+      source: "graph",
+      score: 100 + Number(file.score || 0) * 10 + Number(existing?.score || 0),
+      reasons
+    });
+  }
+
+  return [...byPath.values()]
+    .sort((a, b) => Number(b.score || 0) - Number(a.score || 0) || a.path.localeCompare(b.path))
+    .slice(0, limit);
+}
+
+function mergeGraphResults({ cwd, results, limit }) {
+  const byPath = new Map();
+  for (const result of Array.isArray(results) ? results : []) {
+    const normalized = normalizeRepoPath(cwd, result.path);
+    if (!normalized) continue;
+
+    const existing = byPath.get(normalized) || {
+      path: normalized,
+      score: 0,
+      source: "graph",
+      reasons: []
+    };
+    existing.score += 1;
+    existing.reasons.push(`graph:${result.query}`);
+    byPath.set(normalized, existing);
+  }
+
+  return [...byPath.values()]
+    .map((file) => ({ ...file, reasons: [...new Set(file.reasons)] }))
+    .sort((a, b) => b.score - a.score || a.path.localeCompare(b.path))
+    .slice(0, limit);
+}
+
+function normalizeRepoPath(cwd, filePath) {
+  const normalized = path.normalize(String(filePath || ""));
+  if (!normalized) return null;
+  if (path.isAbsolute(normalized)) {
+    const relative = path.relative(cwd, normalized);
+    if (relative.startsWith("..") || path.isAbsolute(relative)) return null;
+    return relative;
+  }
+  return normalized.startsWith("..") ? null : normalized;
+}
+
+function addQuery(queries, value) {
+  const query = String(value || "").trim();
+  if (query.length < 3) return;
+  if (queries.some((existing) => existing.toLowerCase() === query.toLowerCase())) return;
+  queries.push(query);
+}
+
+function extractIdentifiers(value) {
+  const identifiers = [];
+  const text = String(value || "");
+  const patterns = [
+    /`([^`]+)`/g,
+    /\b[A-Z][A-Za-z0-9]*(?:[A-Z][A-Za-z0-9]*)+\b/g,
+    /\b[a-z0-9]+(?:[-_.][a-z0-9]+)+\b/gi
+  ];
+  for (const pattern of patterns) {
+    for (const match of text.matchAll(pattern)) identifiers.push(match[1] || match[0]);
+  }
+  return identifiers;
+}
+
+function extractTerms(value) {
+  return String(value || "")
+    .toLowerCase()
+    .normalize("NFD")
+    .replace(/[\u0300-\u036f]/g, "")
+    .split(/[^a-z0-9]+/g)
+    .filter((term) => term.length > 2 && !QUERY_STOP_WORDS.has(term));
+}
+
+function importantPhrases(terms) {
+  const phrases = [];
+  for (let index = 0; index < terms.length - 1; index += 1) {
+    phrases.push(`${terms[index]} ${terms[index + 1]}`);
+  }
+  return phrases.slice(0, 4);
+}

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

@@ -0,0 +1,65 @@
+import fs from "node:fs";
+import path from "node:path";
+import { writeJsonFile } from "./fs-utils.js";
+
+function codexHome() {
+  return process.env.CODEX_HOME || path.join(process.env.HOME || process.cwd(), ".codex");
+}
+
+export async function readStdinJson() {
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  const raw = Buffer.concat(chunks).toString("utf8").trim();
+  if (!raw) return {};
+  return JSON.parse(raw);
+}
+
+export function writeJson(value) {
+  process.stdout.write(`${JSON.stringify(value)}\n`);
+}
+
+export function pluginDataDir(fileName = "") {
+  const root = process.env.PLUGIN_DATA || path.join(codexHome(), "contextos");
+  try {
+    fs.mkdirSync(root, { recursive: true });
+  } catch {
+    return path.join(process.cwd(), ".contextos", fileName);
+  }
+  return path.join(root, fileName);
+}
+
+export function logDebug(event, payload) {
+  const line = JSON.stringify({ at: new Date().toISOString(), event, payload });
+  try {
+    fs.appendFileSync(pluginDataDir("debug.log"), `${line}\n`, "utf8");
+  } catch {
+    // Logging must never break Codex hooks.
+  }
+}
+
+export function logError(event, error) {
+  const line = JSON.stringify({
+    at: new Date().toISOString(),
+    event,
+    message: error?.message || String(error),
+    stack: error?.stack
+  });
+  try {
+    fs.appendFileSync(pluginDataDir("error.log"), `${line}\n`, "utf8");
+  } catch {
+    // failOpen depends on this staying best-effort.
+  }
+}
+
+export function failOpen(event, error, fallback) {
+  logError(event, error);
+  writeJson(fallback);
+}
+
+export function persistRuntime(name, value) {
+  try {
+    writeJsonFile(pluginDataDir(name), value);
+  } catch {
+    // Runtime persistence is diagnostic; hook output is the critical path.
+  }
+}

package/plugins/ctx/lib/import-graph.js

@@ -0,0 +1,124 @@
+import fs from "node:fs";
+import path from "node:path";
+
+const JS_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+const IMPORT_RE = /\bimport\s+(?:[^'"]+\s+from\s+)?['"]([^'"]+)['"]|\brequire\(\s*['"]([^'"]+)['"]\s*\)/g;
+
+export function expandImportGraph({ cwd = process.cwd(), seedFiles = [], limit = 6 } = {}) {
+  const seeds = new Set(seedFiles.map((file) => normalizeRel(file.path)).filter(Boolean));
+  if (!seeds.size) return [];
+
+  const files = [];
+  for (const root of importGraphRoots(cwd, [...seeds])) {
+    walkSourceFiles(root, (filePath) => files.push(path.relative(cwd, filePath)));
+  }
+  const fileSet = new Set(files);
+  const outgoing = new Map();
+  const incoming = new Map();
+
+  for (const rel of files) {
+    const imports = resolveImports({ cwd, rel, fileSet });
+    outgoing.set(rel, imports);
+    for (const target of imports) {
+      const importers = incoming.get(target) || new Set();
+      importers.add(rel);
+      incoming.set(target, importers);
+    }
+  }
+
+  const candidates = new Map();
+  for (const seed of seeds) {
+    for (const target of outgoing.get(seed) || []) {
+      addImportCandidate(candidates, target, `imports:${seed}`, 4);
+    }
+    for (const importer of incoming.get(seed) || []) {
+      addImportCandidate(candidates, importer, `imported-by:${seed}`, 5);
+    }
+  }
+
+  return [...candidates.values()]
+    .filter((file) => !seeds.has(file.path))
+    .sort((a, b) => b.score - a.score || a.path.localeCompare(b.path))
+    .slice(0, limit);
+}
+
+function importGraphRoots(cwd, seedFiles) {
+  const roots = new Set();
+  for (const file of seedFiles) {
+    const parts = file.split(path.sep);
+    const rootParts = parts[0] === "services" && parts[1] ? parts.slice(0, 2) : parts.slice(0, 1);
+    const root = path.join(cwd, ...rootParts);
+    if (fs.existsSync(root)) roots.add(root);
+  }
+  return roots.size ? [...roots] : [cwd];
+}
+
+function addImportCandidate(candidates, filePath, reason, score) {
+  const existing = candidates.get(filePath) || {
+    path: filePath,
+    score: 0,
+    source: "import-graph",
+    reasons: []
+  };
+  existing.score += score;
+  existing.reasons.push(reason);
+  candidates.set(filePath, {
+    ...existing,
+    reasons: [...new Set(existing.reasons)]
+  });
+}
+
+function resolveImports({ cwd, rel, fileSet }) {
+  const fullPath = path.join(cwd, rel);
+  let content = "";
+  try {
+    content = fs.readFileSync(fullPath, "utf8");
+  } catch {
+    return [];
+  }
+
+  const resolved = new Set();
+  for (const match of content.matchAll(IMPORT_RE)) {
+    const specifier = match[1] || match[2];
+    if (!specifier?.startsWith(".")) continue;
+    const target = resolveRelativeImport(path.dirname(rel), specifier, fileSet);
+    if (target) resolved.add(target);
+  }
+  return [...resolved];
+}
+
+function resolveRelativeImport(fromDir, specifier, fileSet) {
+  const base = normalizeRel(path.join(fromDir, specifier));
+  const candidates = [
+    base,
+    ...JS_EXTENSIONS.map((ext) => `${base}${ext}`),
+    ...JS_EXTENSIONS.map((ext) => path.join(base, `index${ext}`))
+  ];
+  return candidates.find((candidate) => fileSet.has(candidate)) || null;
+}
+
+function normalizeRel(filePath) {
+  const normalized = path.normalize(String(filePath || ""));
+  if (!normalized || normalized.startsWith("..") || path.isAbsolute(normalized)) return null;
+  return normalized;
+}
+
+function walkSourceFiles(directory, onFile, depth = 0) {
+  if (depth > 8) return;
+  let entries = [];
+  try {
+    entries = fs.readdirSync(directory, { withFileTypes: true });
+  } catch {
+    return;
+  }
+
+  for (const entry of entries) {
+    if (entry.name.startsWith(".") || ["node_modules", "dist", "build", "coverage", ".next"].includes(entry.name)) continue;
+    const fullPath = path.join(directory, entry.name);
+    if (entry.isDirectory()) {
+      walkSourceFiles(fullPath, onFile, depth + 1);
+    } else if (entry.isFile() && JS_EXTENSIONS.includes(path.extname(entry.name))) {
+      onFile(fullPath);
+    }
+  }
+}