coding-friend-cli 1.39.0 → 1.40.0

package/dist/{chunk-GTOEIGDM.js → chunk-KCBMCHSA.js}

@@ -1,14 +1,27 @@
 import {
   getOmpExtensionPath
-} from "./chunk-ZZNTNIM4.js";
+} from "./chunk-TN3Y75WG.js";
 import {
   compareVersions
-} from "./chunk-OFEC6OVI.js";
+} from "./chunk-OBCNHQFA.js";
 import {
   readJson,
   writeJson
 } from "./chunk-5UVDWG5L.js";
 import {
+  commandExists,
+  run,
+  runWithStderr
+} from "./chunk-EVGXUDX4.js";
+import {
+  agyConfigDir,
+  agyConfigJsonPath,
+  agyConfigRoot,
+  agyPluginDir,
+  agyPluginsDir,
+  agySourceCloneDir,
+  devStatePath,
+  marketplaceClonePath,
   ompConfigYmlPath,
   ompExtensionsDir,
   ompMcpJsonPath,
@@ -17,18 +30,244 @@ import {
   ompProjectExtensionsDir,
   ompUserAgentsDir,
   pluginCachePath
-} from "./chunk-IV5OPG34.js";
+} from "./chunk-IYBIIRH4.js";
 
-// src/lib/omp-config.ts
+// src/lib/agy-config.ts
 import {
+  cpSync,
   existsSync,
   mkdirSync,
   readdirSync,
-  readFileSync,
   rmSync,
-  writeFileSync
+  statSync
 } from "fs";
 import { dirname, join, resolve } from "path";
