all-hands-cli 0.1.0

package/.allhands/harness/src/commands/validate.ts

@@ -0,0 +1,143 @@
+/**
+ * Validate Command (Agent-Facing)
+ *
+ * Validates files against their schema types.
+ * Used by hooks and agents to verify file correctness.
+ *
+ * Usage:
+ *   ah validate <file> [--type <type>]  - Validate a single file
+ *   ah validate agents                   - Validate all agent profiles
+ */
+
+import { Command } from 'commander';
+import { existsSync, readFileSync } from 'fs';
+import { dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { loadAllProfiles } from '../lib/opencode/index.js';
+import {
+  formatErrors,
+  inferSchemaType,
+  listSchemas,
+  validateFile,
+} from '../lib/schema.js';
+import { TEMPLATE_VAR_NAMES } from '../lib/schemas/template-vars.js';
+import { tracedAction } from '../lib/base-command.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// Note: inferSchemaType is now imported from lib/schema.ts
+
+export function register(program: Command): void {
+  const validateCmd = program
+    .command('validate')
+    .description('Validate files against schemas');
+
+  // Subcommand: validate agents
+  validateCmd
+    .command('agents')
+    .description('Validate all agent profiles')
+    .option('--json', 'Output as JSON')
+    .action(tracedAction('validate agents', (options: { json?: boolean }) => {
+      const { profiles, errors } = loadAllProfiles();
+
+      if (options.json) {
+        console.log(JSON.stringify({
+          success: errors.length === 0,
+          profileCount: profiles.length,
+          errors,
+          templateVars: TEMPLATE_VAR_NAMES,
+        }));
+        process.exit(errors.length === 0 ? 0 : 1);
+      }
+
+      console.log(`\nAgent Profile Validation`);
+      console.log(`========================\n`);
+      console.log(`Found ${profiles.length} agent profiles\n`);
+
+      if (errors.length === 0) {
+        console.log('All profiles valid!\n');
+        for (const profile of profiles) {
+          console.log(`  ${profile.name}`);
+          console.log(`    Flow: ${profile.flow}`);
+          console.log(`    TUI Action: ${profile.tuiAction ?? '(none)'}`);
+          console.log(`    Template Vars: ${profile.templateVars.length > 0 ? profile.templateVars.join(', ') : '(none)'}`);
+          console.log();
+        }
+      } else {
+        console.log('Validation errors:\n');
+        for (const err of errors) {
+          console.log(`  ${err.name}:`);
+          for (const e of err.errors) {
+            console.log(`    ERROR: ${e}`);
+          }
+          for (const w of err.warnings) {
+            console.log(`    WARN: ${w}`);
+          }
+          console.log();
+        }
+        process.exit(1);
+      }
+
+      console.log('\nValid template variables:');
+      console.log(`  ${TEMPLATE_VAR_NAMES.join(', ')}\n`);
+    }));
+
+  // Subcommand: validate file <path>
+  validateCmd
+    .command('file <path>')
+    .description('Validate a file against its schema')
+    .option('-t, --type <type>', 'Schema type (prompt, alignment, spec, documentation)')
+    .option('--json', 'Output as JSON')
+    .action(tracedAction('validate file', async (file: string, options: { type?: string; json?: boolean }) => {
+      if (!existsSync(file)) {
+        if (options.json) {
+          console.log(JSON.stringify({ success: false, error: `File not found: ${file}` }));
+        } else {
+          console.error(`File not found: ${file}`);
+        }
+        process.exit(1);
+      }
+
+      let schemaType = options.type;
+      if (!schemaType) {
+        schemaType = inferSchemaType(file) ?? undefined;
+      }
+
+      if (!schemaType) {
+        const available = listSchemas();
+        if (options.json) {
+          console.log(JSON.stringify({
+            success: false,
+            error: 'Could not determine schema type',
+            available,
+          }));
+        } else {
+          console.error('Could not determine schema type. Use --type to specify.');
+          console.error(`Available types: ${available.join(', ')}`);
+        }
+        process.exit(1);
+      }
+
+      const content = readFileSync(file, 'utf-8');
+      const result = validateFile(content, schemaType);
+
+      if (options.json) {
+        console.log(JSON.stringify({
+          success: result.valid,
+          file,
+          schemaType,
+          errors: result.errors,
+        }));
+        process.exit(result.valid ? 0 : 1);
+      }
+
+      if (result.valid) {
+        console.log(`Valid: ${file} (schema: ${schemaType})`);
+      } else {
+        console.error(`Invalid: ${file} (schema: ${schemaType})`);
+        console.error(formatErrors(result));
+        process.exit(1);
+      }
+    }));
+}
+

package/.allhands/harness/src/commands/validation-tools.ts

@@ -0,0 +1,108 @@
+/**
+ * Validation Tools Command (Agent-Facing)
+ *
+ * Lists and discovers validation tooling suites.
+ * Agents use this to find relevant validation tooling for their tasks.
+ *
+ * Usage: ah validation-tools list
+ */
+
+import { Command } from 'commander';
+import { existsSync, readdirSync, readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { tracedAction } from '../lib/base-command.js';
+import { extractFrontmatter, loadSchema, validateFrontmatter } from '../lib/schema.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+interface ValidationSuiteFrontmatter {
+  name: string;
+  description: string;
+  globs: string[];
+  tools: string[];
+}
+
+interface ValidationSuiteEntry {
+  name: string;
+  description: string;
+  globs: string[];
+  tools: string[];
+  file: string;
+}
+
+/**
+ * Get the validation directory path
+ * Path: harness/src/commands/ -> harness/src/ -> harness/ -> .allhands/ -> validation/
+ */
+function getValidationToolingDir(): string {
+  return join(__dirname, '..', '..', '..', 'validation');
+}
+
+/**
+ * List all validation suites by reading .md files and extracting frontmatter
+ */
+function listValidationSuites(): ValidationSuiteEntry[] {
+  const dir = getValidationToolingDir();
+
+  if (!existsSync(dir)) {
+    return [];
+  }
+
+  const schema = loadSchema('validation-suite');
+  if (!schema) {
+    return [];
+  }
+
+  const files = readdirSync(dir).filter(f => f.endsWith('.md'));
+  const suites: ValidationSuiteEntry[] = [];
+
+  for (const file of files) {
+    const filePath = join(dir, file);
+    const content = readFileSync(filePath, 'utf-8');
+    const { frontmatter: rawFm } = extractFrontmatter(content);
+
+    if (rawFm && validateFrontmatter(rawFm, schema).valid) {
+      const fm = rawFm as unknown as ValidationSuiteFrontmatter;
+      suites.push({
+        name: fm.name,
+        description: fm.description,
+        globs: fm.globs,
+        tools: fm.tools,
+        file: `.allhands/validation/${file}`,
+      });
+    }
+  }
+
+  return suites;
+}
+
+export function register(program: Command): void {
+  const cmd = program
+    .command('validation-tools')
+    .description('Discover and list validation tooling suites');
+
+  cmd
+    .command('list')
+    .description('List all validation suites with their descriptions and glob patterns')
+    .option('--json', 'Output as JSON (default)')
+    .action(tracedAction('validation-tools list', async () => {
+      const suites = listValidationSuites();
+
+      if (suites.length === 0) {
+        console.log(JSON.stringify({
+          success: true,
+          suites: [],
+          message: 'No validation suites found. Create suites in .allhands/validation/ using `ah schema validation-suite` for the file structure.',
+        }, null, 2));
+        return;
+      }
+
+      console.log(JSON.stringify({
+        success: true,
+        suites,
+        count: suites.length,
+      }, null, 2));
+    }));
+}