@minhpnq1807/contextos 0.2.0 → 0.3.1

package/plugins/ctx/lib/antigravity-adapter.js

@@ -0,0 +1,56 @@
+import fs from "node:fs";
+import { resolveHookCwd } from "./hook-io.js";
+
+export function antigravityCwd(payload) {
+  return payload.cwd
+    || payload.working_directory
+    || payload.workspacePath
+    || payload.workspacePaths?.[0]
+    || resolveHookCwd(payload);
+}
+
+function textFromValue(value) {
+  if (!value) return "";
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) return value.map(textFromValue).filter(Boolean).join("\n");
+  if (typeof value !== "object") return "";
+  if (typeof value.text === "string") return value.text;
+  if (typeof value.content === "string") return value.content;
+  if (typeof value.message === "string") return value.message;
+  if (typeof value.userMessage === "string") return value.userMessage;
+  if (Array.isArray(value.parts)) return textFromValue(value.parts);
+  if (Array.isArray(value.content)) return textFromValue(value.content);
+  return "";
+}
+
+function looksUserAuthored(record) {
+  const role = String(record.role || record.author || record.type || record.sender || "").toLowerCase();
+  return !role || role.includes("user") || role.includes("human");
+}
+
+export function extractPromptFromAntigravityPayload(payload) {
+  const direct = payload.prompt || payload.userPrompt || payload.userMessage || payload.message;
+  if (direct) return textFromValue(direct);
+
+  const transcriptPath = payload.transcriptPath || payload.transcript_path;
+  if (!transcriptPath || !fs.existsSync(transcriptPath)) return "";
+
+  try {
+    const lines = fs.readFileSync(transcriptPath, "utf8").trim().split(/\r?\n/).filter(Boolean).slice(-200);
+    for (const line of lines.reverse()) {
+      let record;
+      try {
+        record = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (!looksUserAuthored(record)) continue;
+      const text = textFromValue(record.prompt || record.userPrompt || record.userMessage || record.message || record.content || record.parts);
+      if (text.trim()) return text.trim();
+    }
+  } catch {
+    return "";
+  }
+
+  return "";
+}

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

@@ -0,0 +1,53 @@
+import fs from "node:fs";
+import path from "node:path";
+
+function shellQuote(value) {
+  return `'${String(value).replaceAll("'", "'\\''")}'`;
+}
+
+function readJsonFile(filePath, fallback) {
+  if (!fs.existsSync(filePath)) return fallback;
+  const raw = fs.readFileSync(filePath, "utf8").trim();
+  if (!raw) return fallback;
+  return JSON.parse(raw);
+}
+
+function commandFor(installRoot, scriptName, { injectPromptContext = true } = {}) {
+  const envPrefix = scriptName === "on-antigravity-preinvocation.js" && !injectPromptContext ? "CONTEXTOS_INJECT=0 " : "";
+  return `${envPrefix}node ${shellQuote(path.join(installRoot, "plugins", "ctx", "bin", scriptName))}`;
+}
+
+export function antigravityHooksPath() {
+  return process.env.ANTIGRAVITY_HOOKS_PATH
+    || path.join(process.env.HOME || process.cwd(), ".gemini", "config", "hooks.json");
+}
+
+export function buildAntigravityHooksConfig(existingConfig, { installRoot, injectPromptContext = true } = {}) {
+  const config = existingConfig && typeof existingConfig === "object" ? structuredClone(existingConfig) : {};
+  config.contextos = {
+    enabled: true,
+    PreInvocation: [
+      {
+        type: "command",
+        command: commandFor(installRoot, "on-antigravity-preinvocation.js", { injectPromptContext }),
+        timeout: 10
+      }
+    ],
+    Stop: [
+      {
+        type: "command",
+        command: commandFor(installRoot, "on-antigravity-stop.js"),
+        timeout: 10
+      }
+    ]
+  };
+  return config;
+}
+
+export function installAntigravityHooks({ hooksPath = antigravityHooksPath(), installRoot, injectPromptContext = true } = {}) {
+  const existing = readJsonFile(hooksPath, {});
+  const next = buildAntigravityHooksConfig(existing, { installRoot, injectPromptContext });
+  fs.mkdirSync(path.dirname(hooksPath), { recursive: true });
+  fs.writeFileSync(hooksPath, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+  return hooksPath;
+}

package/plugins/ctx/lib/antigravity-mcp.js

@@ -0,0 +1,43 @@
+import fs from "node:fs";
+import path from "node:path";
+
+function readJsonFile(filePath, fallback) {
+  if (!fs.existsSync(filePath)) return fallback;
+  const raw = fs.readFileSync(filePath, "utf8").trim();
+  if (!raw) return fallback;
+  return JSON.parse(raw);
+}
+
+export function antigravityMcpConfigPaths() {
+  if (process.env.ANTIGRAVITY_MCP_CONFIG_PATH) {
+    return [process.env.ANTIGRAVITY_MCP_CONFIG_PATH];
+  }
+  const home = process.env.HOME || process.cwd();
+  return [
+    path.join(home, ".gemini", "antigravity", "mcp_config.json"),
+    path.join(home, ".gemini", "antigravity-cli", "mcp_config.json"),
+    path.join(home, ".gemini", "config", "mcp_config.json")
+  ];
+}
+
+export function buildAntigravityMcpConfig(existingConfig, { installRoot } = {}) {
+  const config = existingConfig && typeof existingConfig === "object" ? structuredClone(existingConfig) : {};
+  if (!config.mcpServers || typeof config.mcpServers !== "object") config.mcpServers = {};
+  config.mcpServers["ctx-mcp"] = {
+    command: "node",
+    args: [path.join(installRoot, "plugins", "ctx", "mcp", "server.js")]
+  };
+  return config;
+}
+
+export function installAntigravityMcp({ configPaths = antigravityMcpConfigPaths(), installRoot } = {}) {
+  const written = [];
+  for (const configPath of configPaths) {
+    const existing = readJsonFile(configPath, {});
+    const next = buildAntigravityMcpConfig(existing, { installRoot });
+    fs.mkdirSync(path.dirname(configPath), { recursive: true });
+    fs.writeFileSync(configPath, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+    written.push(configPath);
+  }
+  return written;
+}

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

@@ -0,0 +1,27 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import { buildGlobalHooksConfig } from "./global-hooks.js";
+
+function readJsonFile(filePath, fallback) {
+  if (!fs.existsSync(filePath)) return fallback;
+  const raw = fs.readFileSync(filePath, "utf8").trim();
+  if (!raw) return fallback;
+  return JSON.parse(raw);
+}
+
+export function claudeHome() {
+  return process.env.CLAUDE_HOME || path.join(process.env.HOME || process.cwd(), ".claude");
+}
+
+export function installClaudeHooks({ claudeHome: home = claudeHome(), installRoot, injectPromptContext = true } = {}) {
+  const settingsPath = path.join(home, "settings.json");
+  const existing = readJsonFile(settingsPath, {});
+  const next = buildGlobalHooksConfig(existing, {
+    marketplaceRoot: installRoot,
+    injectPromptContext
+  });
+  fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
+  fs.writeFileSync(settingsPath, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+  return settingsPath;
+}

package/plugins/ctx/lib/claude-mcp.js

@@ -0,0 +1,33 @@
+import fs from "node:fs";
+import path from "node:path";
+
+function readJsonFile(filePath, fallback) {
+  if (!fs.existsSync(filePath)) return fallback;
+  const raw = fs.readFileSync(filePath, "utf8").trim();
+  if (!raw) return fallback;
+  return JSON.parse(raw);
+}
+
+export function claudeConfigPath() {
+  return process.env.CLAUDE_CONFIG_PATH || path.join(process.env.HOME || process.cwd(), ".claude.json");
+}
+
+export function buildClaudeMcpConfig(existingConfig, { installRoot } = {}) {
+  const config = existingConfig && typeof existingConfig === "object" ? structuredClone(existingConfig) : {};
+  if (!config.mcpServers || typeof config.mcpServers !== "object") config.mcpServers = {};
+  config.mcpServers["ctx-mcp"] = {
+    type: "stdio",
+    command: "node",
+    args: [path.join(installRoot, "plugins", "ctx", "mcp", "server.js")],
+    env: {}
+  };
+  return config;
+}
+
+export function installClaudeMcp({ configPath = claudeConfigPath(), installRoot } = {}) {
+  const existing = readJsonFile(configPath, {});
+  const next = buildClaudeMcpConfig(existing, { installRoot });
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  fs.writeFileSync(configPath, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+  return configPath;
+}

package/plugins/ctx/lib/embedding-scorer.js

@@ -57,6 +57,9 @@ export async function warmRuleEmbeddings({
   sources = [],
   allowRemote = true
 } = {}) {
+  if (!allowRemote && !isModelCacheReady(dataDir)) {
+    return { count: 0, cachePath: path.join(dataDir, "embeddings.db"), status: "missing-model" };
+  }
   const texts = [...new Set([
     task,
     ...rules.map((rule) => rule.content || "")
@@ -131,6 +134,16 @@ export function modelCacheDir(dataDir = defaultDataRoot()) {
   return path.join(dataDir, "models");
 }
 
+export function isModelCacheReady(dataDir = defaultDataRoot()) {
+  const modelDir = path.join(modelCacheDir(dataDir), ...DEFAULT_MODEL.split("/"));
+  return [
+    "config.json",
+    "tokenizer.json",
+    "tokenizer_config.json",
+    path.join("onnx", "model_quantized.onnx")
+  ].every((relativePath) => fs.existsSync(path.join(modelDir, relativePath)));
+}
+
 async function getCachedEmbedding({ cache, embedder, text, sources }) {
   const key = cacheKey(text, sources);
   const existing = cache.get(key);

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

@@ -1,6 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
-import { enhanceRuleScoresWithEmbeddings, warmRuleEmbeddings } from "./embedding-scorer.js";
+import { enhanceRuleScoresWithEmbeddings, isModelCacheReady, warmRuleEmbeddings } from "./embedding-scorer.js";
 
 const SOURCE_EXTENSIONS = new Set([
   ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", ".sql", ".md", ".json"
@@ -65,6 +65,7 @@ export async function warmFileEmbeddings({
   maxFiles = Number(process.env.CONTEXTOS_FILE_EMBEDDING_MAX_FILES || DEFAULT_MAX_FILES)
 } = {}) {
   if (!dataDir) return { count: 0, cachePath: null };
+  if (!allowRemote && !isModelCacheReady(dataDir)) return { count: 0, cachePath: null, status: "missing-model" };
   const files = listSourceFiles(cwd, { maxFiles });
   const rules = files.map((filePath) => ({ content: fileSearchText(filePath) }));
   return warmRuleEmbeddings({

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

@@ -15,6 +15,22 @@ export function writeJson(value) {
   process.stdout.write(`${JSON.stringify(value)}\n`);
 }
 
+export function resolveHookCwd(payload = {}) {
+  return payload.cwd
+    || payload.working_directory
+    || payload.workspacePath
+    || payload.workspace_path
+    || payload.workspaceRoot
+    || payload.workspace_root
+    || payload.projectDir
+    || payload.project_dir
+    || payload.workspacePaths?.[0]
+    || payload.workspace_paths?.[0]
+    || process.env.CLAUDE_PROJECT_DIR
+    || process.env.PWD
+    || process.cwd();
+}
+
 export function pluginDataDir(fileName = "", cwd = process.cwd()) {
   let root;
   try {

package/plugins/ctx/lib/package-install.js

@@ -0,0 +1,36 @@
+import fs from "node:fs";
+import path from "node:path";
+
+export function copyDir(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else if (entry.isFile()) {
+      fs.copyFileSync(srcPath, destPath);
+      fs.chmodSync(destPath, fs.statSync(srcPath).mode);
+    }
+  }
+}
+
+export function copyPath(src, dest) {
+  const stat = fs.statSync(src);
+  if (stat.isDirectory()) {
+    copyDir(src, dest);
+  } else {
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    fs.copyFileSync(src, dest);
+    fs.chmodSync(dest, stat.mode);
+  }
+}
+
+export function copyPackageRoot({ rootDir, targetRoot }) {
+  fs.rmSync(targetRoot, { recursive: true, force: true });
+  for (const entry of [".agents", "bin", "plugins", "package.json", "package-lock.json", "README.md", "LICENSE", "node_modules"]) {
+    const src = path.join(rootDir, entry);
+    if (fs.existsSync(src)) copyPath(src, path.join(targetRoot, entry));
+  }
+  return targetRoot;
+}

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

@@ -1,6 +1,7 @@
 import { scheduleContext } from "./scheduler.js";
 import { appendJsonLine, writeJsonFile } from "./fs-utils.js";
 import { callCtxScoreContext } from "./ctx-mcp-client.js";
+import { resolveHookCwd } from "./hook-io.js";
 import path from "node:path";
 
 export async function handlePromptPayload(
@@ -16,7 +17,7 @@ export async function handlePromptPayload(
   } = {}
 ) {
   const prompt = payload.prompt || payload.message || payload.user_prompt || "";
-  const cwd = payload.cwd || payload.working_directory || process.cwd();
+  const cwd = resolveHookCwd(payload);
   const openFiles = payload.openFiles || payload.open_files || payload.files || [];
   const dataDir = dataPath ? path.dirname(dataPath) : undefined;