@baselineos/cli 0.1.0

package/src/badge.ts

@@ -0,0 +1,88 @@
+/**
+ * "Baseline-governed" Trust Signal Badge Generator
+ *
+ * Generates a machine-readable trust signal that can be embedded
+ * in applications, documents, or registries to indicate that
+ * AI operations are governed by Baseline Protocol.
+ */
+
+import { createHash } from 'node:crypto';
+
+export interface BadgeData {
+  version: string;
+  governedBy: 'baseline-protocol';
+  standards: string[];
+  verificationHash: string;
+  issuedAt: string;
+  expiresAt: string;
+  issuer: string;
+  subject: string;
+}
+
+export interface BadgeOptions {
+  subject: string;
+  issuer?: string;
+  standards?: string[];
+  validityDays?: number;
+  verificationHash?: string;
+}
+
+export function generateBadge(options: BadgeOptions): BadgeData {
+  const now = new Date();
+  const validityDays = options.validityDays ?? 90;
+  const expiresAt = new Date(now.getTime() + validityDays * 86_400_000);
+
+  const hashInput = [
+    options.subject,
+    options.issuer ?? 'self',
+    ...(options.standards ?? []),
+    now.toISOString(),
+  ].join('|');
+
+  const verificationHash = options.verificationHash ??
+    createHash('sha256').update(hashInput).digest('hex').slice(0, 32);
+
+  return {
+    version: '1.0.0',
+    governedBy: 'baseline-protocol',
+    standards: options.standards ?? [],
+    verificationHash,
+    issuedAt: now.toISOString(),
+    expiresAt: expiresAt.toISOString(),
+    issuer: options.issuer ?? 'self',
+    subject: options.subject,
+  };
+}
+
+export function validateBadge(badge: BadgeData): { valid: boolean; reason?: string } {
+  if (badge.governedBy !== 'baseline-protocol') {
+    return { valid: false, reason: 'Not a Baseline Protocol badge' };
+  }
+
+  if (!badge.verificationHash || badge.verificationHash.length < 16) {
+    return { valid: false, reason: 'Invalid verification hash' };
+  }
+
+  const now = new Date();
+  if (new Date(badge.expiresAt) < now) {
+    return { valid: false, reason: 'Badge has expired' };
+  }
+
+  if (!badge.subject) {
+    return { valid: false, reason: 'Badge has no subject' };
+  }
+
+  return { valid: true };
+}
+
+export function formatBadgeText(badge: BadgeData): string {
+  const lines = [
+    `Baseline-Governed`,
+    `Subject: ${badge.subject}`,
+    `Standards: ${badge.standards.length > 0 ? badge.standards.join(', ') : 'none specified'}`,
+    `Issued: ${badge.issuedAt.split('T')[0]}`,
+    `Expires: ${badge.expiresAt.split('T')[0]}`,
+    `Hash: ${badge.verificationHash}`,
+  ];
+  return lines.join('\n');
+}

package/src/cli.ts