+var PLUGIN_NAME = "coding-friend";
+var PLUGIN_SUBDIR = "plugin-antigravity";
+var SOURCE_REPO = "https://github.com/dinhanhthi/coding-friend";
+var INSTALLED_VERSION_FILE = "installed_version.json";
+var PLUGIN_JSON = "plugin.json";
+var MCP_CONFIG = "mcp_config.json";
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isDirectory(path) {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function pluginSourcePath(root) {
+  return join(root, PLUGIN_SUBDIR);
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function countFiles(dir) {
+  let count = 0;
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return 0;
+  }
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      count += countFiles(join(dir, entry.name));
+    } else {
+      count += 1;
+    }
+  }
+  return count;
+}
+function readVersionFromPluginJson(dir) {
+  const data = readJson(join(dir, PLUGIN_JSON));
+  if (typeof data?.version !== "string") return null;
+  const version = data.version.trim();
+  return version || null;
+}
+function ensureAgySourceClone(cloneDir) {
+  if (!commandExists("git")) {
+    throw new Error(
+      "git is not installed or not on PATH. Cannot clone the Antigravity plugin source from GitHub."
+    );
+  }
+  if (existsSync(join(cloneDir, ".git"))) {
+    const result2 = run("git", ["-C", cloneDir, "pull", "--ff-only"]);
+    if (result2 === null) {
+      throw new Error(
+        `Failed to update Antigravity plugin source at ${cloneDir} (git pull --ff-only). Delete that directory and retry, or check your network.`
+      );
+    }
+    return;
+  }
+  if (existsSync(cloneDir)) {
+    rmSync(cloneDir, { recursive: true, force: true });
+  }
+  mkdirSync(dirname(cloneDir), { recursive: true });
+  const result = run("git", ["clone", "--depth", "1", SOURCE_REPO, cloneDir]);
+  if (result === null) {
+    rmSync(cloneDir, { recursive: true, force: true });
+    throw new Error(
+      `Failed to clone ${SOURCE_REPO} into ${cloneDir}. Check your network and that git can reach GitHub. Cannot install a partial Antigravity plugin.`
+    );
+  }
+}
+function resolveAgyPluginSource() {
+  const devState = readJson(devStatePath());
+  if (typeof devState?.localPath === "string" && devState.localPath.trim()) {
+    const path2 = pluginSourcePath(resolve(devState.localPath.trim()));
+    if (isDirectory(path2)) return { path: path2, kind: "dev" };
+  }
+  const marketplacePath = pluginSourcePath(marketplaceClonePath());
+  if (isDirectory(marketplacePath)) {
+    return { path: marketplacePath, kind: "marketplace" };
+  }
+  const cloneDir = agySourceCloneDir();
+  ensureAgySourceClone(cloneDir);
+  const path = pluginSourcePath(cloneDir);
+  if (!isDirectory(path)) {
+    throw new Error(
+      `Cloned coding-friend source at ${cloneDir} is missing ${PLUGIN_SUBDIR}/. Cannot install the Antigravity plugin.`
+    );
+  }
+  return { path, kind: "clone" };
+}
+function deployAgyPlugin(source) {
+  const resolvedSource = resolve(source);
+  if (!isDirectory(resolvedSource)) {
+    throw new Error(`Antigravity plugin source not found: ${resolvedSource}`);
+  }
+  const target = agyPluginDir();
+  if (resolvedSource === resolve(target)) {
+    throw new Error(
+      "Cannot deploy Antigravity plugin: source and target are the same directory."
+    );
+  }
+  mkdirSync(agyPluginsDir(), { recursive: true });
+  rmSync(target, { recursive: true, force: true });
+  try {
+    cpSync(resolvedSource, target, { recursive: true });
+  } catch (error) {
+    rmSync(target, { recursive: true, force: true });
+    throw new Error(
+      `Failed to copy Antigravity plugin from ${resolvedSource} to ${target}: ${errorMessage(error)}`
+    );
+  }
+  const files = countFiles(target);
+  if (files === 0) {
+    rmSync(target, { recursive: true, force: true });
+    throw new Error(
+      `Antigravity plugin source ${resolvedSource} copied 0 files. Refusing partial install.`
+    );
+  }
+  writeJson(join(target, INSTALLED_VERSION_FILE), {
+    version: readVersionFromPluginJson(resolvedSource) ?? "unknown",
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    source: resolvedSource
+  });
+  return { files };
+}
+function removeAgyPlugin() {
+  const target = agyPluginDir();
+  if (target === agyConfigRoot() || target === agyConfigDir() || target === agyPluginsDir()) {
+    throw new Error(
+      "Refusing to remove Antigravity config root; expected the coding-friend plugin directory."
+    );
+  }
+  if (!existsSync(target)) return;
+  rmSync(target, { recursive: true, force: true });
+}
+function isAgyPluginInstalled() {
+  return existsSync(join(agyPluginDir(), PLUGIN_JSON));
+}
+function readAgyPluginVersion() {
+  const dir = agyPluginDir();
+  const installed = readJson(
+    join(dir, INSTALLED_VERSION_FILE)
+  );
+  if (typeof installed?.version === "string" && installed.version.trim()) {
+    return installed.version.trim();
+  }
+  return readVersionFromPluginJson(dir);
+}
+function setAgyPluginEnabled(enabled) {
+  const filePath = agyConfigJsonPath();
+  const existing = readJson(filePath);
+  const data = isPlainObject(existing) ? { ...existing } : {};
+  const plugins = isPlainObject(data.plugins) ? { ...data.plugins } : {};
+  const entry = isPlainObject(plugins[PLUGIN_NAME]) ? { ...plugins[PLUGIN_NAME] } : {};
+  entry.enabled = enabled;
+  plugins[PLUGIN_NAME] = entry;
+  data.plugins = plugins;
+  writeJson(filePath, data);
+}
+function isAgyPluginEnabled() {
+  const data = readJson(agyConfigJsonPath());
+  if (!data || !isPlainObject(data.plugins)) return false;
+  const entry = data.plugins[PLUGIN_NAME];
+  return isPlainObject(entry) && entry.enabled === true;
+}
+function removeAgyPluginConfigEntry() {
+  const filePath = agyConfigJsonPath();
+  const existing = readJson(filePath);
+  if (!existing || !isPlainObject(existing.plugins)) return false;
+  if (!(PLUGIN_NAME in existing.plugins)) return false;
+  const plugins = { ...existing.plugins };
+  delete plugins[PLUGIN_NAME];
+  writeJson(filePath, { ...existing, plugins });
+  return true;
+}
+function mcpConfigPath() {
+  return join(agyPluginDir(), MCP_CONFIG);
+}
+function readAgyMcpConfig() {
+  const data = readJson(mcpConfigPath());
+  if (!data || !isPlainObject(data.mcpServers)) return null;
+  return data;
+}
+function writeAgyMcpEntry(name, server) {
+  const filePath = mcpConfigPath();
+  const existing = readJson(filePath);
+  const data = isPlainObject(existing) ? { ...existing } : {};
+  const mcpServers = isPlainObject(
+    data.mcpServers
+  ) ? { ...data.mcpServers } : {};
+  mcpServers[name] = server;
+  data.mcpServers = mcpServers;
+  writeJson(filePath, data);
+}
+function removeAgyMcpEntry(name) {
+  const filePath = mcpConfigPath();
+  const existing = readJson(filePath);
+  if (!existing || !isPlainObject(existing.mcpServers)) return;
+  const mcpServers = {
+    ...existing.mcpServers
+  };
+  if (!(name in mcpServers)) return;
+  delete mcpServers[name];
+  writeJson(filePath, { ...existing, mcpServers });
+}
+function validateAgyPlugin(dir) {
+  if (!commandExists("agy")) {
+    return { stdout: "", status: 127 };
+  }
+  const result = runWithStderr("agy", ["plugin", "validate", dir]);
+  const stdout = [result.stdout, result.stderr].filter(Boolean).join("\n");
+  return { stdout, status: result.exitCode };
+}
+
+// src/lib/omp-config.ts
+import {
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  readdirSync as readdirSync2,
+  readFileSync,
+  rmSync as rmSync2,
+  writeFileSync
+} from "fs";
+import { dirname as dirname2, join as join2, resolve as resolve2 } from "path";
 var EXTENSION_SHIM = "coding-friend.ts";
 var MANAGED_START = "# coding-friend-managed";
 var MANAGED_END = "# end coding-friend-managed";
