agy-plugin-porter 0.0.0-stage → 0.1.0

package/lib/tool-map.mjs

@@ -0,0 +1,47 @@
+// Source tool names -> agy tool names. Claude's comes from `agy plugin validate`
+// 1.4.5 (docs/agy-baseline.md, "Tool names"); where the CLI and the IDE name a
+// tool differently, both are listed. scripts/hook-shim.mjs keeps its own reverse
+// copy because it ships alone inside each ported plugin.
+export const TOOLS = {
+  claude: {
+    Bash: ['run_command'],
+    Read: ['view_file', 'read_file'],
+    Write: ['write_to_file', 'write_file'],
+    Edit: ['replace_file_content', 'edit_file'],
+    MultiEdit: ['multi_replace_file_content', 'edit_file'],
+    Grep: ['grep_search'],
+    Glob: ['find_by_name'],
+    LS: ['list_dir'],
+    WebFetch: ['read_url_content'],
+    WebSearch: ['search_web'],
+    NotebookEdit: ['notebook_edit'],
+    Task: ['invoke_subagent'],
+    Agent: ['invoke_subagent'],
+  },
+  gemini: {
+    run_shell_command: ['run_command'],
+    read_file: ['view_file', 'read_file'],
+    write_file: ['write_to_file', 'write_file'],
+    replace: ['replace_file_content', 'edit_file'],
+    glob: ['find_by_name'],
+    search_file_content: ['grep_search'],
+    list_directory: ['list_dir'],
+    web_fetch: ['read_url_content'],
+    google_web_search: ['search_web'],
+  },
+};
+
+export const AGY_TOOLS = new Set(Object.values(TOOLS).flatMap((m) => Object.values(m).flat()));
+
+// Roo/Kilo/Cline mode tool groups.
+export const ROO_GROUPS = {
+  read: ['view_file', 'read_file', 'list_dir', 'grep_search', 'find_by_name'],
+  edit: ['write_to_file', 'write_file', 'replace_file_content', 'edit_file', 'multi_replace_file_content'],
+  command: ['run_command'],
+};
+
+export function unmappedToolReason(name) {
+  if (name.startsWith('mcp__')) return 'MCP tool names are not mapped yet (agy MCP step names are unverified)';
+  if (name === 'TodoWrite' || /^Task(Create|Get|List|Update|Output|Stop)$/.test(name)) return 'agy has no built-in tool that does the same job';
+  return 'no agy tool with this name';
+}

package/lib/transpiler-engine.mjs