@@ -0,0 +1,314 @@
+#!/usr/bin/env node
+
+/**
+ * Baseline Protocol CLI
+ * Entry point for the `baseline` command.
+ */
+
+import { BaselineLangSystem } from '@baselineos/lang';
+import { BaselineFrameSystem } from '@baselineos/frame';
+import { BaselineStudioSystem } from '@baselineos/studio';
+import { BaselineGovernSystem } from '@baselineos/govern';
+import { BaselineExperienceSystem } from '@baselineos/experience';
+import { BaselineAutonomySystem } from '@baselineos/autonomy';
+import { BaselinePersonaEngine } from '@baselineos/persona';
+import { BaselineCommandSystem } from './commands.js';
+import { runVerify } from './verify.js';
+import type { VerifyOptions } from './verify.js';
+import { createInterface } from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+
+const VERSION = '0.1.0';
+
+export function buildCommandLine(args: string[]): string {
+  const raw = args.join(' ').trim();
+  if (!raw) return '';
+  return raw.startsWith('--') ? raw : `--${raw}`;
+}
+
+async function main(): Promise<void> {
+  const args = process.argv.slice(2);
+  const command = args[0];
+
+  switch (command) {
+    case '--help':
+    case '-h':
+    case 'help':
+    case undefined:
+      showStartScreen();
+      showHelp();
+      break;
+    case 'status':
+    case '--status':
+      showStatus();
+      break;
+    case 'init': {
+      const cmdSystem = new BaselineCommandSystem();
+      const commandLine = buildCommandLine(['--init', ...args.slice(1), '--write-config']);
+      const result = await cmdSystem.executeCommand(commandLine);
+      if (!result.success) {
+        console.error(`Error: ${result.error ?? 'Unknown error'}`);
+        process.exit(1);
+      }
+      console.log(JSON.stringify(result, null, 2));
+      break;
+    }
+    case 'version':
+    case '--version':
+    case '-v':
+      console.log(`baseline v${VERSION}`);
+      break;
+    case 'onboard':
+    case 'onboarding': {
+      const cmdSystem = new BaselineCommandSystem();
+      const rawArgs = args.slice(1).filter((arg) => arg !== '--interactive');
+      const interactive = args.length <= 1 || args.includes('--interactive');
+
+      let result;
+      if (interactive) {
+        showStartScreen();
+        const options = await promptOnboardingOptions();
+        result = await cmdSystem.executeOnboarding(options);
+      } else {
+        const commandLine = buildCommandLine(['--onboard', ...rawArgs]);
+        result = await cmdSystem.executeCommand(commandLine);
+      }
+      if (!result.success) {
+        console.error(`Error: ${result.error ?? 'Unknown error'}`);
+        process.exit(1);
+      }
+      console.log(JSON.stringify(result, null, 2));
+      break;
+    }
+    case 'experience': {
+      const cmdSystem = new BaselineCommandSystem();
+      const rawArgs = args.slice(1);
+      const commandLine = buildCommandLine(['--experience', ...rawArgs]);
+      const result = await cmdSystem.executeCommand(commandLine);
+      if (!result.success) {
+        console.error(`Error: ${result.error ?? 'Unknown error'}`);
+        process.exit(1);
+      }
+      console.log(JSON.stringify(result, null, 2));
+      break;
+    }
+    case 'serve': {
+      const cmdSystem = new BaselineCommandSystem();
+      const commandLine = buildCommandLine(['--serve', ...args.slice(1)]);
+      const result = await cmdSystem.executeCommand(commandLine);
+      if (!result.success) {
+        console.error(`Error: ${result.error ?? 'Unknown error'}`);
+        process.exit(1);
+      }
+      // Do not print JSON to stdout; MCP uses stdout for protocol.
+      break;
+    }
+    case 'verify': {
+      const verifyOpts: VerifyOptions = {};
+      for (let i = 1; i < args.length; i++) {
+        if (args[i] === '--policy' && args[i + 1]) { verifyOpts.policyPath = args[++i]; }
+        else if (args[i] === '--evidence' && args[i + 1]) { verifyOpts.evidencePath = args[++i]; }
+        else if (args[i] === '--audit-trail' && args[i + 1]) { verifyOpts.auditTrailPath = args[++i]; }
+      }
+      const verifyResult = await runVerify(verifyOpts);
+      console.log(JSON.stringify(verifyResult, null, 2));
+      if (!verifyResult.success) process.exit(1);
+      break;
+    }
+    case 'doctor': {
+      const cmdSystem = new BaselineCommandSystem();
+      const commandLine = buildCommandLine(['--doctor', ...args.slice(1)]);
+      const result = await cmdSystem.executeCommand(commandLine);
+      if (!result.success) {
+        console.error(`Error: ${result.error ?? 'Unknown error'}`);
+        process.exit(1);
+      }
+      console.log(JSON.stringify(result, null, 2));
+      break;
+    }
+    default: {
+      const cmdSystem = new BaselineCommandSystem();
+      const commandLine = buildCommandLine(args);
+      if (!commandLine) {
+        showHelp();
+        return;
+      }
+      const result = await cmdSystem.executeCommand(commandLine);
+      if (!result.success) {
+        console.error(`Error: ${result.error ?? 'Unknown error'}`);
+        process.exit(1);
+      }
+      console.log(JSON.stringify(result, null, 2));
+      break;
+    }
+  }
+}
+
+function showHelp(): void {
+  console.log(`
+Baseline Protocol CLI v${VERSION}
+
+Usage: baseline <command> [options]
+
+Commands:
+  help        Show this help message
+  status      Show status of all protocol layers
+  onboard     Run the guided onboarding flow
+  experience  Run immersive onboarding experiences
+  init        Initialize Baseline and write config
+  run         Run the full Baseline workflow
+  index       Index docs or context for retrieval
+  verify      Verify policy compliance and evidence integrity
+  serve       Start the Baseline MCP server
+  agents      Show agent registry status
+  config      Configure Baseline preferences
+  doctor      Run diagnostics for Baseline readiness
+  version     Show version information
+
+Layer Commands:
+  --baseline       Run full Baseline Protocol workflow
+  --baseline-lang  Run Language layer only
+  --baseline-frame Run Frame layer only
+  --baseline-studio Run Studio layer only
+  --baseline-govern Run Governance layer only
+  --init           Initialize a new Baseline project
+  --run            Run the full workflow
+  --status         Show system status
+  --help           Show help information
+`);
+}
+
+function showStartScreen(): void {
+  console.log(`
+██████╗  █████╗ ███████╗███████╗██╗     ██╗███╗   ██╗███████╗
+██╔══██╗██╔══██╗██╔════╝██╔════╝██║     ██║████╗  ██║██╔════╝
+██████╔╝███████║███████╗█████╗  ██║     ██║██╔██╗ ██║█████╗
+██╔══██╗██╔══██║╚════██║██╔══╝  ██║     ██║██║╚██╗██║██╔══╝
+██████╔╝██║  ██║███████║███████╗███████╗██║██║ ╚████║███████╗
+╚═════╝ ╚═╝  ╚═╝╚══════╝╚══════╝╚══════╝╚═╝╚═╝  ╚═══╝╚══════╝
+
+Baseline Protocol • Guided Onboarding
+`);
+}
+
+async function promptOnboardingOptions(): Promise<Record<string, unknown>> {
+  const rl = createInterface({ input, output });
+  try {
+    const nameInput = (await rl.question('Your name (default: User): ')).trim();
+    const roleInput = (await rl.question('Role (default: Operator): ')).trim();
+    const emailInput = (await rl.question('Email (optional): ')).trim();
+    const companyInput = (await rl.question('Company name (default: Acme Corp): ')).trim();
+    const languageInput = (await rl.question(
+      'Preferred language (en/es/fr/de/ja/zh/ko/ar/hi/pt, default: en): '
+    )).trim();
+    const learningStyleInput = (await rl.question(
+      'Learning style (visual/auditory/kinesthetic/reading, default: visual): '
+    )).trim();
+    const paceInput = (await rl.question(
+      'Learning pace (slow/moderate/fast/lightning, default: moderate): '
+    )).trim();
+    const focusInput = (await rl.question(
+      'Learning focus (practical/theoretical/mixed, default: practical): '
+    )).trim();
+    const learningPathInput = (await rl.question(
+      'Learning path (standard/accelerated/hands-on/theoretical, default: standard): '
+    )).trim();
+    const teamInput =
+      (await rl.question('Team name (optional, press enter to skip): ')).trim();
+    const projectInput =
+      (await rl.question('Project name (optional, press enter to skip): ')).trim();
+    const contextInput = (await rl.question(`Context path (default: ${process.cwd()}): `)).trim();
+    const modeInput = (await rl.question(
+      'Mode (development/staging/production, default: development): '
+    ))
+      .trim()
+      .toLowerCase();
+    const runWorkflow =
+      (await rl.question('Run full workflow now? (Y/n): ')).trim().toLowerCase();
+    const skipWorkflow = runWorkflow === 'n' || runWorkflow === 'no';
+
+    return {
+      name: nameInput || undefined,
+      role: roleInput || undefined,
+      email: emailInput || undefined,
+      company: companyInput || undefined,
+      language: languageInput || undefined,
+      'learning-style': learningStyleInput || undefined,
+      pace: paceInput || undefined,
+      focus: focusInput || undefined,
+      'learning-path': learningPathInput || undefined,
+      team: teamInput || undefined,
+      project: projectInput || undefined,
+      context: contextInput || undefined,
+      mode: modeInput || undefined,
+      'skip-workflow': skipWorkflow,
+    };
+  } finally {
+    rl.close();
+  }
+}
+
+function showStatus(): void {
+  console.log(`\nBaseline Protocol v${VERSION}\n`);
+  console.log('Layer Status:');
+  console.log('-'.repeat(60));
+
+  const safeLine = (label: string, fn: () => string) => {
+    try {
+      console.log(`  ${label.padEnd(10)}: ${fn()}`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.log(`  ${label.padEnd(10)}: error (${msg})`);
+    }
+  };
+
+  safeLine('Lang', () => {
+    const lang = new BaselineLangSystem();
+    const langCommands = lang.getCommandRegistry().size;
+    return `initialized (${langCommands} commands registered)`;
+  });
+
+  safeLine('Frame', () => {
+    const frame = new BaselineFrameSystem();
+    const frameStatus = frame.getStatus();
+    return `${frameStatus.initialized ? 'initialized' : 'not initialized'} (mode: ${frameStatus.currentMode?.name ?? 'default'})`;
+  });
+
+  safeLine('Studio', () => {
+    const studio = new BaselineStudioSystem();
+    const studioStatus = studio.getStatus() as { system: string };
+    return `initialized (${studioStatus.system})`;
+  });
+
+  safeLine('Govern', () => {
+    const govern = new BaselineGovernSystem();
+    const governStatus = govern.getStatus();
+    return `${governStatus.initialized ? 'initialized' : 'not initialized'} (${governStatus.policies} policies)`;
+  });
+
+  safeLine('Experience', () => {
+    const experience = new BaselineExperienceSystem();
+    const expStatus = experience.getStatus();
+    return `${expStatus.initialized ? 'initialized' : 'not initialized'}`;
+  });
+
+  safeLine('Autonomy', () => {
+    const autonomy = new BaselineAutonomySystem();
+    const autoStatus = autonomy.getSystemStatus();
+    return `${autoStatus.status} (${autoStatus.agentCount} agents)`;
+  });
+
+  safeLine('Persona', () => {
+    const persona = new BaselinePersonaEngine();
+    const personaStatus = persona.getStatus();
+    return `${personaStatus.initialized ? 'initialized' : 'not initialized'} (${personaStatus.totalPersonas} personas)`;
+  });
+
+  console.log('');
+  console.log('All systems operational.');
+}
+
+main().catch((err: unknown) => {
+  console.error('Fatal error:', err instanceof Error ? err.message : String(err));
+  process.exit(1);
+});