eai-cli 0.0.0-bootstrap.0

package/resources/gofer/node-scripts/parse-stage-command.mjs

@@ -0,0 +1,211 @@
+/**
+ * parse-stage-command.mjs
+ * Parses a .specify/commands/<stage>.md file with YAML frontmatter.
+ * Uses a minimal inline YAML parser (no external deps required).
+ */
+
+import { readFile } from 'fs/promises';
+
+/**
+ * Minimal YAML parser for stage-command frontmatter.
+ * Handles:
+ *   - string scalars: `key: value`
+ *   - quoted strings: `key: "value"` or `key: 'value'`
+ *   - block sequences (arrays): `key:\n  - item`
+ *   - inline sequences: `key: [a, b, c]`
+ *   - boolean: `key: true` / `key: false`
+ *
+ * @param {string} yaml Raw YAML text
+ * @returns {Record<string, unknown>}
+ */
+function parseMinimalYaml(yaml) {
+  const result = {};
+  const lines = yaml.split('\n');
+  let i = 0;
+
+  while (i < lines.length) {
+    const line = lines[i];
+
+    // Skip blank lines and comments
+    if (!line.trim() || line.trim().startsWith('#')) {
+      i++;
+      continue;
+    }
+
+    // Key: value pair (top-level only — sufficient for frontmatter)
+    const keyMatch = line.match(/^([a-zA-Z_][a-zA-Z0-9_-]*):\s*(.*)/);
+    if (!keyMatch) {
+      i++;
+      continue;
+    }
+
+    const key = keyMatch[1];
+    const rest = keyMatch[2].trim();
+
+    // Inline array: key: [a, b, c]
+    if (rest.startsWith('[')) {
+      const inner = rest.slice(1, rest.lastIndexOf(']'));
+      result[key] = inner
+        .split(',')
+        .map((s) => s.trim().replace(/^["']|["']$/g, ''))
+        .filter(Boolean);
+      i++;
+      continue;
+    }
+
+    // Empty value → check for block sequence on next lines
+    if (rest === '' || rest === null) {
+      const items = [];
+      i++;
+      while (i < lines.length && lines[i].match(/^\s+-\s+/)) {
+        const item = lines[i].replace(/^\s+-\s+/, '').trim().replace(/^["']|["']$/g, '');
+        items.push(item);
+        i++;
+      }
+      result[key] = items.length > 0 ? items : '';
+      continue;
+    }
+
+    // Boolean
+    if (rest === 'true') { result[key] = true; i++; continue; }
+    if (rest === 'false') { result[key] = false; i++; continue; }
+
+    // Quoted string
+    if ((rest.startsWith('"') && rest.endsWith('"')) ||
+        (rest.startsWith("'") && rest.endsWith("'"))) {
+      result[key] = rest.slice(1, -1);
+      i++;
+      continue;
+    }
+
+    // Plain scalar
+    result[key] = rest;
+    i++;
+  }
+
+  return result;
+}
+
+function toCanonicalCommandName(fileStem) {
+  if (fileStem.includes(':')) {
+    return fileStem;
+  }
+
+  if (fileStem === 'gofer_constitution' || fileStem === 'gofer_hydrate') {
+    return fileStem;
+  }
+
+  if (fileStem.startsWith('gofer_')) {
+    return `gofer:${fileStem.slice('gofer_'.length).replace(/_/g, '-')}`;
+  }
+
+  return fileStem;
+}
+
+/**
+ * Performs structural validation of a parsed frontmatter object.
+ * Throws if required fields are missing or have wrong types.
+ *
+ * @param {Record<string, unknown>} fm Parsed frontmatter
+ * @param {string} filePath Source file path (for error messages)
+ */
+function validateFrontmatter(fm, filePath) {
+  const required = ['name', 'description', 'title', 'surfaces', 'category'];
+  for (const field of required) {
+    if (fm[field] === undefined || fm[field] === null || fm[field] === '') {
+      throw new Error(`Missing required frontmatter field '${field}' in ${filePath}`);
+    }
+  }
+
+  if (typeof fm.name !== 'string') {
+    throw new Error(`'name' must be a string in ${filePath}`);
+  }
+  if (!/^(?:[0-9]+[a-z]?_[a-z0-9_]+|gofer_[a-z0-9_]+|gofer:[a-z0-9-]+)$/.test(fm.name)) {
+    throw new Error(`'name' contains invalid characters in ${filePath}`);
+  }
+  if (typeof fm.description !== 'string') {
+    throw new Error(`'description' must be a string in ${filePath}`);
+  }
+  if (fm.description.length > 140) {
+    throw new Error(`'description' exceeds 140 chars in ${filePath}`);
+  }
+  if (typeof fm.title !== 'string') {
+    throw new Error(`'title' must be a string in ${filePath}`);
+  }
+  if (!Array.isArray(fm.surfaces) || fm.surfaces.length === 0) {
+    throw new Error(`'surfaces' must be a non-empty array in ${filePath}`);
+  }
+
+  const validSurfaces = new Set([
+    'claude', 'claude-mirror', 'copilot', 'vscode', 'codex',
+    'gemini', 'github-prompts', 'agents-skills', 'system-skills',
+  ]);
+  for (const s of fm.surfaces) {
+    if (!validSurfaces.has(s)) {
+      throw new Error(`Invalid surface '${s}' in ${filePath}`);
+    }
+  }
+
+  const validCategories = new Set(['pipeline', 'utility', 'diagnostic', 'control']);
+  if (!validCategories.has(fm.category)) {
+    throw new Error(`Invalid category '${fm.category}' in ${filePath}`);
+  }
+
+  const fileStem = (filePath.split(/[\\/]/).pop() || '').replace(/\.md$/, '');
+  const expectedName = toCanonicalCommandName(fileStem);
+  if (fm.name !== expectedName) {
+    throw new Error(
+      `'name' must match canonical command id '${expectedName}' for ${filePath}`
+    );
+  }
+}
+
+/**
+ * Parses a stage command markdown file.
+ *
+ * The file format is:
+ * ```
+ * ---
+ * name: stage_name
+ * description: "Short description"
+ * title: "Human title"
+ * surfaces:
+ *   - claude
+ *   - codex
+ * category: pipeline
+ * ---
+ *
+ * Markdown body content here...
+ * ```
+ *
+ * @param {string} filePath Absolute or relative path to the .md file
+ * @returns {Promise<{ frontmatter: Record<string, unknown>, body: string }>}
+ */
+export async function parseStageCommand(filePath) {
+  const raw = await readFile(filePath, 'utf8');
+
+  // Must start with ---
+  if (!raw.startsWith('---')) {
+    throw new Error(`File does not start with frontmatter fence '---': ${filePath}`);
+  }
+
+  // Find the closing --- after the opening
+  const afterOpen = raw.slice(3); // skip first ---
+  // Handle both \r\n and \n
+  const closeIdx = afterOpen.search(/\r?\n---(\r?\n|$)/);
+  if (closeIdx === -1) {
+    throw new Error(`No closing frontmatter fence found in ${filePath}`);
+  }
+
+  const yamlText = afterOpen.slice(0, closeIdx).replace(/^\r?\n/, '');
+
+  // Find where the body starts (after closing --- line)
+  const closingFenceMatch = afterOpen.match(/\r?\n---(\r?\n|$)/);
+  const bodyStart = 3 /* opening --- */ + closeIdx + closingFenceMatch[0].length;
+  const body = raw.slice(bodyStart);
+
+  const frontmatter = parseMinimalYaml(yamlText);
+  validateFrontmatter(frontmatter, filePath);
+
+  return { frontmatter, body };
+}

package/resources/gofer/node-scripts/schemas/stage-command.schema.json

@@ -0,0 +1,72 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "stage-command.schema.json",
+  "title": "StageCommand",
+  "description": "Schema for Gofer stage command definitions",
+  "type": "object",
+  "required": ["name", "description", "title", "surfaces", "category", "body"],
+  "additionalProperties": true,
+  "properties": {
+    "name": {
+      "type": "string",
+      "description": "Stage identifier, e.g. '0_gofer_start'"
+    },
+    "description": {
+      "type": "string",
+      "description": "Short description shown to Codex (≤140 chars)",
+      "maxLength": 140
+    },
+    "title": {
+      "type": "string",
+      "description": "Human-readable title for the stage"
+    },
+    "surfaces": {
+      "type": "array",
+      "description": "Target surfaces where this command is emitted",
+      "items": {
+        "type": "string",
+        "enum": [
+          "claude",
+          "claude-mirror",
+          "copilot",
+          "vscode",
+          "codex",
+          "gemini",
+          "github-prompts",
+          "agents-skills",
+          "system-skills"
+        ]
+      },
+      "minItems": 1,
+      "uniqueItems": true
+    },
+    "category": {
+      "type": "string",
+      "description": "Command category",
+      "enum": ["pipeline", "utility", "diagnostic", "control"]
+    },
+    "args": {
+      "type": "object",
+      "description": "Optional map of arg-name to arg-definition",
+      "additionalProperties": {
+        "type": "object",
+        "properties": {
+          "description": { "type": "string" },
+          "required": { "type": "boolean" },
+          "default": {}
+        }
+      }
+    },
+    "includes": {
+      "type": "array",
+      "description": "Optional relative paths to include",
+      "items": {
+        "type": "string"
+      }
+    },
+    "body": {
+      "type": "string",
+      "description": "The markdown body content of the command"
+    }
+  }
+}

package/resources/gofer/node-scripts/sync-extension-resources.mjs

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+
+import { promises as fs } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const REPO_ROOT = path.resolve(__dirname, '..', '..', '..');
+const IS_DIRECT_RUN = process.argv[1] ? path.resolve(process.argv[1]) === __filename : false;
+
+const SYNC_PAIRS = [
+  ['.claude/commands', 'extension/resources/claude-commands'],
+  ['.claude/agents', 'extension/resources/claude-agents'],
+  ['.claude/skills', 'extension/resources/claude-skills'],
+  ['.github/agents', 'extension/resources/github-agents'],
+  ['.github/prompts', 'extension/resources/copilot-prompts'],
+  ['.github/instructions', 'extension/resources/copilot-instructions'],
+  ['.github/skills', 'extension/resources/github-skills'],
+  ['.gemini', 'extension/resources/gemini'],
+  ['.specify/commands', 'extension/resources/specify-commands'],
+  ['.specify/references', 'extension/resources/references'],
+  ['.specify/scripts/bash', 'extension/resources/bash-scripts'],
+  ['.specify/scripts/powershell', 'extension/resources/powershell-scripts'],
+  ['.specify/scripts/node', 'extension/resources/node-scripts'],
+  ['.specify/scripts/hooks', 'extension/resources/hook-scripts'],
+  ['.specify/templates', 'extension/resources/templates'],
+];
+
+function isNodeErrorWithCode(error) {
+  return typeof error === 'object' && error !== null && 'code' in error;
+}
+
+export async function pathExists(targetPath) {
+  try {
+    await fs.access(targetPath);
+    return true;
+  } catch (error) {
+    if (isNodeErrorWithCode(error) && error.code === 'ENOENT') {
+      return false;
+    }
+    throw error;
+  }
+}
+
+async function copyFileWithMode(sourcePath, targetPath) {
+  await fs.mkdir(path.dirname(targetPath), { recursive: true });
+  await fs.copyFile(sourcePath, targetPath);
+  const sourceStat = await fs.stat(sourcePath);
+  await fs.chmod(targetPath, sourceStat.mode);
+}
+
+async function syncDirectory(sourcePath, targetPath) {
+  if (!(await pathExists(sourcePath))) {
+    console.log(`i skip: ${sourcePath} does not exist`);
+    return;
+  }
+
+  await fs.mkdir(targetPath, { recursive: true });
+
+  const sourceEntries = await fs.readdir(sourcePath, { withFileTypes: true });
+  const sourceNames = new Set(sourceEntries.map((entry) => entry.name));
+
+  if (await pathExists(targetPath)) {
+    const targetEntries = await fs.readdir(targetPath, { withFileTypes: true });
+    await Promise.all(
+      targetEntries
+        .filter((entry) => !sourceNames.has(entry.name))
+        .map((entry) =>
+          fs.rm(path.join(targetPath, entry.name), { recursive: true, force: true })
+        )
+    );
+  }
+
+  for (const entry of sourceEntries) {
+    const sourceEntryPath = path.join(sourcePath, entry.name);
+    const targetEntryPath = path.join(targetPath, entry.name);
+
+    if (entry.isDirectory()) {
+      await syncDirectory(sourceEntryPath, targetEntryPath);
+      continue;
+    }
+
+    await copyFileWithMode(sourceEntryPath, targetEntryPath);
+  }
+}
+
+export async function main() {
+  const codexFragmentPath = path.join(REPO_ROOT, '.specify', 'outputs', 'codex-config-fragment.toml');
+  const codexConfigPath = path.join(REPO_ROOT, 'codex-config.toml');
+  await copyFileWithMode(codexFragmentPath, codexConfigPath);
+
+  console.log('i Syncing canonical sources into extension/resources/ ...');
+  for (const [sourceRelativePath, targetRelativePath] of SYNC_PAIRS) {
+    await syncDirectory(
+      path.join(REPO_ROOT, sourceRelativePath),
+      path.join(REPO_ROOT, targetRelativePath)
+    );
+    console.log(`✓ synced ${sourceRelativePath} → ${targetRelativePath}`);
+  }
+
+  console.log('✓ extension/resources/ is in sync with canonical sources');
+}
+
+if (IS_DIRECT_RUN) {
+  main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  });
+}