enterprise-delivery 0.1.0

package/src/frontmatter.mjs

@@ -0,0 +1,121 @@
+export function parseFrontmatter(content) {
+  if (!content.startsWith('---\n')) {
+    return { data: {}, body: content };
+  }
+
+  const endIndex = content.indexOf('\n---\n', 4);
+  if (endIndex === -1) {
+    throw new Error('Frontmatter starts but does not close.');
+  }
+
+  const raw = content.slice(4, endIndex);
+  const body = content.slice(endIndex + 5);
+  return {
+    data: parseYamlSubset(raw),
+    body
+  };
+}
+
+function parseYamlSubset(raw) {
+  const data = {};
+  const lines = raw.split('\n');
+  let currentKey = null;
+  let currentMapKey = null;
+
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (line.trim() === '') {
+      continue;
+    }
+
+    if (!line.startsWith(' ')) {
+      currentMapKey = null;
+      const match = line.match(/^([A-Za-z0-9_-]+):(?:\s*(.*))?$/);
+      if (!match) {
+        throw new Error(`Unsupported frontmatter line: ${line}`);
+      }
+      currentKey = match[1];
+      const rawValue = match[2] ?? '';
+      if (rawValue === '') {
+        const nextLine = lines[index + 1] ?? '';
+        data[currentKey] = nextLine.startsWith('  - ') ? [] : {};
+      } else if (rawValue === '[]') {
+        data[currentKey] = [];
+      } else {
+        data[currentKey] = unquote(rawValue);
+      }
+      continue;
+    }
+
+    if (!currentKey) {
+      throw new Error(`Indented frontmatter value has no parent: ${line}`);
+    }
+
+    if (line.startsWith('  - ')) {
+      if (!Array.isArray(data[currentKey])) {
+        throw new Error(`Frontmatter key is not an array: ${currentKey}`);
+      }
+      const value = line.slice(4).trim();
+      if (/^[A-Za-z0-9_-]+:\s*.*$/.test(value)) {
+        throw new Error(`Unsupported array item: ${value}`);
+      }
+      data[currentKey].push(unquote(value));
+      continue;
+    }
+
+    if (line.startsWith('    - ') && currentMapKey) {
+      if (!isPlainMap(data[currentKey]) || !Array.isArray(data[currentKey][currentMapKey])) {
+        throw new Error(`Frontmatter key is not an array: ${currentKey}.${currentMapKey}`);
+      }
+      const value = line.slice(6).trim();
+      if (/^[A-Za-z0-9_-]+:\s*.*$/.test(value)) {
+        throw new Error(`Unsupported array item: ${value}`);
+      }
+      data[currentKey][currentMapKey].push(unquote(value));
+      continue;
+    }
+
+    if (line.startsWith('  ')) {
+      if (!isPlainMap(data[currentKey])) {
+        throw new Error(`Frontmatter key is not a map: ${currentKey}`);
+      }
+      const mapMatch = line.match(/^  ([A-Za-z0-9_-]+):(?:\s*(.*))?$/);
+      if (!mapMatch) {
+        throw new Error(`Unsupported frontmatter map line: ${line}`);
+      }
+      const mapKey = mapMatch[1];
+      const rawValue = mapMatch[2] ?? '';
+      if (rawValue === '') {
+        const nextLine = lines[index + 1] ?? '';
+        if (nextLine.startsWith('    - ')) {
+          data[currentKey][mapKey] = [];
+          currentMapKey = mapKey;
+        } else {
+          throw new Error(`Unsupported nested frontmatter under ${currentKey}.${mapKey}`);
+        }
+      } else {
+        data[currentKey][mapKey] = unquote(rawValue);
+        currentMapKey = null;
+      }
+      continue;
+    }
+
+    throw new Error(`Unsupported nested frontmatter line: ${line}`);
+  }
+
+  return data;
+}
+
+function isPlainMap(value) {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function unquote(value) {
+  if (value === '""') {
+    return '';
+  }
+  if (value.startsWith('"') && value.endsWith('"')) {
+    return value.slice(1, -1);
+  }
+  return value;
+}

package/src/init.mjs

@@ -0,0 +1,54 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
+const TEMPLATE_ROOT = path.resolve(MODULE_DIR, '..', 'templates', 'docs', 'enterprise');
+
+export function initializeEnterprise(rootDir) {
+  const created = [];
+  const skipped = [];
+
+  for (const templatePath of listTemplateFiles(TEMPLATE_ROOT)) {
+    const relativeTemplatePath = path.relative(TEMPLATE_ROOT, templatePath);
+    const targetRelativePath = path.join('docs', 'enterprise', relativeTemplatePath);
+    const targetPath = path.join(rootDir, targetRelativePath);
+
+    if (fs.existsSync(targetPath)) {
+      skipped.push(normalizePath(targetRelativePath));
+      continue;
+    }
+
+    fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+    fs.copyFileSync(templatePath, targetPath);
+    created.push(normalizePath(targetRelativePath));
+  }
+
+  return {
+    command: 'init',
+    target: normalizePath(path.resolve(rootDir)),
+    status: 'pass',
+    created,
+    skipped
+  };
+}
+
+function listTemplateFiles(directory) {
+  const entries = fs.readdirSync(directory, { withFileTypes: true });
+  const files = [];
+
+  for (const entry of entries) {
+    const entryPath = path.join(directory, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...listTemplateFiles(entryPath));
+    } else if (entry.isFile()) {
+      files.push(entryPath);
+    }
+  }
+
+  return files.sort();
+}
+
+function normalizePath(value) {
+  return value.split(path.sep).join('/');
+}

