@aiwg/cli 0.0.0-bootstrap.0 → 2026.7.17

package/dist/src/models/wrapper-deployment.js

@@ -0,0 +1,178 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { load as loadYaml } from 'js-yaml';
+import { MODEL_WRAPPERS } from './provider-models.js';
+const TIERS = {
+    reasoning: 'premium',
+    coding: 'standard',
+    efficiency: 'economy',
+};
+const EFFORTS = {
+    reasoning: 'high',
+    coding: 'medium',
+    efficiency: 'low',
+};
+const CLAUDE_ALIASES = {
+    reasoning: 'opus',
+    coding: 'sonnet',
+    efficiency: 'haiku',
+};
+async function collectFiles(root) {
+    const files = [];
+    async function walk(directory) {
+        let entries;
+        try {
+            entries = await fs.readdir(directory, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const item = path.join(directory, entry.name);
+            if (entry.isDirectory())
+                await walk(item);
+            else if (entry.isFile())
+                files.push(item);
+        }
+    }
+    await walk(root);
+    return files.sort();
+}
+function tomlFields(content) {
+    const fields = {};
+    for (const line of content.split(/\r?\n/)) {
+        const match = line.match(/^([A-Za-z0-9_.-]+)\s*=\s*"((?:\\.|[^"\\])*)"\s*$/);
+        if (!match)
+            continue;
+        try {
+            fields[match[1]] = JSON.parse(`"${match[2]}"`);
+        }
+        catch {
+            fields[match[1]] = match[2];
+        }
+    }
+    return fields;
+}
+function markdownFields(content) {
+    const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
+    if (!match)
+        return null;
+    const parsed = loadYaml(match[1]);
+    return parsed && typeof parsed === 'object' ? parsed : null;
+}
+function artifactFields(file, content) {
+    if (/\.toml$/i.test(file))
+        return tomlFields(content);
+    if (/\.json$/i.test(file)) {
+        try {
+            const parsed = JSON.parse(content);
+            return parsed && typeof parsed === 'object' ? parsed : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    if (/\.(?:md|yaml|yml)$/i.test(file))
+        return markdownFields(content);
+    return null;
+}
+function fieldValue(fields, ...names) {
+    for (const name of names) {
+        const value = fields[name];
+        if (typeof value === 'string' && value.trim())
+            return value.trim();
+    }
+    return undefined;
+}
+function addMismatch(mismatches, wrapper, file, field, reason, expected, actual) {
+    mismatches.push({
+        wrapper,
+        path: file,
+        field,
+        ...(expected !== undefined ? { expected } : {}),
+        ...(actual !== undefined ? { actual } : {}),
+        reason,
+    });
+}
+async function validateArtifact(file, role, expectation) {
+    const wrapper = MODEL_WRAPPERS[role];
+    const mismatches = [];
+    const content = await fs.readFile(file, 'utf8');
+    if (!content.trim()) {
+        addMismatch(mismatches, wrapper, file, 'content', 'wrapper artifact is empty');
+        return mismatches;
+    }
+    const fields = artifactFields(file, content);
+    if (!fields) {
+        addMismatch(mismatches, wrapper, file, 'format', 'wrapper artifact is malformed or has no parseable metadata');
+        return mismatches;
+    }
+    const actualName = fieldValue(fields, 'name');
+    if (actualName !== wrapper)
+        addMismatch(mismatches, wrapper, file, 'name', 'wrapper identity does not match its deployed filename', wrapper, actualName);
+    const actualRole = fieldValue(fields, 'model-role', 'modelRole', 'aiwg-model-role');
+    if (actualRole && actualRole !== role)
+        addMismatch(mismatches, wrapper, file, 'model-role', 'wrapper role is stale or mismatched', role, actualRole);
+    const actualTier = fieldValue(fields, 'model-tier', 'modelTier', 'aiwg-model-tier');
+    if (actualTier && actualTier !== TIERS[role])
+        addMismatch(mismatches, wrapper, file, 'model-tier', 'wrapper tier is stale or mismatched', TIERS[role], actualTier);
+    const actualModel = fieldValue(fields, 'model', 'model_hint', 'modelHint');
+    const expectedModel = expectation.models?.[role];
+    if (expectation.provider === 'codex') {
+        if (!actualModel)
+            addMismatch(mismatches, wrapper, file, 'model', 'Codex wrapper has no exact model pin', expectedModel);
+        else if (expectedModel && actualModel !== expectedModel)
+            addMismatch(mismatches, wrapper, file, 'model', 'Codex wrapper model does not match the effective catalog', expectedModel, actualModel);
+        const actualEffort = fieldValue(fields, 'model_reasoning_effort');
+        if (actualEffort !== EFFORTS[role])
+            addMismatch(mismatches, wrapper, file, 'model_reasoning_effort', 'Codex wrapper effort does not match its role', EFFORTS[role], actualEffort);
+        if (!fieldValue(fields, 'developer_instructions'))
+            addMismatch(mismatches, wrapper, file, 'developer_instructions', 'Codex wrapper has no bootstrap instructions', 'non-empty');
+    }
+    else if (expectation.provider === 'claude') {
+        const accepted = new Set([CLAUDE_ALIASES[role], expectedModel].filter(Boolean));
+        if (!actualModel || !accepted.has(actualModel))
+            addMismatch(mismatches, wrapper, file, 'model', 'Claude wrapper does not carry the semantic role alias or effective model', [...accepted].join(' or '), actualModel);
+        if (!actualRole)
+            addMismatch(mismatches, wrapper, file, 'model-role', 'Claude wrapper is missing its canonical role', role);
+        if (!actualTier)
+            addMismatch(mismatches, wrapper, file, 'model-tier', 'Claude wrapper is missing its canonical tier', TIERS[role]);
+    }
+    return mismatches;
+}
+export async function verifyModelWrapperDeployment(agentsPath, expectation = {}) {
+    const expected = Object.entries(MODEL_WRAPPERS);
+    if (!agentsPath)
+        return {
+            supported: false,
+            valid: false,
+            agentsPath: null,
+            found: [],
+            missing: expected.map(([, wrapper]) => wrapper),
+            mismatches: [],
+        };
+    const files = await collectFiles(agentsPath);
+    const found = [];
+    const missing = [];
+    const mismatches = [];
+    for (const [role, wrapper] of expected) {
+        const matches = files.filter(file => path.basename(file).replace(/\.(?:md|toml|json|yaml|yml)$/i, '') === wrapper);
+        if (matches.length === 0) {
+            missing.push(wrapper);
+            continue;
+        }
+        found.push(wrapper);
+        if (matches.length > 1)
+            addMismatch(mismatches, wrapper, matches[0], 'path', `multiple deployed wrapper artifacts found: ${matches.join(', ')}`);
+        mismatches.push(...await validateArtifact(matches[0], role, expectation));
+    }
+    return {
+        supported: true,
+        valid: missing.length === 0 && mismatches.length === 0,
+        agentsPath,
+        found,
+        missing,
+        mismatches,
+    };
+}
+//# sourceMappingURL=wrapper-deployment.js.map

package/dist/src/models/wrapper-route.js

@@ -0,0 +1,54 @@
+import { compileModelPolicy, } from './provider-policy.js';
+import { MODEL_WRAPPERS } from './provider-models.js';
+import { routeModelTier } from './router.js';
+function roleForTier(tier) {
+    if (tier === 'economy')
+        return 'efficiency';
+    if (tier === 'premium' || tier === 'max-quality')
+        return 'reasoning';
+    if (tier === 'standard')
+        return 'coding';
+    return null;
+}
+export function buildWrapperRouteEnvelope(request) {
+    if (!request.assignment.trim())
+        throw new Error('Wrapper routing requires a bounded assignment.');
+    const decision = routeModelTier(request);
+    const tier = decision.modelTier;
+    const role = roleForTier(tier);
+    const wrapper = role ? MODEL_WRAPPERS[role] : null;
+    const model = role && tier
+        ? compileModelPolicy({
+            provider: request.provider,
+            artifact: 'agent',
+            policy: { role, tier: tier === 'max-quality' ? 'premium' : tier },
+            ...(request.catalog ? { catalog: request.catalog } : {}),
+        })
+        : null;
+    const prompt = wrapper
+        ? [
+            `Run this assignment through ${wrapper}.`,
+            `Selected capability: ${request.capability.type} ${request.capability.name} (${request.capability.id}).`,
+            `Load it with aiwg show ${request.capability.type === 'workflow' ? 'metadata' : request.capability.type} ${request.capability.id} after discover-first validation.`,
+            `Assignment: ${request.assignment.trim()}`,
+            'Return capability evidence, changed artifacts, validation results, and remaining risks.',
+        ].join('\n')
+        : `No model call is required. Execute the deterministic assignment: ${request.assignment.trim()}`;
+    return {
+        version: 1,
+        provider: request.provider,
+        decision,
+        role,
+        tier,
+        wrapper,
+        capability: request.capability,
+        assignment: request.assignment.trim(),
+        model,
+        launch: {
+            mechanism: request.launchMechanism,
+            target: wrapper,
+            prompt,
+        },
+    };
+}
+//# sourceMappingURL=wrapper-route.js.map

package/dist/src/ops/cli.js

@@ -0,0 +1,268 @@
+/**
+ * Ops CLI — Subcommand router for `aiwg ops`
+ *
+ * Subcommands:
+ *   init              — Bootstrap a new ops workspace
+ *   status            — Show workspace health
+ *   use <workspace>   — Switch active workspace
+ *   list              — List registered workspaces
+ *   push              — Push workspace repos to remote
+ *
+ * @implements #544
+ */
+import { OpsRegistry } from './registry.js';
+/**
+ * Main CLI entry point for `aiwg ops <subcommand> [args]`
+ */
+export async function main(args) {
+    // Extract global flags
+    let configDir;
+    const filteredArgs = [];
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--config-dir' && i + 1 < args.length) {
+            configDir = args[i + 1];
+            i++;
+        }
+        else {
+            filteredArgs.push(args[i]);
+        }
+    }
+    const subcommand = filteredArgs[0];
+    const subArgs = filteredArgs.slice(1);
+    const registry = new OpsRegistry(configDir);
+    switch (subcommand) {
+        case 'init':
+            await handleInit(registry, subArgs);
+            break;
+        case 'status':
+            await handleStatus(registry, subArgs);
+            break;
+        case 'use':
+            await handleUse(registry, subArgs);
+            break;
+        case 'list':
+        case 'ls':
+            await handleList(registry);
+            break;
+        case 'push':
+            await handlePush(registry, subArgs);
+            break;
+        case 'discover':
+            await handleDiscover(registry, subArgs);
+            break;
+        case 'adopt':
+            await handleAdopt(registry, subArgs);
+            break;
+        default:
+            printUsage();
+            if (subcommand) {
+                throw new Error(`Unknown ops subcommand: ${subcommand}`);
+            }
+            break;
+    }
+}
+async function handleInit(registry, args) {
+    // Parse flags
+    let silent = false;
+    let workspace;
+    let home;
+    let mode = 'multi-repo';
+    let extensions = ['sys', 'it', 'dev'];
+    let prefix;
+    let provider;
+    let from;
+    for (let i = 0; i < args.length; i++) {
+        switch (args[i]) {
+            case '--silent':
+                silent = true;
+                break;
+            case '--workspace':
+                workspace = args[++i];
+                break;
+            case '--home':
+                home = args[++i];
+                break;
+            case '--mode':
+                mode = args[++i];
+                break;
+            case '--ext':
+                extensions = args[++i].split(',');
+                break;
+            case '--prefix':
+                prefix = args[++i];
+                break;
+            case '--provider':
+                provider = args[++i];
+                break;
+            case '--from':
+                from = args[++i];
+                break;
+        }
+    }
+    if (!workspace) {
+        workspace = 'default';
+    }
+    await registry.initWorkspace({
+        name: workspace,
+        home,
+        mode,
+        extensions,
+        prefix,
+        provider,
+        silent,
+        from,
+    });
+}
+async function handleAdopt(registry, args) {
+    let path;
+    let workspace;
+    let extensions;
+    let name;
+    let silent = false;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === '--workspace')
+            workspace = args[++i];
+        else if (a === '--ext')
+            extensions = args[++i].split(',');
+        else if (a === '--name')
+            name = args[++i];
+        else if (a === '--silent')
+            silent = true;
+        else if (!a.startsWith('--') && !path)
+            path = a;
+    }
+    if (!path) {
+        throw new Error('Usage: aiwg ops adopt <path> [--workspace <n>] [--ext <list>] [--name <n>]');
+    }
+    await registry.adoptRepo(path, { workspace, extensions, name, silent });
+}
+async function handleStatus(registry, args) {
+    const showAll = args.includes('--all');
+    await registry.showStatus(showAll);
+}
+async function handleUse(registry, args) {
+    const workspace = args[0];
+    if (!workspace) {
+        throw new Error('Usage: aiwg ops use <workspace>');
+    }
+    await registry.switchWorkspace(workspace);
+}
+async function handleList(registry) {
+    await registry.listWorkspaces();
+}
+async function handlePush(registry, args) {
+    let workspace;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--workspace') {
+            workspace = args[++i];
+        }
+    }
+    await registry.pushWorkspace(workspace);
+}
+async function handleDiscover(registry, args) {
+    const roots = [];
+    let maxDepth = 3;
+    let register = false;
+    let workspaceName = 'discovered';
+    let asJson = false;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === '--max-depth') {
+            maxDepth = Number(args[++i]);
+        }
+        else if (a === '--register' || a === '--yes' || a === '-y') {
+            register = true;
+        }
+        else if (a === '--workspace') {
+            workspaceName = args[++i];
+        }
+        else if (a === '--json') {
+            asJson = true;
+        }
+        else if (!a.startsWith('--')) {
+            roots.push(a);
+        }
+    }
+    const candidates = await registry.discoverWorkspaces({
+        roots: roots.length > 0 ? roots : undefined,
+        maxDepth,
+    });
+    if (asJson) {
+        console.log(JSON.stringify({ candidates }, null, 2));
+    }
+    else if (candidates.length === 0) {
+        console.log('No ops workspace candidates found.');
+    }
+    else {
+        console.log(`Found ${candidates.length} candidate(s):\n`);
+        console.log('  STATUS  NAME           REMOTE                                   PATH');
+        for (const c of candidates) {
+            const status = c.alreadyRegistered ? 'KNOWN ' : 'NEW   ';
+            const name = (c.name + ' '.repeat(14)).slice(0, 14);
+            const remote = (c.remote || '-').slice(0, 40).padEnd(40);
+            console.log(`  ${status}  ${name} ${remote} ${c.path}`);
+        }
+        console.log('');
+    }
+    if (register) {
+        const result = await registry.registerDiscovered(workspaceName, candidates);
+        console.log(`Registered ${result.added} new entr${result.added === 1 ? 'y' : 'ies'} ` +
+            `(skipped ${result.skipped} already-known) into workspace "${workspaceName}".`);
+    }
+    else if (candidates.some((c) => !c.alreadyRegistered)) {
+        console.log('Run with --register to add NEW candidates to the registry.');
+    }
+}
+function printUsage() {
+    console.log(`Usage: aiwg ops <subcommand> [options]
+
+Subcommands:
+  init                    Bootstrap a new ops workspace
+  status [--all]          Show workspace health
+  use <workspace>         Switch active workspace
+  list                    List registered workspaces
+  push [--workspace <n>]  Push workspace repos to remote
+  discover [root...]      Scan filesystem for orphaned ops-workspace clones
+  adopt <path>            Register an existing local clone as a repo entry
+
+Init options:
+  --silent                Skip interactive prompts
+  --workspace <name>      Workspace name (default: "default")
+  --home <path>           Parent directory for repos
+  --mode <mode>           single-repo or multi-repo (default: multi-repo)
+  --ext <list>            Comma-separated extensions: sys,it,dev,stream,repo-maintainer
+  --prefix <name>         Repo naming prefix (e.g., "myorg")
+  --provider <name>       Remote provider for auto-push (github, gitea, or URL)
+  --from <git-url>        Clone this URL into the target repo instead of init.
+                          Requires single-repo mode or exactly one --ext value.
+
+Global flags:
+  --config-dir <path>     Override config directory
+
+Examples:
+  aiwg ops init
+  aiwg ops init --silent --workspace personal --ext sys,dev
+  aiwg ops init --mode single-repo --workspace homelab
+  aiwg ops status
+  aiwg ops status --all
+  aiwg ops use client-acme
+  aiwg ops list
+  aiwg ops push --workspace personal
+  aiwg ops discover ~/projects ~/work --max-depth 4
+  aiwg ops discover --register --workspace home
+
+Discover options:
+  --max-depth <n>         Max walk depth from each root (default: 3)
+  --register              Write NEW candidates into the registry
+  --yes, -y               Alias for --register
+  --workspace <name>      Bucket workspace for registered entries (default: "discovered")
+  --json                  Machine-readable output
+
+Adopt options:
+  --workspace <name>      Workspace to attach to (default: "default")
+  --ext <list>            Comma-separated extensions for the adopted repo
+  --name <name>           Override repo name (default: basename of path)
+  --silent                Suppress informational logging`);
+}
+//# sourceMappingURL=cli.js.map