@kbediako/codex-orchestrator 0.1.1 → 0.1.3

package/dist/scripts/design/pipeline/context.js

@@ -3,13 +3,13 @@ import { mkdir } from 'node:fs/promises';
 import { loadDesignConfig, designPipelineId } from '../../../packages/shared/config/index.js';
 import { sanitizeTaskId } from '../../../orchestrator/src/persistence/sanitizeTaskId.js';
 import { sanitizeRunId } from '../../../orchestrator/src/persistence/sanitizeRunId.js';
+import { resolveEnvironmentPaths } from '../../lib/run-manifests.js';
 export async function loadDesignContext() {
-    const repoRoot = process.env.CODEX_ORCHESTRATOR_REPO_ROOT ?? process.cwd();
-    const runsRoot = process.env.CODEX_ORCHESTRATOR_RUNS_DIR ?? join(repoRoot, '.runs');
-    const outRoot = process.env.CODEX_ORCHESTRATOR_OUT_DIR ?? join(repoRoot, 'out');
+    const { repoRoot, runsRoot, outRoot } = resolveEnvironmentPaths();
     const taskId = sanitizeTaskId(process.env.CODEX_ORCHESTRATOR_TASK_ID ?? process.env.MCP_RUNNER_TASK_ID ?? 'unknown-task');
-    const runId = process.env.CODEX_ORCHESTRATOR_RUN_ID ?? 'run-local';
-    const runDir = process.env.CODEX_ORCHESTRATOR_RUN_DIR ?? join(runsRoot, taskId, sanitizeRunId(runId));
+    const rawRunId = process.env.CODEX_ORCHESTRATOR_RUN_ID ?? 'run-local';
+    const runId = sanitizeRunId(rawRunId);
+    const runDir = process.env.CODEX_ORCHESTRATOR_RUN_DIR ?? join(runsRoot, taskId, runId);
     const manifestPath = process.env.CODEX_ORCHESTRATOR_MANIFEST_PATH ?? join(runDir, 'manifest.json');
     const designConfigPath = process.env.DESIGN_CONFIG_PATH ?? join(repoRoot, 'design.config.yaml');
     const config = await loadDesignConfig({ rootDir: repoRoot, filePath: designConfigPath });

package/dist/scripts/design/pipeline/extract.js

@@ -4,7 +4,8 @@ import { tmpdir } from 'node:os';
 import { loadDesignContext } from './context.js';
 import { appendArtifacts, loadDesignRunState, saveDesignRunState, upsertStage } from './state.js';
 import { stageArtifacts } from '../../../orchestrator/src/persistence/ArtifactStager.js';
-import { loadPlaywright } from './optionalDeps.js';
+import { slugify as sharedSlugify } from '../../../packages/shared/utils/strings.js';
+import { loadPlaywright } from './optional-deps.js';
 async function main() {
     const context = await loadDesignContext();
     const state = await loadDesignRunState(context.statePath);
@@ -232,11 +233,13 @@ function defaultBreakpoints() {
     ];
 }
 function slugify(value) {
-    return value
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, '-')
-        .replace(/^-+|-+$/g, '')
-        .slice(0, 60) || 'capture';
+    return sharedSlugify(value, {
+        fallback: 'capture',
+        maxLength: 60,
+        lowercase: true,
+        pattern: /[^a-z0-9]+/g,
+        collapseDashes: true
+    });
 }
 function sanitizeSegment(value) {
     const slug = slugify(value);

package/dist/scripts/design/pipeline/{optionalDeps.js → optional-deps.js}

@@ -4,18 +4,17 @@ import { join } from 'node:path';
 import { pathToFileURL } from 'node:url';
 const DESIGN_SETUP_HINT = 'Run "npm run setup:design-tools" and "npx playwright install" to enable design tooling.';
 function isModuleNotFound(error) {
-    const candidate = error;
-    if (!candidate) {
+    if (!error) {
         return false;
     }
-    const message = candidate.message ?? '';
-    return (candidate.code === 'ERR_MODULE_NOT_FOUND' ||
-        candidate.code === 'MODULE_NOT_FOUND' ||
+    const message = error.message ?? '';
+    return (error.code === 'ERR_MODULE_NOT_FOUND' ||
+        error.code === 'MODULE_NOT_FOUND' ||
         message.includes('Cannot find package') ||
         message.includes('Cannot find module'));
 }
-function missingDependency(specifier) {
-    return new Error(`[design-tools] Missing optional dependency "${specifier}". ${DESIGN_SETUP_HINT}`);
+function missingDependency(specifier, label, hint) {
+    return new Error(`[${label}] Missing optional dependency "${specifier}". ${hint}`);
 }
 function resolveWithRequire(specifier, base) {
     try {
@@ -62,46 +61,58 @@ function toModuleUrl(resolved) {
     }
     return pathToFileURL(resolved).href;
 }
-async function loadOptionalDependency(specifier) {
+async function loadOptionalDependency(specifier, label, hint) {
     const resolved = resolveOptionalDependency(specifier);
     if (!resolved) {
-        throw missingDependency(specifier);
+        throw missingDependency(specifier, label, hint);
     }
     try {
-        return (await import(toModuleUrl(resolved)));
+        return await import(toModuleUrl(resolved));
     }
     catch (error) {
         if (isModuleNotFound(error)) {
-            throw missingDependency(specifier);
+            throw missingDependency(specifier, label, hint);
         }
         throw error;
     }
 }
-let playwrightPromise = null;
-let pngPromise = null;
-let pixelmatchPromise = null;
-let cheerioPromise = null;
-export async function loadPlaywright() {
-    if (!playwrightPromise) {
-        playwrightPromise = loadOptionalDependency('playwright');
-    }
-    return playwrightPromise;
-}
-export async function loadPngjs() {
-    if (!pngPromise) {
-        pngPromise = loadOptionalDependency('pngjs');
-    }
-    return pngPromise;
-}
-export async function loadPixelmatch() {
-    if (!pixelmatchPromise) {
-        pixelmatchPromise = loadOptionalDependency('pixelmatch');
-    }
-    return pixelmatchPromise;
-}
-export async function loadCheerio() {
-    if (!cheerioPromise) {
-        cheerioPromise = loadOptionalDependency('cheerio');
-    }
-    return cheerioPromise;
+export function createOptionalDependencyLoader({ label, hint }) {
+    let playwrightPromise = null;
+    let pngPromise = null;
+    let pixelmatchPromise = null;
+    let cheerioPromise = null;
+    return {
+        async loadPlaywright() {
+            if (!playwrightPromise) {
+                playwrightPromise = loadOptionalDependency('playwright', label, hint);
+            }
+            return playwrightPromise;
+        },
+        async loadPngjs() {
+            if (!pngPromise) {
+                pngPromise = loadOptionalDependency('pngjs', label, hint);
+            }
+            return pngPromise;
+        },
+        async loadPixelmatch() {
+            if (!pixelmatchPromise) {
+                pixelmatchPromise = loadOptionalDependency('pixelmatch', label, hint);
+            }
+            return pixelmatchPromise;
+        },
+        async loadCheerio() {
+            if (!cheerioPromise) {
+                cheerioPromise = loadOptionalDependency('cheerio', label, hint);
+            }
+            return cheerioPromise;
+        }
+    };
 }
+const designLoader = createOptionalDependencyLoader({
+    label: 'design-tools',
+    hint: DESIGN_SETUP_HINT
+});
+export const loadPlaywright = designLoader.loadPlaywright;
+export const loadPngjs = designLoader.loadPngjs;
+export const loadPixelmatch = designLoader.loadPixelmatch;
+export const loadCheerio = designLoader.loadCheerio;

package/dist/scripts/design/pipeline/permit.js

@@ -0,0 +1,59 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+export async function loadPermitFile(repoRoot) {
+    const permitPath = join(repoRoot, 'compliance', 'permit.json');
+    try {
+        const raw = await readFile(permitPath, 'utf8');
+        return { status: 'found', permit: JSON.parse(raw), path: permitPath, error: null };
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT') {
+            return { status: 'missing', permit: { allowedSources: [] }, path: permitPath, error: null };
+        }
+        return {
+            status: 'error',
+            permit: null,
+            path: permitPath,
+            error: error?.message ?? String(error)
+        };
+    }
+}
+export function buildAllowedOriginSet(permit) {
+    const allowed = new Set();
+    const sources = Array.isArray(permit?.allowedSources) ? permit.allowedSources : [];
+    for (const entry of sources) {
+        if (!entry || typeof entry.origin !== 'string') {
+            continue;
+        }
+        try {
+            allowed.add(new URL(entry.origin).origin);
+        }
+        catch {
+            continue;
+        }
+    }
+    return allowed;
+}
+export function findPermitEntry(permit, origin) {
+    const sources = Array.isArray(permit?.allowedSources) ? permit.allowedSources : [];
+    let originKey = origin;
+    try {
+        originKey = new URL(origin).origin;
+    }
+    catch {
+        // ignore invalid origin
+    }
+    return (sources.find((entry) => entry?.origin === originKey) ??
+        sources.find((entry) => {
+            if (!entry?.origin) {
+                return false;
+            }
+            try {
+                return new URL(entry.origin).origin === originKey;
+            }
+            catch {
+                return false;
+            }
+        }) ??
+        null);
+}

package/dist/scripts/design/pipeline/toolkit/common.js

@@ -1,31 +1,18 @@
-import { readFile } from 'node:fs/promises';
-import { join } from 'node:path';
+import { buildAllowedOriginSet, loadPermitFile } from '../permit.js';
+import { slugify as sharedSlugify } from '../../../../packages/shared/utils/strings.js';
 export async function loadToolkitPermit(repoRoot) {
-    const permitPath = join(repoRoot, 'compliance', 'permit.json');
-    try {
-        const raw = await readFile(permitPath, 'utf8');
-        return JSON.parse(raw);
+    const permitResult = await loadPermitFile(repoRoot);
+    if (permitResult.status === 'missing') {
+        console.warn('[design-toolkit] compliance/permit.json not found; proceeding without permit enforcement');
+        return { allowedSources: [] };
     }
-    catch (error) {
-        const nodeError = error;
-        if (nodeError?.code === 'ENOENT') {
-            console.warn('[design-toolkit] compliance/permit.json not found; proceeding without permit enforcement');
-            return { allowedSources: [] };
-        }
-        throw error;
+    if (permitResult.status === 'error') {
+        throw new Error(permitResult.error ?? 'Unable to read compliance/permit.json');
     }
+    return permitResult.permit ?? { allowedSources: [] };
 }
 export function ensureSourcePermitted(url, permit) {
-    const allowed = new Set((permit.allowedSources ?? [])
-        .map((entry) => {
-        try {
-            return new URL(entry.origin).origin;
-        }
-        catch {
-            return null;
-        }
-    })
-        .filter((origin) => Boolean(origin)));
+    const allowed = buildAllowedOriginSet(permit);
     const origin = new URL(url).origin;
     if (allowed.size === 0 || allowed.has(origin)) {
         return true;
@@ -64,15 +51,14 @@ export function buildRetentionMetadata(retention, now) {
     };
 }
 export function slugifyToolkitValue(value, index) {
-    const normalized = value
-        .toLowerCase()
-        .replace(/[^a-z0-9-_]+/g, '-')
-        .replace(/^-+|-+$/g, '')
-        .slice(0, 48);
-    if (normalized.length > 0) {
-        return normalized;
-    }
-    return `source-${index + 1}`;
+    const normalized = sharedSlugify(value, {
+        fallback: '',
+        maxLength: 48,
+        lowercase: true,
+        pattern: /[^a-z0-9-_]+/g,
+        collapseDashes: false
+    });
+    return normalized.length > 0 ? normalized : `source-${index + 1}`;
 }
 function defaultBreakpoints() {
     return [

package/dist/scripts/design/pipeline/toolkit/reference.js

@@ -2,7 +2,7 @@ import { access, cp, mkdir, readFile, readdir, symlink, writeFile } from 'node:f
 import { dirname, isAbsolute, join, relative } from 'node:path';
 import { tmpdir } from 'node:os';
 import { pathToFileURL } from 'node:url';
-import { loadPixelmatch, loadPlaywright, loadPngjs } from '../optionalDeps.js';
+import { loadPixelmatch, loadPlaywright, loadPngjs } from '../optional-deps.js';
 import { loadDesignContext } from '../context.js';
 import { appendApprovals, appendToolkitArtifacts, ensureToolkitState, loadDesignRunState, saveDesignRunState, upsertStage, upsertToolkitContext } from '../state.js';
 import { stageArtifacts } from '../../../../orchestrator/src/persistence/ArtifactStager.js';

package/dist/scripts/design/pipeline/toolkit/snapshot.js

@@ -1,5 +1,5 @@
 import { Buffer } from 'node:buffer';
-import { loadCheerio, loadPlaywright } from '../optionalDeps.js';
+import { loadCheerio, loadPlaywright } from '../optional-deps.js';
 const DEFAULT_MAX_STYLESHEETS = 24;
 const DEFAULT_VIEWPORT = { width: 1440, height: 900 };
 const USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36';

package/dist/scripts/design/pipeline/visual-regression.js

@@ -1,11 +1,11 @@
 import { spawn } from 'node:child_process';
-import { access, mkdir, readFile, writeFile } from 'node:fs/promises';
-import { constants } from 'node:fs';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { join, relative } from 'node:path';
 import { tmpdir } from 'node:os';
 import { loadDesignContext } from './context.js';
 import { appendArtifacts, loadDesignRunState, saveDesignRunState, upsertStage } from './state.js';
 import { stageArtifacts } from '../../../orchestrator/src/persistence/ArtifactStager.js';
+import { pathExists } from '../../lib/docs-helpers.js';
 const DESIGN_SYSTEM_DIR = 'packages/design-system';
 const SUMMARY_FILE = join(DESIGN_SYSTEM_DIR, '.codex', 'visual-regression-summary.json');
 async function main() {
@@ -75,15 +75,6 @@ async function main() {
     const statusText = exitCode === 0 ? 'passed' : 'failed';
     console.log(`[design-visual-regression] ${statusText}; summary staged at ${staged.path}`);
 }
-async function pathExists(path) {
-    try {
-        await access(path, constants.F_OK);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
 async function runVisualRegression() {
     return new Promise((resolve) => {
         const child = spawn('npm', ['--prefix', DESIGN_SYSTEM_DIR, 'run', 'test:visual'], {

package/dist/scripts/lib/cli-args.js

@@ -0,0 +1,53 @@
+export function parseArgs(argv) {
+    const args = {};
+    const positionals = [];
+    const entries = [];
+    for (let index = 0; index < argv.length; index += 1) {
+        const raw = argv[index];
+        if (!raw) {
+            continue;
+        }
+        if (raw === '--') {
+            positionals.push(...argv.slice(index + 1));
+            break;
+        }
+        if (!raw.startsWith('-')) {
+            positionals.push(raw);
+            continue;
+        }
+        const cleaned = raw.replace(/^--?/, '');
+        if (!cleaned) {
+            continue;
+        }
+        const [key, inlineValue] = cleaned.split('=');
+        if (inlineValue !== undefined) {
+            args[key] = inlineValue;
+            entries.push({ key, value: inlineValue });
+            continue;
+        }
+        const next = argv[index + 1];
+        if (next && !next.startsWith('-')) {
+            args[key] = next;
+            entries.push({ key, value: next });
+            index += 1;
+        }
+        else {
+            args[key] = true;
+            entries.push({ key, value: true });
+        }
+    }
+    return { args, positionals, entries };
+}
+export function hasFlag(args, key) {
+    const value = args[key];
+    if (value === undefined) {
+        return false;
+    }
+    if (value === false) {
+        return false;
+    }
+    if (value === 'false' || value === '0') {
+        return false;
+    }
+    return true;
+}

package/dist/scripts/lib/docs-helpers.js

@@ -0,0 +1,111 @@
+import { access, readdir } from 'node:fs/promises';
+import path from 'node:path';
+const DOC_ROOTS = ['.agent', '.ai-dev-tasks', 'docs', 'tasks'];
+const DOC_ROOT_FILES = ['README.md', 'AGENTS.md'];
+const EXCLUDED_DIR_NAMES = new Set(['.runs', 'out', 'archives', 'node_modules', 'dist']);
+export async function pathExists(target, options = {}) {
+    const { allowMissingOnly = false } = options;
+    try {
+        await access(target);
+        return true;
+    }
+    catch (error) {
+        if (allowMissingOnly && error?.code !== 'ENOENT') {
+            throw error;
+        }
+        return false;
+    }
+}
+export function toPosixPath(value) {
+    return value.split(path.sep).join('/');
+}
+export async function collectMarkdownFiles(repoRoot, relativeDir) {
+    const absDir = path.join(repoRoot, relativeDir);
+    const entries = await readdir(absDir, { withFileTypes: true });
+    const results = [];
+    for (const entry of entries) {
+        const relPath = path.join(relativeDir, entry.name);
+        if (entry.isDirectory()) {
+            if (EXCLUDED_DIR_NAMES.has(entry.name)) {
+                continue;
+            }
+            results.push(...(await collectMarkdownFiles(repoRoot, relPath)));
+            continue;
+        }
+        if (entry.isFile() && entry.name.toLowerCase().endsWith('.md')) {
+            results.push(toPosixPath(relPath));
+        }
+    }
+    return results;
+}
+export async function collectDocFiles(repoRoot) {
+    const results = [];
+    for (const file of DOC_ROOT_FILES) {
+        const abs = path.join(repoRoot, file);
+        if (await pathExists(abs)) {
+            results.push(toPosixPath(file));
+        }
+    }
+    for (const dir of DOC_ROOTS) {
+        const abs = path.join(repoRoot, dir);
+        if (await pathExists(abs)) {
+            results.push(...(await collectMarkdownFiles(repoRoot, dir)));
+        }
+    }
+    results.sort();
+    return results;
+}
+export function normalizeTaskKey(item) {
+    if (!item || typeof item !== 'object') {
+        return null;
+    }
+    const id = typeof item.id === 'string' ? item.id.trim() : '';
+    const slug = typeof item.slug === 'string' ? item.slug.trim() : '';
+    if (slug && id && slug.startsWith(`${id}-`)) {
+        return slug;
+    }
+    if (id && slug) {
+        return `${id}-${slug}`;
+    }
+    if (slug) {
+        return slug;
+    }
+    if (id) {
+        return id;
+    }
+    return null;
+}
+export function parseDateString(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const match = value.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+    if (!match) {
+        return null;
+    }
+    return value;
+}
+export function parseIsoDate(raw) {
+    const normalized = parseDateString(raw);
+    if (!normalized) {
+        return null;
+    }
+    const [yearStr, monthStr, dayStr] = normalized.split('-');
+    const year = Number(yearStr);
+    const month = Number(monthStr) - 1;
+    const day = Number(dayStr);
+    const date = new Date(Date.UTC(year, month, day));
+    if (Number.isNaN(date.getTime())) {
+        return null;
+    }
+    if (date.getUTCFullYear() !== year ||
+        date.getUTCMonth() !== month ||
+        date.getUTCDate() !== day) {
+        return null;
+    }
+    return date;
+}
+export function computeAgeInDays(from, to) {
+    const msPerDay = 24 * 60 * 60 * 1000;
+    return Math.floor((to.getTime() - from.getTime()) / msPerDay);
+}

package/dist/scripts/lib/npm-pack.js

@@ -0,0 +1,20 @@
+import { execFile } from 'node:child_process';
+import process from 'node:process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+export async function runPack() {
+    const { stdout } = await execFileAsync('npm', ['pack', '--json', '--ignore-scripts'], {
+        env: { ...process.env, npm_config_ignore_scripts: 'true' },
+        maxBuffer: 10 * 1024 * 1024
+    });
+    const trimmed = String(stdout ?? '').trim();
+    if (!trimmed) {
+        throw new Error('npm pack produced no output');
+    }
+    const parsed = JSON.parse(trimmed);
+    const record = Array.isArray(parsed) ? parsed[0] : parsed;
+    if (!record || typeof record !== 'object') {
+        throw new Error('npm pack output did not include a record');
+    }
+    return record;
+}