@@ -0,0 +1,158 @@
+// detect -> stage -> compile -> audit -> write. For Claude Code and Gemini CLI
+// sources, staging is `agy plugin install` run against a throwaway home, and
+// the porter post-processes what agy staged (docs/agy-baseline.md). Cursor,
+// Roo/Kilo and Codex sources, which agy doesn't detect, start from an empty
+// plugin dir. agy only ever runs with HOME/USERPROFILE pointed at a temp dir,
+// so the user's real profile is never read or written.
+import { spawnSync } from 'node:child_process';
+import { cpSync, existsSync, mkdirSync, mkdtempSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { basename, join, posix, resolve } from 'node:path';
+
+import { detect } from './detector.mjs';
+import { compileHooks, writeHookPort } from './hook-compiler.mjs';
+import { sanitizeManifest, sourceManifest } from './manifest-sanitizer.mjs';
+import { compileModes } from './mode-compiler.mjs';
+import { compileRules } from './rules-compiler.mjs';
+import { compileSkills, slugifyName } from './skill-compiler.mjs';
+import { auditPlugin } from './static-auditor.mjs';
+
+const AGY_STAGED = ['claude', 'gemini'];
+
+export function throwawayEnv(home) {
+  return { ...process.env, HOME: home, USERPROFILE: home, NO_COLOR: '1' };
+}
+
+export function runAgy(args, { agy = 'agy', home }) {
+  const run = spawnSync(agy, args, { encoding: 'utf8', env: throwawayEnv(home), timeout: 120_000 });
+  if (run.error) throw new Error(`can't run ${agy}: ${run.error.message}`);
+  return run;
+}
+
+// Runs `agy plugin install <srcDir>` in a throwaway home and returns the staged dir.
+export function stageWithAgy(srcDir, { agy, workDir }) {
+  const home = join(workDir, 'home');
+  mkdirSync(home, { recursive: true });
+  const run = runAgy(['plugin', 'install', srcDir], { agy, home });
+  const pluginsDir = join(home, '.gemini', 'config', 'plugins');
+  const staged = existsSync(pluginsDir) ? readdirSync(pluginsDir).filter((d) => statSync(join(pluginsDir, d)).isDirectory()) : [];
+  if (run.status !== 0 || staged.length !== 1) {
+    throw new Error(`agy plugin install failed (exit ${run.status}): ${(run.stdout + run.stderr).trim()}`);
+  }
+  return join(pluginsDir, staged[0]);
+}
+
+const removeEmptyDirs = (dir) => {
+  for (const entry of readdirSync(dir)) {
+    const full = join(dir, entry);
+    if (statSync(full).isDirectory()) {
+      removeEmptyDirs(full);
+      if (readdirSync(full).length === 0) rmSync(full, { recursive: true });
+    }
+  }
+};
+
+const merge = (into, part) => {
+  into.ported.push(...part.ported);
+  into.unported.push(...part.unported);
+  into.warnings.push(...part.warnings);
+};
+
+export function defaultSlug(srcDir, ecosystems) {
+  const name = sourceManifest(srcDir, ecosystems).name;
+  return slugifyName(typeof name === 'string' && name ? name : basename(resolve(srcDir)));
+}
+
+// Ports srcDir into outDir. Returns the port report.
+export function transpile({ srcDir, outDir, slug, agy = 'agy', force = false, validate = false }) {
+  srcDir = resolve(srcDir);
+  const detection = detect(srcDir);
+  const { ecosystems } = detection;
+  if (ecosystems.length === 0) throw new Error(`no plugin found in ${srcDir} (looked for Claude Code, Gemini CLI, Cursor, Roo/Kilo, Codex and Antigravity layouts)`);
+  slug = slug ?? defaultSlug(srcDir, ecosystems);
+  if (!/^[a-z0-9][a-z0-9._-]*$/.test(slug)) throw new Error(`invalid slug "${slug}": use lowercase letters, digits, ".", "_" and "-"`);
+  outDir = resolve(outDir);
+  if (existsSync(outDir) && readdirSync(outDir).length && !force) throw new Error(`${outDir} isn't empty (pass force to replace it)`);
+
+  const report = { slug, ecosystems, ported: [], unported: [], warnings: [], flags: [], tier: null, tierReasons: [] };
+  const workDir = mkdtempSync(join(tmpdir(), 'agy-porter-'));
+  try {
+    const pluginDir = join(workDir, 'plugin');
+    const stagedPaths = [];
+    if (ecosystems.includes('antigravity')) {
+      cpSync(srcDir, pluginDir, { recursive: true, filter: (p) => !/[\\/](\.git|node_modules)$/.test(p) });
+      report.ported.push('native plugin (copied as is)');
+    } else if (ecosystems.some((e) => AGY_STAGED.includes(e))) {
+      let stageFrom = srcDir;
+      if (detection.manifestless) {
+        // agy only detects Claude plugins by their manifest, so stage a copy with one.
+        stageFrom = join(workDir, 'src');
+        cpSync(srcDir, stageFrom, { recursive: true, filter: (p) => !/[\\/](\.git|node_modules)$/.test(p) });
+        mkdirSync(join(stageFrom, '.claude-plugin'));
+        writeFileSync(join(stageFrom, '.claude-plugin', 'plugin.json'), JSON.stringify({ name: slug }));
+        report.warnings.push('no .claude-plugin/plugin.json: ported as a Claude Code plugin from its default folders');
+      }
+      const staged = stageWithAgy(stageFrom, { agy, workDir });
+      // agy may write the resolved path (macOS /var -> /private/var, Windows 8.3 names).
+      stagedPaths.push(...new Set([staged, realpathSync.native(staged)]));
+      cpSync(staged, pluginDir, { recursive: true, filter: (p) => !/[\\/]\.git$/.test(p) });
+    } else {
+      mkdirSync(pluginDir);
+    }
+
+    if (!ecosystems.includes('antigravity')) {
+      merge(report, sanitizeManifest(pluginDir, { srcDir, ecosystems, slug, stagedPaths }));
+      const hooks = compileHooks(detection.hookSources, { slug });
+      writeHookPort(pluginDir, hooks);
+      merge(report, hooks.report);
+      // UI mods are reported, never copied: drop the module files agy staged.
+      for (const mod of detection.uiMods) {
+        const base = posix.dirname(mod.path.split('#')[0]);
+        for (const m of mod.modules) rmSync(join(pluginDir, posix.join(base, String(m))), { force: true });
+        const types = sourceManifest(srcDir, ecosystems).types;
+        if (typeof types === 'string') rmSync(join(pluginDir, types), { force: true });
+      }
+      merge(report, compileSkills(pluginDir, { srcDir, ecosystems }));
+      merge(report, compileRules(pluginDir, { srcDir, ecosystems }));
+      merge(report, compileModes(pluginDir, { srcDir, ecosystems, slug }));
+      removeEmptyDirs(pluginDir);
+    }
+
+    const audit = auditPlugin(pluginDir);
+    report.flags = audit.flags;
+    report.warnings.push(...audit.warnings);
+    report.tier = audit.tier;
+    report.tierReasons = audit.reasons;
+
+    rmSync(outDir, { recursive: true, force: true });
+    mkdirSync(outDir, { recursive: true });
+    cpSync(pluginDir, outDir, { recursive: true });
+    if (validate) report.validation = validateWithAgy(outDir, { agy, workDir });
+    return report;
+  } finally {
+    rmSync(workDir, { recursive: true, force: true });
+  }
+}
+
+// `agy plugin validate --json` in a throwaway home.
+export function validateWithAgy(pluginDir, { agy = 'agy', workDir } = {}) {
+  const ownDir = !workDir;
+  const dir = workDir ?? mkdtempSync(join(tmpdir(), 'agy-porter-validate-'));
+  const home = join(dir, 'validate-home');
+  mkdirSync(home, { recursive: true });
+  try {
+    const run = runAgy(['plugin', 'validate', pluginDir, '--json'], { agy, home });
+    let result = null;
+    try { result = JSON.parse(run.stdout); } catch {}
+    if (!result) return { ok: false, errors: [], warnings: [], output: (run.stdout + run.stderr).trim() };
+    const findings = result.findings ?? [];
+    return {
+      ok: run.status === 0,
+      components: result.components,
+      errors: findings.filter((f) => f.severity === 'error'),
+      warnings: findings.filter((f) => f.severity !== 'error'),
+    };
+  } finally {
+    if (ownDir) rmSync(dir, { recursive: true, force: true });
+  }
+}

package/lib/yaml-lite.mjs

@@ -0,0 +1,190 @@
+// A YAML subset, enough for Markdown frontmatter and `.roomodes`: block maps and
+// sequences, flow `[a, b]` / `{k: v}`, quoted and plain scalars, `|` / `>` block
+// scalars, multi-line plain scalars and comments. Anchors, tags and multiple
+// documents are not supported. Like agy's loader, it tolerates `: ` inside an
+// unquoted value (`description: Runs checks: lint`).
+
+const KEY = /^("(?:[^"\\]|\\.)*"|'(?:[^']|'')*'|[^\s"'#\-[{][^:#]*?|-[^\s:#][^:#]*?)\s*:(?=\s|$)/;
+
+function unquote(s) {
+  if (s.startsWith('"')) {
+    try { return JSON.parse(s); } catch { return s.slice(1, -1); }
+  }
+  if (s.startsWith("'")) return s.slice(1, -1).replace(/''/g, "'");
+  return s;
+}
+
+function stripComment(s) {
+  let quote = null;
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if (quote) {
+      if (c === quote && !(quote === '"' && s[i - 1] === '\\')) quote = null;
+    } else if (c === '"' || c === "'") {
+      if (i === 0 || /[\s[{,]/.test(s[i - 1])) quote = c;
+    } else if (c === '#' && (i === 0 || /\s/.test(s[i - 1]))) {
+      return s.slice(0, i).trimEnd();
+    }
+  }
+  return s;
+}
+
+function splitFlow(s) {
+  const parts = [];
+  let depth = 0;
+  let quote = null;
+  let start = 0;
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if (quote) { if (c === quote) quote = null; continue; }
+    if (c === '"' || c === "'") quote = c;
+    else if (c === '[' || c === '{') depth++;
+    else if (c === ']' || c === '}') depth--;
+    else if (c === ',' && depth === 0) { parts.push(s.slice(start, i)); start = i + 1; }
+  }
+  parts.push(s.slice(start));
+  return parts.map((p) => p.trim()).filter((p) => p !== '');
+}
+
+export function parseScalar(raw) {
+  const s = stripComment(raw.trim());
+  if (s === '') return null;
+  if (s.startsWith('"') || s.startsWith("'")) return unquote(s);
+  if (s.startsWith('[') && s.endsWith(']')) return splitFlow(s.slice(1, -1)).map(parseScalar);
+  if (s.startsWith('{') && s.endsWith('}')) {
+    const obj = {};
+    for (const part of splitFlow(s.slice(1, -1))) {
+      const m = KEY.exec(part);
+      if (m) obj[unquote(m[1])] = parseScalar(part.slice(m[0].length));
+    }
+    return obj;
+  }
+  if (/^(true|True|TRUE)$/.test(s)) return true;
+  if (/^(false|False|FALSE)$/.test(s)) return false;
+  if (/^(null|Null|NULL|~)$/.test(s)) return null;
+  if (/^[-+]?\d+(\.\d+)?$/.test(s)) return Number(s);
+  return s;
+}
+
+export function parseYaml(text) {
+  const lines = String(text).replace(/^/, '').replace(/\r\n?/g, '\n').split('\n')
+    .map((raw) => ({ raw, indent: raw.match(/^ */)[0].length, text: raw.trim() }));
+  let i = 0;
+  if (lines[0]?.text === '---') i = 1;
+  const blank = (l) => l.text === '' || l.text.startsWith('#');
+  const skip = () => { while (i < lines.length && blank(lines[i])) i++; };
+  const isSeq = (t) => t === '-' || t.startsWith('- ');
+
+  function blockScalar(header, parentIndent) {
+    const folded = header.startsWith('>');
+    const chomp = header.includes('-') ? 'strip' : header.includes('+') ? 'keep' : 'clip';
+    const body = [];
+    while (i < lines.length && (lines[i].text === '' || lines[i].indent > parentIndent)) body.push(lines[i++]);
+    const first = body.find((l) => l.text !== '');
+    const ind = first ? first.indent : 0;
+    const rows = body.map((l) => (l.text === '' ? '' : l.raw.slice(ind)));
+    let out;
+    if (folded) {
+      out = '';
+      rows.forEach((row, k) => {
+        if (k === 0) out = row;
+        else if (row === '' || rows[k - 1] === '' || /^\s/.test(row)) out += `\n${row}`;
+        else out += ` ${row}`;
+      });
+      out = out.replace(/\n(?=\n)/g, '');
+    } else out = rows.join('\n');
+    const trimmed = out.replace(/\n+$/, '');
+    if (chomp === 'strip') return trimmed;
+    if (chomp === 'keep') return out.endsWith('\n') ? out : `${out}\n`;
+    return trimmed === '' ? '' : `${trimmed}\n`;
+  }
+
+  // A value on the same line as its key or dash, with continuation lines for plain scalars.
+  function inlineValue(rest, indent) {
+    if (/^[|>][-+0-9]*$/.test(stripComment(rest))) return blockScalar(rest, indent);
+    const value = parseScalar(rest);
+    if (typeof value !== 'string' || /^["'[{]/.test(rest)) return value;
+    let joined = value;
+    while (i < lines.length && lines[i].text !== '' && lines[i].indent > indent && !KEY.test(lines[i].text) && !isSeq(lines[i].text)) {
+      joined += ` ${stripComment(lines[i++].text)}`;
+    }
+    return joined;
+  }
+
+  function node(indent) {
+    skip();
+    if (i >= lines.length || lines[i].indent < indent) return null;
+    return isSeq(lines[i].text) ? seq(lines[i].indent) : map(lines[i].indent);
+  }
+
+  function seq(indent) {
+    const items = [];
+    for (skip(); i < lines.length && lines[i].indent === indent && isSeq(lines[i].text); skip()) {
+      const line = lines[i];
+      const rest = line.text.slice(1).trimStart();
+      if (rest === '' || rest.startsWith('#')) { i++; items.push(node(indent + 1)); continue; }
+      if (isSeq(rest) || KEY.test(rest)) {
+        // `- - x` or `- key: v`: reparse the rest as a node at its own column.
+        const col = line.raw.indexOf(rest, line.indent + 1);
+        lines[i] = { raw: ' '.repeat(col) + rest, indent: col, text: rest };
+        items.push(node(col));
+        continue;
+      }
+      i++;
+      items.push(inlineValue(rest, indent));
+    }
+    return items;
+  }
+
+  function map(indent) {
+    const obj = {};
+    for (skip(); i < lines.length && lines[i].indent === indent; skip()) {
+      const m = KEY.exec(lines[i].text);
+      if (!m) throw new Error(`yaml: can't parse line ${i + 1}: ${lines[i].text}`);
+      const key = unquote(m[1].trim());
+      const rest = lines[i].text.slice(m[0].length).trim();
+      i++;
+      if (rest === '' || rest.startsWith('#')) {
+        skip();
+        const next = lines[i];
+        obj[key] = next && (next.indent > indent || (next.indent === indent && isSeq(next.text))) ? node(next.indent) : null;
+      } else obj[key] = inlineValue(rest, indent);
+    }
+    return obj;
+  }
+
+  const result = node(0);
+  skip();
+  if (i < lines.length && lines[i].text !== '---') throw new Error(`yaml: unexpected indentation at line ${i + 1}`);
+  return result;
+}
+
+// Splits `---\n<yaml>\n---\n<body>`. Returns {data, body, hasFrontmatter}.
+export function splitFrontmatter(text) {
+  const src = String(text).replace(/^/, '').replace(/\r\n?/g, '\n');
+  const m = /^---\n([\s\S]*?\n)?---[ \t]*(?:\n|$)/.exec(src);
+  if (!m) return { data: {}, body: src, hasFrontmatter: false };
+  return { data: parseYaml(m[1] ?? '') ?? {}, body: src.slice(m[0].length), hasFrontmatter: true };
+}
+
+function scalar(value) {
+  if (typeof value === 'boolean' || typeof value === 'number') return String(value);
+  const s = String(value);
+  const plain = /^[A-Za-z0-9_./*][^\n:#]*$/.test(s) && s === s.trim()
+    && !/^(true|false|null|yes|no|on|off|~|[-+]?\d+(\.\d+)?)$/i.test(s) && !/[[\]{},&*!|>'"%@`]/.test(s[0]);
+  return plain ? s : JSON.stringify(s);
+}
+
+// Writes frontmatter from plain values; arrays become block lists, null/undefined are skipped.
+export function formatFrontmatter(data, body) {
+  const lines = ['---'];
+  for (const [key, value] of Object.entries(data)) {
+    if (value === undefined || value === null) continue;
+    if (Array.isArray(value)) {
+      lines.push(value.length ? `${key}:` : `${key}: []`);
+      value.forEach((v) => lines.push(`  - ${scalar(v)}`));
+    } else lines.push(`${key}: ${scalar(value)}`);
+  }
+  lines.push('---', '');
+  return `${lines.join('\n')}${body.replace(/^\n+/, '\n')}`;
+}

package/package.json

@@ -1,6 +1,64 @@
 {
   "name": "agy-plugin-porter",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Ports Claude Code, Gemini CLI, Cursor, Roo/Kilo and Codex plugins to native Antigravity plugins.",
+  "type": "module",
+  "license": "MIT",
+  "author": {
+    "name": "Arthur Cavallari",
+    "url": "https://github.com/arthurcavallari"
+  },
+  "homepage": "https://github.com/arthurcavallari/agy-plugin-porter#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/arthurcavallari/agy-plugin-porter.git"
+  },
+  "bugs": {
+    "url": "https://github.com/arthurcavallari/agy-plugin-porter/issues"
+  },
+  "keywords": [
+    "antigravity",
+    "google-antigravity",
+    "agy",
+    "agy-plugin",
+    "antigravity-plugin",
+    "claude-code",
+    "claude-code-plugin",
+    "gemini-cli",
+    "cursor",
+    "roo-code",
+    "codex",
+    "plugin-porter",
+    "hooks",
+    "mcp"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "bin": {
+    "agy-porter": "bin/agy-porter.mjs"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "scripts/hook-shim.mjs",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": "./lib/index.mjs",
+    "./detector": "./lib/detector.mjs",
+    "./hook-compiler": "./lib/hook-compiler.mjs",
+    "./manifest-sanitizer": "./lib/manifest-sanitizer.mjs",
+    "./skill-compiler": "./lib/skill-compiler.mjs",
+    "./rules-compiler": "./lib/rules-compiler.mjs",
+    "./mode-compiler": "./lib/mode-compiler.mjs",
+    "./static-auditor": "./lib/static-auditor.mjs",
+    "./transpiler-engine": "./lib/transpiler-engine.mjs",
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "test": "node --test test/yaml-lite.test.mjs test/detector.test.mjs test/hook-compiler.test.mjs test/hook-shim.test.mjs test/compilers.test.mjs test/transpiler.test.mjs",
+    "test:pack": "node scripts/pack-smoke.mjs"
+  }
+}