@@ -47,7 +286,7 @@ var FALLBACK_CF_AGENT_NAMES = [
   "cf-writer",
   "cf-writer-deep"
 ];
-function isPlainObject(value) {
+function isPlainObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function agentsDirForScope(scope) {
@@ -105,9 +344,9 @@ function isCfAgentFile(name) {
   return /^cf-.*\.md$/.test(name);
 }
 function listMdFiles(dir) {
-  if (!existsSync(dir)) return [];
+  if (!existsSync2(dir)) return [];
   try {
-    return readdirSync(dir, { withFileTypes: true }).filter(
+    return readdirSync2(dir, { withFileTypes: true }).filter(
       (entry) => (entry.isFile() || entry.isSymbolicLink()) && entry.name.endsWith(".md")
     ).map((entry) => entry.name).sort();
   } catch {
@@ -128,26 +367,26 @@ function ourAgentNames(scope) {
   return [...names].sort();
 }
 function repoPluginCandidate(repoRoot, ...parts) {
-  const direct = resolve(repoRoot, ...parts);
-  const parent = resolve(repoRoot, "..", ...parts);
-  if (existsSync(direct)) return direct;
-  if (existsSync(parent)) return parent;
-  if (existsSync(resolve(repoRoot, "..", "plugin", "agents"))) return parent;
+  const direct = resolve2(repoRoot, ...parts);
+  const parent = resolve2(repoRoot, "..", ...parts);
+  if (existsSync2(direct)) return direct;
+  if (existsSync2(parent)) return parent;
+  if (existsSync2(resolve2(repoRoot, "..", "plugin", "agents"))) return parent;
   return direct;
 }
 function latestCachedPluginDir(cacheRoot = pluginCachePath()) {
-  if (!existsSync(cacheRoot)) return null;
-  if (existsSync(join(cacheRoot, "agents"))) return cacheRoot;
+  if (!existsSync2(cacheRoot)) return null;
+  if (existsSync2(join2(cacheRoot, "agents"))) return cacheRoot;
   let dirs = [];
   try {
-    dirs = readdirSync(cacheRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+    dirs = readdirSync2(cacheRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
   } catch {
     return null;
   }
   const versions = dirs.filter((name) => /^\d/.test(name)).sort(compareVersions).reverse();
-  if (versions[0]) return join(cacheRoot, versions[0]);
+  if (versions[0]) return join2(cacheRoot, versions[0]);
   const rest = [...dirs].sort(compareVersions).reverse();
-  return rest[0] ? join(cacheRoot, rest[0]) : null;
+  return rest[0] ? join2(cacheRoot, rest[0]) : null;
 }
 function ensureNl(content) {
   return content === "" || content.endsWith("\n") ? content : `${content}
@@ -347,18 +586,18 @@ function removeOurDisabledAgents(content, ours) {
   return writeDisabledAgents(content, remaining, false);
 }
 function writeTextFile(filePath, content) {
-  mkdirSync(dirname(filePath), { recursive: true });
+  mkdirSync2(dirname2(filePath), { recursive: true });
   writeFileSync(filePath, ensureNl(content), "utf8");
 }
 function readOmpMcpJson(filePath = ompMcpJsonPath()) {
   const data = readJson(filePath);
-  if (!data || !isPlainObject(data.mcpServers)) return null;
+  if (!data || !isPlainObject2(data.mcpServers)) return null;
   return data;
 }
 function writeOmpMcpEntry(name, server, filePath = ompMcpJsonPath()) {
   const existing = readJson(filePath);
-  const data = isPlainObject(existing) ? { ...existing } : {};
-  const mcpServers = isPlainObject(
+  const data = isPlainObject2(existing) ? { ...existing } : {};
+  const mcpServers = isPlainObject2(
     data.mcpServers
   ) ? { ...data.mcpServers } : {};
   mcpServers[name] = server;
@@ -367,7 +606,7 @@ function writeOmpMcpEntry(name, server, filePath = ompMcpJsonPath()) {
 }
 function removeOmpMcpEntry(name, filePath = ompMcpJsonPath()) {
   const existing = readJson(filePath);
-  if (!existing || !isPlainObject(existing.mcpServers)) return;
+  if (!existing || !isPlainObject2(existing.mcpServers)) return;
   const mcpServers = {
     ...existing.mcpServers
   };
@@ -400,13 +639,13 @@ ${normalizeAgentBody(body)}`;
 }
 function findOmpAgentSourceDir(repoRoot = process.cwd()) {
   const repoAgents = repoPluginCandidate(repoRoot, "plugin", "agents");
-  if (existsSync(repoAgents)) return repoAgents;
+  if (existsSync2(repoAgents)) return repoAgents;
   const cached = latestCachedPluginDir();
   if (!cached) return null;
-  const cachedAgents = join(cached, "agents");
-  if (existsSync(cachedAgents)) return cachedAgents;
-  const nested = join(cached, "plugin", "agents");
-  return existsSync(nested) ? nested : null;
+  const cachedAgents = join2(cached, "agents");
+  if (existsSync2(cachedAgents)) return cachedAgents;
+  const nested = join2(cached, "plugin", "agents");
+  return existsSync2(nested) ? nested : null;
 }
 function deployOmpAgents(scope, options) {
   const sourceDir = findOmpAgentSourceDir();
@@ -417,12 +656,12 @@ function deployOmpAgents(scope, options) {
   const dryRun = options?.dryRun === true;
   const targetDir = agentsDirForScope(scope);
   let printedFirst = false;
-  if (!dryRun) mkdirSync(targetDir, { recursive: true });
+  if (!dryRun) mkdirSync2(targetDir, { recursive: true });
   for (const filename of files) {
     let converted;
     try {
       converted = convertClaudeAgentToOmp(
-        readFileSync(join(sourceDir, filename), "utf8")
+        readFileSync(join2(sourceDir, filename), "utf8")
       );
     } catch {
       skipped.push(filename);
@@ -436,43 +675,43 @@ function deployOmpAgents(scope, options) {
       skipped.push(filename);
       continue;
     }
-    writeFileSync(join(targetDir, filename), converted, "utf8");
+    writeFileSync(join2(targetDir, filename), converted, "utf8");
     deployed.push(filename);
   }
   return { deployed, skipped };
 }
 function removeOmpAgents(scope) {
   const targetDir = agentsDirForScope(scope);
-  if (!existsSync(targetDir)) return;
-  for (const entry of readdirSync(targetDir, { withFileTypes: true })) {
+  if (!existsSync2(targetDir)) return;
+  for (const entry of readdirSync2(targetDir, { withFileTypes: true })) {
     if (!(entry.isFile() || entry.isSymbolicLink()) || !isCfAgentFile(entry.name)) {
       continue;
     }
-    rmSync(join(targetDir, entry.name));
+    rmSync2(join2(targetDir, entry.name));
   }
 }
 function writeOmpExtensionEntry(scope, repoRoot = process.cwd()) {
   const extensionPath = getOmpExtensionPath(repoRoot);
-  if (!extensionPath || !existsSync(extensionPath)) {
+  if (!extensionPath || !existsSync2(extensionPath)) {
     throw new Error(
       extensionPath ? `omp extension not found: ${extensionPath}. Run from the coding-friend repo or install the plugin first.` : "omp extension not found. Run from the coding-friend repo or install the plugin first."
     );
   }
-  const pluginRoot = dirname(dirname(extensionPath));
+  const pluginRoot = dirname2(dirname2(extensionPath));
   const shim = [
     `// CODING_FRIEND_PLUGIN_ROOT=${pluginRoot}`,
     `export { default } from ${JSON.stringify(extensionPath)};`,
     ""
   ].join("\n");
-  writeTextFile(join(extensionsDirForScope(scope), EXTENSION_SHIM), shim);
+  writeTextFile(join2(extensionsDirForScope(scope), EXTENSION_SHIM), shim);
 }
 function removeOmpExtensionEntry(scope) {
-  const filePath = join(extensionsDirForScope(scope), EXTENSION_SHIM);
-  if (existsSync(filePath)) rmSync(filePath);
+  const filePath = join2(extensionsDirForScope(scope), EXTENSION_SHIM);
+  if (existsSync2(filePath)) rmSync2(filePath);
 }
 function setOmpAgentEnabled(scope) {
   const filePath = configYmlForScope(scope);
-  if (!existsSync(filePath)) return false;
+  if (!existsSync2(filePath)) return false;
   const current = readFileSync(filePath, "utf8");
   const next = removeOurDisabledAgents(current, ourAgentNames(scope));
   if (next === current) return false;
@@ -481,14 +720,14 @@ function setOmpAgentEnabled(scope) {
 }
 function setOmpAgentDisabled(scope) {
   const filePath = configYmlForScope(scope);
-  const current = existsSync(filePath) ? readFileSync(filePath, "utf8") : "";
+  const current = existsSync2(filePath) ? readFileSync(filePath, "utf8") : "";
   writeTextFile(filePath, upsertDisabledAgents(current, ourAgentNames(scope)));
 }
 function isOmpAgentInstalled(scope) {
   const dir = agentsDirForScope(scope);
-  if (!existsSync(dir)) return false;
+  if (!existsSync2(dir)) return false;
   try {
-    return readdirSync(dir, { withFileTypes: true }).some(
+    return readdirSync2(dir, { withFileTypes: true }).some(
       (entry) => (entry.isFile() || entry.isSymbolicLink()) && isCfAgentFile(entry.name)
     );
   } catch {
@@ -497,6 +736,18 @@ function isOmpAgentInstalled(scope) {
 }
 
 export {
+  resolveAgyPluginSource,
+  deployAgyPlugin,
+  removeAgyPlugin,
+  isAgyPluginInstalled,
+  readAgyPluginVersion,
+  setAgyPluginEnabled,
+  isAgyPluginEnabled,
+  removeAgyPluginConfigEntry,
+  readAgyMcpConfig,
+  writeAgyMcpEntry,
+  removeAgyMcpEntry,
+  validateAgyPlugin,
   readOmpMcpJson,
   writeOmpMcpEntry,
   removeOmpMcpEntry,

package/dist/{chunk-463QKRBN.js → chunk-KG6HYBGD.js}

@@ -3,8 +3,11 @@ import {
   writeJson
 } from "./chunk-5UVDWG5L.js";
 import {
+  claudeLocalSettingsPath,
+  claudeProjectSettingsPath,
+  claudeSettingsPath,
   pluginCachePath
-} from "./chunk-IV5OPG34.js";
+} from "./chunk-IYBIIRH4.js";
 
 // src/lib/permissions.ts
 var STATIC_RULES = [
@@ -451,6 +454,23 @@ async function runDangerousRulesAudit(settingsPaths, log, promptConfirm) {
     }
   }
 }
+var AUTO_APPROVE_CROSS_HOST_NOTE = "autoApprove enables Claude Code (LLM classifier), Antigravity, and Codex (deterministic rules).";
+async function afterAutoApproveEnabled(log, promptConfirm) {
+  await runDangerousRulesAudit(
+    [
+      claudeProjectSettingsPath(),
+      claudeLocalSettingsPath(),
+      claudeSettingsPath()
+    ],
+    log,
+    promptConfirm
+  );
+  log.dim(`Note: ${AUTO_APPROVE_CROSS_HOST_NOTE}`);
+  log.dim(
+    "Tip: Fine-tune with autoApproveAllowExtra / autoApproveIgnore in config.json"
+  );
+  log.dim("Docs: https://cf.dinhanhthi.com/docs/reference/auto-approve/");
+}
 function logPluginScriptWarning(log, chalk) {
   log.warn(
     `Plugin script rules use ${chalk.bold("wide patterns")} that allow executing any script in the Coding Friend plugin cache.`
@@ -462,12 +482,7 @@ function logPluginScriptWarning(log, chalk) {
 
 export {
   STATIC_RULES,
-  buildPluginScriptRules,
   getAllRules,
-  PERMISSION_RULES,
-  DANGEROUS_RULE_PATTERNS,
-  auditDangerousRules,
-  stripDangerousRules,
   getExistingRules,
   getMissingRules,
   buildLearnDirRules,
@@ -475,6 +490,7 @@ export {
   groupByCategory,
   extractTag,
   cleanupStalePluginRules,
-  runDangerousRulesAudit,
+  AUTO_APPROVE_CROSS_HOST_NOTE,
+  afterAutoApproveEnabled,
   logPluginScriptWarning
 };