package/src/install-codex.mjs

@@ -0,0 +1,121 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
+const PACKAGE_ROOT = path.resolve(MODULE_DIR, '..');
+const PLUGIN_NAME = 'enterprise-delivery';
+const MARKETPLACE_ENTRY = {
+  name: PLUGIN_NAME,
+  source: {
+    source: 'local',
+    path: './plugins/enterprise-delivery'
+  },
+  policy: {
+    installation: 'AVAILABLE',
+    authentication: 'ON_INSTALL'
+  },
+  category: 'Coding'
+};
+const PAYLOAD_PATHS = [
+  '.codex-plugin',
+  'skills',
+  'scripts',
+  'src',
+  'templates',
+  'README.md',
+  'AGENTS.md',
+  'package.json'
+];
+
+export function installCodexPlugin(options = {}) {
+  const homeDir = options.homeDir || os.homedir();
+  if (!homeDir) {
+    throw new Error('Could not determine home directory for Codex plugin installation.');
+  }
+
+  const marketplaceRoot = path.join(homeDir, '.agents', 'plugins');
+  const pluginsRoot = path.join(marketplaceRoot, 'plugins');
+  const pluginDir = path.join(pluginsRoot, PLUGIN_NAME);
+  const marketplacePath = path.join(marketplaceRoot, 'marketplace.json');
+
+  fs.mkdirSync(pluginsRoot, { recursive: true });
+  fs.rmSync(pluginDir, { recursive: true, force: true });
+  fs.mkdirSync(pluginDir, { recursive: true });
+
+  for (const relativePath of PAYLOAD_PATHS) {
+    const sourcePath = path.join(PACKAGE_ROOT, relativePath);
+    if (!fs.existsSync(sourcePath)) {
+      continue;
+    }
+
+    const targetPath = path.join(pluginDir, relativePath);
+    fs.cpSync(sourcePath, targetPath, {
+      recursive: true,
+      force: true,
+      verbatimSymlinks: true
+    });
+  }
+
+  const marketplace = readMarketplace(marketplacePath);
+  marketplace.plugins = marketplace.plugins.filter((plugin) => plugin.name !== PLUGIN_NAME);
+  marketplace.plugins.push(MARKETPLACE_ENTRY);
+  writeJson(marketplacePath, marketplace);
+
+  return {
+    command: 'install',
+    adapter: 'codex',
+    status: 'pass',
+    pluginName: PLUGIN_NAME,
+    pluginDir: normalizePath(pluginDir),
+    marketplacePath: normalizePath(marketplacePath)
+  };
+}
+
+export function installClaudePlaceholder() {
+  return {
+    command: 'install',
+    adapter: 'claude',
+    status: 'pass',
+    implemented: false,
+    message: 'Claude adapter is planned but not implemented yet.'
+  };
+}
+
+function readMarketplace(marketplacePath) {
+  if (!fs.existsSync(marketplacePath)) {
+    return {
+      name: 'local-marketplace',
+      interface: {
+        displayName: 'Local Plugins'
+      },
+      plugins: []
+    };
+  }
+
+  const marketplace = JSON.parse(fs.readFileSync(marketplacePath, 'utf8'));
+  if (!marketplace.name) {
+    marketplace.name = 'local-marketplace';
+  }
+  if (!marketplace.interface || typeof marketplace.interface !== 'object') {
+    marketplace.interface = {};
+  }
+  if (!marketplace.interface.displayName) {
+    marketplace.interface.displayName = 'Local Plugins';
+  }
+  if (!Array.isArray(marketplace.plugins)) {
+    marketplace.plugins = [];
+  }
+
+  return marketplace;
+}
+
+function writeJson(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function normalizePath(value) {
+  return value.split(path.sep).join('/');
+}

package/src/markdown.mjs

@@ -0,0 +1,58 @@
+export function hasSection(markdown, heading) {
+  return findSectionStart(markdown, heading) !== -1;
+}
+
+export function sectionHasContent(markdown, heading) {
+  return getSection(markdown, heading).trim().length > 0;
+}
+
+export function getSection(markdown, heading) {
+  const lines = markdown.split('\n');
+  const start = findSectionStart(markdown, heading);
+
+  if (start === -1) {
+    return '';
+  }
+
+  const collected = [];
+  for (let index = start; index < lines.length; index += 1) {
+    if (isHeadingLine(lines[index])) {
+      break;
+    }
+    collected.push(lines[index]);
+  }
+
+  return collected.join('\n');
+}
+
+export function listIds(markdown, prefix) {
+  const expression = new RegExp(`\\b${escapeRegExp(prefix)}-[0-9]{4}\\b`, 'g');
+  const matches = markdown.match(expression);
+  return Array.from(new Set(matches ?? []));
+}
+
+export function containsNoImpactReason(markdown, heading) {
+  const section = getSection(markdown, heading).toLowerCase();
+  return section.includes('no impact') || section.includes('not applicable');
+}
+
+function findSectionStart(markdown, heading) {
+  const lines = markdown.split('\n');
+  const headingLine = `## ${heading}`;
+
+  for (let index = 0; index < lines.length; index += 1) {
+    if (isHeadingLine(lines[index]) && lines[index].trim() === headingLine) {
+      return index + 1;
+    }
+  }
+
+  return -1;
+}
+
+function isHeadingLine(line) {
+  return line.trim().startsWith('## ');
+}
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/src/repository.mjs

@@ -0,0 +1,59 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { parseFrontmatter } from './frontmatter.mjs';
+
+export function findArtifactById(rootDir, folder, id) {
+  const directory = path.join(rootDir, 'docs/enterprise', folder);
+  if (!fs.existsSync(directory)) {
+    return null;
+  }
+
+  const entries = fs.readdirSync(directory).filter((entry) => entry.endsWith('.md'));
+  for (const entry of entries) {
+    const absolutePath = path.join(directory, entry);
+    const content = fs.readFileSync(absolutePath, 'utf8');
+    if (!entry.startsWith(`${id}-`) && entry !== `${id}.md`) {
+      let parsed;
+      try {
+        parsed = parseFrontmatter(content);
+      } catch {
+        continue;
+      }
+      if (parsed.data.id !== id) {
+        continue;
+      }
+    }
+
+    try {
+      const parsed = parseFrontmatter(content);
+      return {
+        id,
+        path: absolutePath,
+        relativePath: path.relative(rootDir, absolutePath),
+        content,
+        data: parsed.data,
+        body: parsed.body
+      };
+    } catch (parseError) {
+      return {
+        id,
+        path: absolutePath,
+        relativePath: path.relative(rootDir, absolutePath),
+        content,
+        data: {},
+        body: '',
+        parseError
+      };
+    }
+  }
+
+  return null;
+}
+
+export function loadStory(rootDir, storyId) {
+  return findArtifactById(rootDir, 'stories', storyId);
+}
+
+export function loadChange(rootDir, changeId) {
+  return findArtifactById(rootDir, 'changes', changeId);
+}