skrypt-ai 0.6.1 → 0.8.0

package/dist/commands/generate/scan.js

@@ -0,0 +1,256 @@
+import { existsSync, readFileSync } from 'fs';
+import { resolve, join } from 'path';
+import { resolveSourceEntries } from '../../config/index.js';
+import { scanDirectory } from '../../scanner/index.js';
+import { discoverOrgRepos, cloneRepoToTemp } from '../../github/org-discovery.js';
+/**
+ * Parse source arguments with optional labels.
+ * e.g. "./api:API" -> { path: "./api", label: "API" }
+ * e.g. "./src" -> { path: "./src" }
+ */
+export function parseSourceArgs(args) {
+    return args.map(arg => {
+        const colonIdx = arg.lastIndexOf(':');
+        // Only treat as label separator if colon is not part of a path (e.g. C:\)
+        if (colonIdx > 1 && !arg.substring(0, colonIdx).endsWith('\\')) {
+            return {
+                path: arg.substring(0, colonIdx),
+                label: arg.substring(colonIdx + 1),
+            };
+        }
+        return { path: arg };
+    });
+}
+/**
+ * Read .skryptignore patterns from source directory
+ */
+export function readIgnorePatterns(sourcePath) {
+    const ignorePath = join(sourcePath, '.skryptignore');
+    if (!existsSync(ignorePath))
+        return [];
+    const content = readFileSync(ignorePath, 'utf-8');
+    return content
+        .split('\n')
+        .map(line => line.trim())
+        .filter(line => line && !line.startsWith('#'));
+}
+/**
+ * Auto-detect OpenAPI spec file in source directory
+ */
+export function findOpenAPISpec(sourcePath) {
+    const candidates = [
+        'openapi.json',
+        'openapi.yaml',
+        'openapi.yml',
+        'swagger.json',
+        'swagger.yaml',
+        'swagger.yml',
+        'api.json',
+        'api.yaml',
+        'api.yml',
+    ];
+    for (const name of candidates) {
+        const specPath = join(sourcePath, name);
+        if (existsSync(specPath)) {
+            return specPath;
+        }
+    }
+    // Check common subdirectories
+    const subdirs = ['docs', 'api', 'spec', '.'];
+    for (const subdir of subdirs) {
+        for (const name of candidates) {
+            const specPath = join(sourcePath, subdir, name);
+            if (existsSync(specPath)) {
+                return specPath;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Check if element should be excluded based on patterns
+ */
+export function shouldExcludeElement(element, patterns) {
+    for (const pattern of patterns) {
+        // Match by name
+        if (pattern.startsWith('name:')) {
+            const namePattern = pattern.slice(5);
+            if (element.name === namePattern) {
+                return true;
+            }
+            // Only use regex if the pattern contains regex metacharacters
+            // Reject patterns with nested quantifiers to prevent catastrophic backtracking (ReDoS)
+            if (/[*+?{}()|[\]\\^$.]/.test(namePattern)) {
+                if (/(\+|\*|\?)\{|\(\?[^:)]|\(\.[*+].*\)\+|\([^)]*[+*][^)]*\)[+*]/.test(namePattern)) {
+                    continue; // Skip patterns prone to catastrophic backtracking
+                }
+                try {
+                    if (new RegExp(namePattern).test(element.name))
+                        return true;
+                }
+                catch {
+                    // Invalid regex — treat as literal match (already checked above)
+                }
+            }
+        }
+        // Match by file path
+        else if (pattern.includes('/') || pattern.includes('*')) {
+            const filePath = element.filePath;
+            if (pattern.includes('**')) {
+                const parts = pattern.split('**');
+                const prefixMatch = !parts[0] || filePath.includes(parts[0].replace(/^\//, ''));
+                const suffixMatch = !parts[1] || filePath.includes(parts[1].replace(/^\//, ''));
+                if (prefixMatch && suffixMatch)
+                    return true;
+            }
+            else if (filePath.includes(pattern.replace(/\*/g, ''))) {
+                return true;
+            }
+        }
+        // Match by exact name
+        else if (element.name === pattern) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Scan all sources (CLI args, --org, or config), apply filters, return elements.
+ */
+export async function scanSources(sources, options, config) {
+    // Resolve source entries: CLI args, --org, or config file
+    let sourceEntries;
+    const tempDirs = [];
+    if (options.org) {
+        // GitHub org discovery mode
+        const token = process.env.GITHUB_TOKEN;
+        if (!token) {
+            throw new Error('GITHUB_TOKEN environment variable required for --org');
+        }
+        console.log(`Discovering repos in org "${options.org}"...`);
+        const repoWhitelist = options.repos ? options.repos.split(',').map(r => r.trim()) : undefined;
+        const repoBlacklist = options.excludeRepos ? options.excludeRepos.split(',').map(r => r.trim()) : undefined;
+        let discoveredRepos = await discoverOrgRepos(options.org, token);
+        if (repoWhitelist) {
+            discoveredRepos = discoveredRepos.filter(r => repoWhitelist.includes(r.name));
+        }
+        if (repoBlacklist) {
+            discoveredRepos = discoveredRepos.filter(r => !repoBlacklist.includes(r.name));
+        }
+        console.log(`  Found ${discoveredRepos.length} repos`);
+        sourceEntries = [];
+        for (const repo of discoveredRepos) {
+            console.log(`  Cloning ${repo.full_name}...`);
+            const tempDir = await cloneRepoToTemp(repo, token);
+            tempDirs.push(tempDir);
+            sourceEntries.push({
+                path: tempDir,
+                label: repo.name,
+                include: config.source.include,
+                exclude: config.source.exclude,
+            });
+        }
+    }
+    else if (sources.length > 1) {
+        // Multiple CLI args
+        sourceEntries = parseSourceArgs(sources);
+    }
+    else {
+        // Single source or config file sources
+        sourceEntries = resolveSourceEntries(config);
+    }
+    const isMultiSource = sourceEntries.length > 1 || sourceEntries.some(s => s.label);
+    // Check all source paths exist
+    for (const entry of sourceEntries) {
+        const sourcePath = resolve(entry.path);
+        if (!existsSync(sourcePath)) {
+            throw new Error(`Source directory not found: ${sourcePath}`);
+        }
+    }
+    // Step 1: Scan source code from all sources
+    console.log('Step 1: Scanning source code...');
+    let allElements = [];
+    let totalFiles = 0;
+    const allScanErrors = [];
+    for (const entry of sourceEntries) {
+        const sourcePath = resolve(entry.path);
+        if (isMultiSource) {
+            console.log(`\n  Scanning ${entry.label || entry.path}...`);
+        }
+        const scanResult = await scanDirectory(sourcePath, {
+            include: entry.include || config.source.include,
+            exclude: entry.exclude || config.source.exclude,
+            onProgress: (current, total, file) => {
+                process.stdout.write(`\r  [${current}/${total}] ${file.slice(-50).padStart(50)}`);
+            }
+        });
+        console.log('');
+        if (scanResult.errors.length > 0) {
+            allScanErrors.push(...scanResult.errors);
+        }
+        totalFiles += scanResult.files.length;
+        // Tag elements with source metadata
+        for (const file of scanResult.files) {
+            for (const el of file.elements) {
+                if (entry.label) {
+                    el.sourceLabel = entry.label;
+                }
+                el.sourceRoot = sourcePath;
+                allElements.push(el);
+            }
+        }
+    }
+    if (allScanErrors.length > 0) {
+        console.log('\n  Scan warnings:');
+        allScanErrors.slice(0, 5).forEach(e => console.log(`    - ${e}`));
+        if (allScanErrors.length > 5) {
+            console.log(`    ... and ${allScanErrors.length - 5} more`);
+        }
+    }
+    console.log(`\n  Found ${allElements.length} API elements in ${totalFiles} files`);
+    if (allElements.length === 0) {
+        console.log('  No API elements found. Nothing to generate.');
+        return { allElements, sourceEntries, primarySourcePath: resolve(sourceEntries[0].path), tempDirs, isMultiSource };
+    }
+    // Apply privacy filters
+    const initialCount = allElements.length;
+    // 1. --public-only: filter to exported/public APIs only
+    if (options.publicOnly) {
+        allElements = allElements.filter(el => el.isExported === true || el.isPublic === true);
+        console.log(`  --public-only: filtered to ${allElements.length} exported APIs`);
+    }
+    // 2. Load .skryptignore patterns from all source dirs
+    const ignorePatterns = [];
+    for (const entry of sourceEntries) {
+        ignorePatterns.push(...readIgnorePatterns(resolve(entry.path)));
+    }
+    if (ignorePatterns.length > 0) {
+        console.log(`  .skryptignore: loaded ${ignorePatterns.length} patterns`);
+    }
+    // 3. Combine with --exclude patterns
+    const excludePatterns = [...ignorePatterns, ...(options.exclude || [])];
+    if (excludePatterns.length > 0) {
+        allElements = allElements.filter(el => !shouldExcludeElement(el, excludePatterns));
+        if (options.exclude?.length) {
+            console.log(`  --exclude: applied ${options.exclude.length} additional patterns`);
+        }
+    }
+    if (initialCount !== allElements.length) {
+        console.log(`  Filtered: ${initialCount} -> ${allElements.length} elements`);
+    }
+    // Show summary by kind
+    const byKind = {};
+    for (const el of allElements) {
+        byKind[el.kind] = (byKind[el.kind] || 0) + 1;
+    }
+    const pluralize = (word, count) => {
+        if (count === 1)
+            return word;
+        if (word === 'class')
+            return 'classes';
+        return word + 's';
+    };
+    console.log('  ' + Object.entries(byKind).map(([k, v]) => `${v} ${pluralize(k, v)}`).join(', '));
+    const primarySourcePath = resolve(sourceEntries[0].path);
+    return { allElements, sourceEntries, primarySourcePath, tempDirs, isMultiSource };
+}

package/dist/commands/generate/verify.d.ts

@@ -0,0 +1,14 @@
+import { APIElement } from '../../scanner/index.js';
+import { LLMClient } from '../../llm/index.js';
+interface VerifyOptions {
+    envFile?: string;
+    maxVerifyIterations?: string;
+    multiLanguage: boolean;
+    externalContext?: Map<string, string>;
+    projectContext?: string;
+}
+/**
+ * Verify generated code examples by running them, with re-generation retry loop.
+ */
+export declare function verifyCodeExamples(outputPath: string, allElements: APIElement[], client: LLMClient, primarySourcePath: string, options: VerifyOptions): Promise<void>;
+export {};

package/dist/commands/generate/verify.js

@@ -0,0 +1,122 @@
+import { dirname } from 'path';
+import { resolve } from 'path';
+import { generateForElements, groupDocsByFile, writeDocsToDirectory } from '../../generator/index.js';
+import { extractSnippets, findDocFiles, runLocally, loadEnvFile } from '../../testing/index.js';
+/**
+ * Verify generated code examples by running them, with re-generation retry loop.
+ */
+export async function verifyCodeExamples(outputPath, allElements, client, primarySourcePath, options) {
+    console.log('\nStep 4: Verifying code examples...');
+    let verifyEnvVars = {};
+    if (options.envFile) {
+        try {
+            verifyEnvVars = loadEnvFile(resolve(options.envFile));
+            console.log(`  Loaded ${Object.keys(verifyEnvVars).length} env var(s) from ${options.envFile}`);
+        }
+        catch {
+            console.log(`  Warning: Could not load env file: ${options.envFile}`);
+        }
+    }
+    const verifyConfig = {
+        timeout: 15000,
+        envVars: verifyEnvVars,
+        installDeps: true,
+    };
+    const maxIterations = Math.max(1, parseInt(options.maxVerifyIterations ?? '2', 10) || 2);
+    let failedCount = 0;
+    let passedCount = 0;
+    let skippedCount = 0;
+    const genOptions = {
+        multiLanguage: options.multiLanguage,
+        externalContext: options.externalContext,
+        projectContext: options.projectContext,
+        onProgress: (_progress) => {
+            // Placeholder — overridden below for re-generation
+        },
+    };
+    for (let iteration = 1; iteration <= maxIterations; iteration++) {
+        const docFiles = findDocFiles(outputPath);
+        const allSnippets = docFiles.flatMap(f => extractSnippets(f));
+        if (allSnippets.length === 0) {
+            console.log('  No code snippets found to verify');
+            break;
+        }
+        if (iteration === 1) {
+            console.log(`  Found ${allSnippets.length} code snippet(s) to verify`);
+        }
+        else {
+            console.log(`\n  Retry ${iteration}/${maxIterations}: re-verifying ${allSnippets.length} snippet(s)...`);
+        }
+        failedCount = 0;
+        passedCount = 0;
+        skippedCount = 0;
+        const failedSnippets = [];
+        const snippetErrors = new Map();
+        for (const snippet of allSnippets) {
+            const result = await runLocally(snippet, verifyConfig);
+            if (result.status === 'pass') {
+                passedCount++;
+            }
+            else if (result.status === 'skip') {
+                skippedCount++;
+            }
+            else {
+                failedCount++;
+                failedSnippets.push(snippet);
+                const errorMsg = result.stderr?.trim().split('\n').slice(0, 5).join('\n') || `Exit code: ${result.exitCode}`;
+                snippetErrors.set(snippet.filePath + ':' + snippet.lineNumber, errorMsg);
+                console.log(`  \x1b[31m✗\x1b[0m ${snippet.filePath}:${snippet.lineNumber} [${snippet.language}]`);
+                if (result.stderr) {
+                    console.log(`    ${result.stderr.trim().split('\n')[0]?.slice(0, 80)}`);
+                }
+            }
+        }
+        // If all passed or last iteration, stop
+        if (failedCount === 0 || iteration === maxIterations) {
+            break;
+        }
+        // Re-generate failing docs by re-running generation for elements whose docs had failing snippets
+        console.log(`\n  Re-generating ${failedSnippets.length} failing snippet(s)...`);
+        const failedFiles = [...new Set(failedSnippets.map(s => s.filePath))];
+        for (const failedFile of failedFiles) {
+            // Find elements that map to this doc file
+            const fileSnippets = failedSnippets.filter(s => s.filePath === failedFile);
+            const matchingElements = allElements.filter(el => fileSnippets.some(s => {
+                // Match element name in the snippet's surrounding code or filename
+                const elNameLower = el.name.toLowerCase();
+                return s.code.toLowerCase().includes(elNameLower) ||
+                    failedFile.toLowerCase().includes(elNameLower);
+            }));
+            if (matchingElements.length > 0) {
+                // Build error context map: element name -> error message
+                const previousErrors = new Map();
+                for (const snippet of fileSnippets) {
+                    const errKey = snippet.filePath + ':' + snippet.lineNumber;
+                    const errMsg = snippetErrors.get(errKey);
+                    if (errMsg) {
+                        // Map snippet back to element name
+                        const matchedEl = matchingElements.find(el => snippet.code.toLowerCase().includes(el.name.toLowerCase()));
+                        if (matchedEl) {
+                            previousErrors.set(matchedEl.name, errMsg);
+                        }
+                    }
+                }
+                const reDocs = await generateForElements(matchingElements, client, {
+                    ...genOptions,
+                    verify: true,
+                    previousErrors,
+                    onProgress: (p) => {
+                        process.stdout.write(`\r  Re-generating: ${p.element} ${p.status}`.padEnd(80));
+                    },
+                });
+                console.log('');
+                // Re-write the doc file with updated content
+                const fileResults = groupDocsByFile(reDocs);
+                await writeDocsToDirectory(fileResults, dirname(failedFile), primarySourcePath);
+            }
+        }
+    }
+    if (failedCount + passedCount + skippedCount > 0) {
+        console.log(`\n  Verification: ${passedCount} passed, ${failedCount} failed, ${skippedCount} skipped`);
+    }
+}

package/dist/commands/generate/write.d.ts

@@ -0,0 +1,25 @@
+import { APIElement } from '../../scanner/index.js';
+type GeneratedDoc = Awaited<ReturnType<typeof import('../../generator/index.js').generateForElements>>[number];
+interface WriteDocsOptions {
+    byTopic?: boolean;
+}
+interface WriteDocsResult {
+    filesWritten: number;
+    totalDocs: number;
+    errorCount: number;
+}
+/**
+ * Write generated docs to output directory (byTopic / multiSource / single source).
+ */
+export declare function writeDocs(docs: GeneratedDoc[], outputPath: string, primarySourcePath: string, isMultiSource: boolean, options: WriteDocsOptions): Promise<WriteDocsResult>;
+interface WriteAssetsOptions {
+    openapi?: string;
+    projectName?: string;
+    baseUrl?: string;
+    agentsMd?: boolean;
+}
+/**
+ * Write post-generation assets: OpenAPI spec copy, llms.txt, AGENTS.md, manifest.
+ */
+export declare function writeAssets(docs: GeneratedDoc[], allElements: APIElement[], outputPath: string, primarySourcePath: string, configOutputPath: string, filesWritten: number, options: WriteAssetsOptions): Promise<void>;
+export {};

package/dist/commands/generate/write.js

@@ -0,0 +1,120 @@
+import { existsSync, copyFileSync, mkdirSync, writeFileSync } from 'fs';
+import { resolve, basename, dirname, join, relative } from 'path';
+import { groupDocsByFile, writeDocsToDirectory, writeDocsByTopic, writeLlmsTxt, generateAgentsMd } from '../../generator/index.js';
+import { writeManifest, buildManifestEntries } from '../../refresh/manifest.js';
+import { findOpenAPISpec } from './scan.js';
+/**
+ * Write generated docs to output directory (byTopic / multiSource / single source).
+ */
+export async function writeDocs(docs, outputPath, primarySourcePath, isMultiSource, options) {
+    let filesWritten;
+    let totalDocs;
+    if (options.byTopic) {
+        console.log('  mode: by-topic (grouped by concept)');
+        const result = await writeDocsByTopic(docs, outputPath);
+        filesWritten = result.filesWritten;
+        totalDocs = result.totalDocs;
+        console.log(`  topics: ${result.topics.map(t => t.name).join(', ')}`);
+    }
+    else if (isMultiSource) {
+        // Multi-source: write docs namespaced by source label
+        filesWritten = 0;
+        totalDocs = 0;
+        // Group docs by source label
+        const bySource = new Map();
+        for (const doc of docs) {
+            const label = doc.element.sourceLabel || '_default';
+            if (!bySource.has(label))
+                bySource.set(label, []);
+            bySource.get(label).push(doc);
+        }
+        for (const [label, sourceDocs] of bySource) {
+            const fileResults = groupDocsByFile(sourceDocs);
+            const sourceOutputDir = label === '_default' ? outputPath : join(outputPath, label.toLowerCase());
+            const sourceRoot = sourceDocs[0]?.element.sourceRoot || primarySourcePath;
+            const result = await writeDocsToDirectory(fileResults, sourceOutputDir, sourceRoot);
+            filesWritten += result.filesWritten;
+            totalDocs += result.totalDocs;
+            if (label !== '_default') {
+                console.log(`  ${label}: ${result.filesWritten} files`);
+            }
+        }
+    }
+    else {
+        // Default: file-based output (single source)
+        const fileResults = groupDocsByFile(docs);
+        const result = await writeDocsToDirectory(fileResults, outputPath, primarySourcePath);
+        filesWritten = result.filesWritten;
+        totalDocs = result.totalDocs;
+    }
+    const errorCount = docs.filter(d => d.error).length;
+    return { filesWritten, totalDocs, errorCount };
+}
+/**
+ * Write post-generation assets: OpenAPI spec copy, llms.txt, AGENTS.md, manifest.
+ */
+export async function writeAssets(docs, allElements, outputPath, primarySourcePath, configOutputPath, filesWritten, options) {
+    console.log(`\n  Wrote ${filesWritten} documentation files to ${outputPath}`);
+    // Copy OpenAPI spec (provided or auto-detected)
+    let specPath = options.openapi ? resolve(options.openapi) : null;
+    // Auto-detect if not provided
+    if (!specPath) {
+        const detected = findOpenAPISpec(primarySourcePath);
+        if (detected) {
+            specPath = detected;
+            console.log(`\n  Auto-detected OpenAPI spec: ${basename(detected)}`);
+        }
+    }
+    if (specPath) {
+        if (existsSync(specPath)) {
+            const specFilename = basename(specPath);
+            const contentDir = dirname(outputPath);
+            const destPath = resolve(contentDir, specFilename);
+            mkdirSync(dirname(destPath), { recursive: true });
+            copyFileSync(specPath, destPath);
+            console.log(`  Copied OpenAPI spec: ${specFilename} -> ${destPath}`);
+            console.log('  API Playground will be available at /reference');
+        }
+        else if (options.openapi) {
+            console.log(`\n  Warning: OpenAPI spec not found: ${specPath}`);
+        }
+    }
+    // Always generate llms.txt for AEO (Answer Engine Optimization)
+    await writeLlmsTxt(docs, outputPath, {
+        projectName: options.projectName,
+        description: `API documentation for ${options.projectName || basename(primarySourcePath)}`
+    });
+    console.log(`\n  Generated llms.txt and llms-full.md for AEO`);
+    // Generate AGENTS.md + CLAUDE.md for coding agent integration
+    if (options.agentsMd !== false) {
+        const projName = options.projectName || basename(primarySourcePath);
+        const pages = docs
+            .filter(d => !d.error)
+            .map(d => ({
+            title: d.element.name,
+            path: relative(outputPath, join(outputPath, basename(d.element.filePath).replace(/\.[^.]+$/, ''))),
+            description: d.markdown?.split(/\.\s/)[0]?.slice(0, 80),
+            category: d.element.sourceLabel,
+        }));
+        const agentsMdContent = generateAgentsMd({
+            projectName: projName,
+            docsPath: configOutputPath,
+            baseUrl: options.baseUrl,
+            pages,
+            hasLlmsTxt: true,
+        });
+        // Write to project root (one level up from docs output)
+        const projectRoot = resolve(outputPath, '..');
+        writeFileSync(join(projectRoot, 'AGENTS.md'), agentsMdContent, 'utf-8');
+        writeFileSync(join(projectRoot, 'CLAUDE.md'), agentsMdContent, 'utf-8');
+        console.log(`  Generated AGENTS.md and CLAUDE.md for coding agent integration`);
+    }
+    // Write manifest for staleness detection
+    try {
+        const manifestEntries = buildManifestEntries(allElements, outputPath);
+        writeManifest(outputPath, manifestEntries);
+    }
+    catch {
+        // Non-fatal — manifest is optional
+    }
+}

package/dist/commands/import.js

@@ -122,10 +122,13 @@ function scaffoldOutput(outputDir, result) {
     const docsJson = {
         name: result.name,
         description: result.description,
+        fonts: {
+            sans: 'Inter',
+            mono: 'JetBrains Mono',
+        },
         theme: {
             primaryColor: '#3b82f6',
             accentColor: '#8b5cf6',
-            font: 'Inter',
         },
         navigation: result.navigation.map(group => ({
             group: group.group,

package/dist/commands/llms-txt.js

@@ -1,6 +1,7 @@
 import { Command } from 'commander';
 import { existsSync, readFileSync, writeFileSync, readdirSync, statSync, mkdirSync } from 'fs';
 import { resolve, join, extname, dirname } from 'path';
+import { serializeMdxToMarkdown } from '../generator/mdx-serializer.js';
 function extractFrontmatter(content) {
     const match = content.match(/^---\n([\s\S]*?)\n---/);
     if (!match)
@@ -11,12 +12,13 @@ function extractFrontmatter(content) {
     return { title, description };
 }
 function cleanContent(content) {
-    return content
+    // First pass: use MDX serializer to convert JSX components to markdown
+    const serialized = serializeMdxToMarkdown(content);
+    return serialized
         .replace(/^---[\s\S]*?---\n?/, '') // Remove frontmatter
-        .replace(/<[^>]+>/g, '') // Remove JSX/HTML
         .replace(/```[\s\S]*?```/g, '[code example]') // Simplify code blocks
+        .replace(/!\[([^\]]*)\]\([^)]+\)/g, '[image: $1]') // Convert images (before links!)
         .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1') // Convert links to text
-        .replace(/!\[([^\]]*)\]\([^)]+\)/g, '[image: $1]') // Convert images
         .replace(/\n{3,}/g, '\n\n') // Normalize newlines
         .trim();
 }
@@ -90,7 +92,7 @@ This document provides an overview of the documentation for AI assistants and LL
     for (const doc of topDocs) {
         output += `### ${doc.title}
 
-${doc.content.slice(0, 500)}...
+${doc.content.slice(0, 500)}${doc.content.length > 500 ? '...' : ''}
 
 [Read more](${options.baseUrl}/docs${doc.path})
 

package/dist/commands/refresh.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const refreshCommand: Command;