@agentskillkit/agent-skills 1.0.1

package/packages/cli/lib/auto-learn.js

@@ -0,0 +1,319 @@
+#!/usr/bin/env node
+/**
+ * Smart Auto-Learn - True Self-Learning Engine
+ * 
+ * Automatically learns from:
+ * 1. ESLint output (runs ESLint and parses)
+ * 2. Test failures (runs tests and parses)
+ * 3. TypeScript errors (runs tsc and parses)
+ * 
+ * Usage:
+ *   ag-smart auto-learn              # Run all
+ *   ag-smart auto-learn --eslint     # ESLint only
+ *   ag-smart auto-learn --test       # Test failures only
+ *   ag-smart auto-learn --typescript # TypeScript only
+ */
+
+import fs from "fs";
+import path from "path";
+import { execSync, spawnSync } from "child_process";
+import { loadKnowledge, saveKnowledge } from "./recall.v2.js";
+import { VERSION } from "./config.js";
+
+// ============================================================================
+// ESLINT AUTO-LEARN
+// ============================================================================
+
+const ESLINT_PATTERN_MAP = {
+    "no-console": { pattern: "console\\.(log|warn|error|info|debug)", message: "Avoid console statements in production" },
+    "no-debugger": { pattern: "\\bdebugger\\b", message: "Remove debugger statements" },
+    "no-var": { pattern: "\\bvar\\s+\\w", message: "Use const/let instead of var" },
+    "eqeqeq": { pattern: "[^!=]==[^=]", message: "Use === instead of ==" },
+    "no-eval": { pattern: "\\beval\\s*\\(", message: "Avoid eval() for security" },
+    "no-alert": { pattern: "\\balert\\s*\\(", message: "Avoid alert() in production" },
+    "no-implicit-globals": { pattern: "^(?!const|let|var|function|class|import|export)", message: "Avoid implicit globals" },
+    "prefer-const": { pattern: "\\blet\\s+\\w+\\s*=\\s*[^;]+;(?![\\s\\S]*\\1\\s*=)", message: "Use const for variables that are never reassigned" },
+    "no-unused-expressions": { pattern: "^\\s*['\"`]use strict['\"`];?\\s*$", message: "Remove unused expressions" },
+    "semi": { pattern: "[^;{}]\\s*$", message: "Missing semicolon" },
+    "quotes": { pattern: '(?<![\\w])"(?![^"]*"[,\\]\\}\\)])', message: "Prefer single quotes" },
+    "no-empty": { pattern: "\\{\\s*\\}", message: "Empty block statement" },
+    "no-extra-semi": { pattern: ";;", message: "Unnecessary semicolon" },
+    "no-unreachable": { pattern: "(?:return|throw|break|continue)[^}]*[\\n\\r]+[^}]+", message: "Unreachable code" }
+};
+
+function runEslintAutoLearn(projectRoot) {
+    console.log("\n🔍 Running ESLint analysis...\n");
+
+    try {
+        // Try to run ESLint with JSON output
+        const result = spawnSync("npx", ["eslint", ".", "--format", "json", "--no-error-on-unmatched-pattern"], {
+            cwd: projectRoot,
+            encoding: "utf8",
+            shell: true,
+            timeout: 60000
+        });
+
+        if (!result.stdout) {
+            console.log("   ℹ️  ESLint not configured or no files to lint.");
+            return [];
+        }
+
+        const eslintResults = JSON.parse(result.stdout);
+        const ruleViolations = {};
+
+        eslintResults.forEach(file => {
+            if (!file.messages) return;
+            file.messages.forEach(msg => {
+                if (!msg.ruleId) return;
+                if (!ruleViolations[msg.ruleId]) {
+                    ruleViolations[msg.ruleId] = {
+                        rule: msg.ruleId,
+                        count: 0,
+                        severity: msg.severity === 2 ? "ERROR" : "WARNING",
+                        sample: msg.message
+                    };
+                }
+                ruleViolations[msg.ruleId].count++;
+            });
+        });
+
+        return Object.values(ruleViolations).sort((a, b) => b.count - a.count);
+    } catch (e) {
+        console.log("   ⚠️  ESLint analysis skipped:", e.message);
+        return [];
+    }
+}
+
+// ============================================================================
+// TEST FAILURE AUTO-LEARN
+// ============================================================================
+
+const TEST_PATTERN_MAP = {
+    "undefined is not a function": { pattern: "\\w+\\s*\\(", message: "Function may be undefined before call" },
+    "cannot read property": { pattern: "\\w+\\.\\w+", message: "Object property access may fail if undefined" },
+    "null is not an object": { pattern: "\\.\\w+", message: "Null check needed before property access" },
+    "expected.*to equal": { pattern: "expect\\s*\\(", message: "Assertion expectation mismatch" },
+    "timeout": { pattern: "async|await|Promise", message: "Async operation may need longer timeout" },
+    "not defined": { pattern: "\\b\\w+\\b", message: "Variable may not be defined in scope" }
+};
+
+function runTestAutoLearn(projectRoot) {
+    console.log("\n🧪 Running test analysis...\n");
+
+    try {
+        // Try common test runners
+        const testCommands = [
+            { cmd: "npm", args: ["test", "--", "--json", "--passWithNoTests"], name: "npm test" },
+            { cmd: "npx", args: ["vitest", "run", "--reporter=json"], name: "vitest" },
+            { cmd: "npx", args: ["jest", "--json", "--passWithNoTests"], name: "jest" }
+        ];
+
+        for (const tc of testCommands) {
+            const result = spawnSync(tc.cmd, tc.args, {
+                cwd: projectRoot,
+                encoding: "utf8",
+                shell: true,
+                timeout: 120000
+            });
+
+            // Look for test failures in output
+            const output = result.stdout + result.stderr;
+            const failures = [];
+
+            // Parse failure messages
+            const failurePatterns = [
+                /FAIL\s+(.+)/g,
+                /✕\s+(.+)/g,
+                /Error:\s+(.+)/g,
+                /AssertionError:\s+(.+)/g
+            ];
+
+            failurePatterns.forEach(regex => {
+                let match;
+                while ((match = regex.exec(output)) !== null) {
+                    failures.push(match[1].trim());
+                }
+            });
+
+            if (failures.length > 0) {
+                console.log(`   Found ${failures.length} test failure(s) from ${tc.name}`);
+                return failures.map(f => ({ message: f, source: tc.name }));
+            }
+        }
+
+        console.log("   ✅ All tests passing or no tests found.");
+        return [];
+    } catch (e) {
+        console.log("   ⚠️  Test analysis skipped:", e.message);
+        return [];
+    }
+}
+
+// ============================================================================
+// TYPESCRIPT ERROR AUTO-LEARN
+// ============================================================================
+
+const TS_PATTERN_MAP = {
+    "TS2304": { pattern: "\\b\\w+\\b", message: "TypeScript: Cannot find name" },
+    "TS2322": { pattern: ":\\s*\\w+", message: "TypeScript: Type mismatch" },
+    "TS2345": { pattern: "\\(.*\\)", message: "TypeScript: Argument type mismatch" },
+    "TS2339": { pattern: "\\.\\w+", message: "TypeScript: Property does not exist" },
+    "TS7006": { pattern: "\\(\\w+\\)", message: "TypeScript: Parameter implicitly has 'any' type" },
+    "TS2531": { pattern: "\\w+\\.", message: "TypeScript: Object is possibly 'null'" },
+    "TS2532": { pattern: "\\w+\\.", message: "TypeScript: Object is possibly 'undefined'" }
+};
+
+function runTypescriptAutoLearn(projectRoot) {
+    console.log("\n📘 Running TypeScript analysis...\n");
+
+    try {
+        const result = spawnSync("npx", ["tsc", "--noEmit", "--pretty", "false"], {
+            cwd: projectRoot,
+            encoding: "utf8",
+            shell: true,
+            timeout: 60000
+        });
+
+        const output = result.stdout + result.stderr;
+        const errors = {};
+
+        // Parse TS errors: file(line,col): error TS1234: message
+        const tsErrorRegex = /error (TS\d+):\s*(.+)/g;
+        let match;
+
+        while ((match = tsErrorRegex.exec(output)) !== null) {
+            const code = match[1];
+            const message = match[2];
+
+            if (!errors[code]) {
+                errors[code] = { code, message, count: 0 };
+            }
+            errors[code].count++;
+        }
+
+        const errorList = Object.values(errors).sort((a, b) => b.count - a.count);
+
+        if (errorList.length > 0) {
+            console.log(`   Found ${errorList.length} unique TypeScript error type(s)`);
+        } else {
+            console.log("   ✅ No TypeScript errors found.");
+        }
+
+        return errorList;
+    } catch (e) {
+        console.log("   ⚠️  TypeScript analysis skipped:", e.message);
+        return [];
+    }
+}
+
+// ============================================================================
+// MAIN AUTO-LEARN ENGINE
+// ============================================================================
+
+function autoLearn(projectRoot, options = {}) {
+    console.log(`\n🧠 Smart Auto-Learn Engine v${VERSION}`);
+    console.log(`📂 Project: ${projectRoot}\n`);
+    console.log("─".repeat(50));
+
+    const db = loadKnowledge();
+    let totalAdded = 0;
+
+    // ESLint
+    if (!options.onlyTest && !options.onlyTypescript) {
+        const eslintViolations = runEslintAutoLearn(projectRoot);
+
+        eslintViolations.forEach(v => {
+            const mapping = ESLINT_PATTERN_MAP[v.rule];
+            if (!mapping) return;
+
+            // Check if already exists
+            if (db.lessons.some(l => l.pattern === mapping.pattern)) return;
+
+            const id = `AUTO-${String(db.lessons.length + 1).padStart(3, "0")}`;
+            db.lessons.push({
+                id,
+                pattern: mapping.pattern,
+                message: `${mapping.message} (ESLint: ${v.rule})`,
+                severity: v.severity,
+                source: "auto-eslint",
+                hitCount: v.count,
+                autoEscalated: false,
+                addedAt: new Date().toISOString()
+            });
+            totalAdded++;
+            console.log(`   ✅ Auto-learned: [${id}] ${v.rule} (${v.count} occurrences)`);
+        });
+    }
+
+    // TypeScript
+    if (!options.onlyEslint && !options.onlyTest) {
+        const tsErrors = runTypescriptAutoLearn(projectRoot);
+
+        tsErrors.slice(0, 5).forEach(e => { // Top 5 only
+            const mapping = TS_PATTERN_MAP[e.code];
+            if (!mapping) return;
+
+            if (db.lessons.some(l => l.message.includes(e.code))) return;
+
+            const id = `AUTO-${String(db.lessons.length + 1).padStart(3, "0")}`;
+            db.lessons.push({
+                id,
+                pattern: mapping.pattern,
+                message: `${mapping.message} (${e.code})`,
+                severity: "WARNING",
+                source: "auto-typescript",
+                hitCount: e.count,
+                autoEscalated: false,
+                addedAt: new Date().toISOString()
+            });
+            totalAdded++;
+            console.log(`   ✅ Auto-learned: [${id}] ${e.code} (${e.count} occurrences)`);
+        });
+    }
+
+    // Summary
+    console.log("\n" + "─".repeat(50));
+
+    if (totalAdded > 0) {
+        saveKnowledge(db);
+        console.log(`\n🎓 Auto-learned ${totalAdded} new pattern(s)!`);
+        console.log(`📊 Total lessons in memory: ${db.lessons.length}\n`);
+    } else {
+        console.log("\n✅ No new patterns discovered. Code looks clean!\n");
+    }
+
+    return totalAdded;
+}
+
+// ============================================================================
+// CLI
+// ============================================================================
+
+const args = process.argv.slice(2);
+const projectRoot = process.cwd();
+
+if (args.includes("--help")) {
+    console.log(`
+🧠 Smart Auto-Learn - True Self-Learning Engine
+
+Usage:
+  ag-smart auto-learn              Run all analyzers
+  ag-smart auto-learn --eslint     ESLint only
+  ag-smart auto-learn --typescript TypeScript only
+  ag-smart auto-learn --test       Test failures only
+
+The engine automatically:
+  1. Runs ESLint and learns from violations
+  2. Runs TypeScript and learns from type errors
+  3. Runs tests and learns from failures
+
+Patterns are automatically added to knowledge base!
+`);
+    process.exit(0);
+}
+
+autoLearn(projectRoot, {
+    onlyEslint: args.includes("--eslint"),
+    onlyTypescript: args.includes("--typescript"),
+    onlyTest: args.includes("--test")
+});

package/packages/cli/lib/auto_preview.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+"""
+Auto Preview - Agent Skills Kit
+==============================
+Manages (start/stop/status) the local development server for previewing the application.
+
+Usage:
+    python .agent/scripts/auto_preview.py start [port]
+    python .agent/scripts/auto_preview.py stop
+    python .agent/scripts/auto_preview.py status
+"""
+
+import os
+import sys
+import time
+import json
+import signal
+import argparse
+import subprocess
+from pathlib import Path
+
+AGENT_DIR = Path(".agent")
+PID_FILE = AGENT_DIR / "preview.pid"
+LOG_FILE = AGENT_DIR / "preview.log"
+
+def get_project_root():
+    return Path(".").resolve()
+
+def is_running(pid):
+    try:
+        os.kill(pid, 0)
+        return True
+    except OSError:
+        return False
+
+def get_start_command(root):
+    pkg_file = root / "package.json"
+    if not pkg_file.exists():
+        return None
+    
+    with open(pkg_file, 'r') as f:
+        data = json.load(f)
+    
+    scripts = data.get("scripts", {})
+    if "dev" in scripts:
+        return ["npm", "run", "dev"]
+    elif "start" in scripts:
+        return ["npm", "start"]
+    return None
+
+def start_server(port=3000):
+    if PID_FILE.exists():
+        try:
+            pid = int(PID_FILE.read_text().strip())
+            if is_running(pid):
+                print(f"⚠️  Preview already running (PID: {pid})")
+                return
+        except:
+            pass # Invalid PID file
+
+    root = get_project_root()
+    cmd = get_start_command(root)
+    
+    if not cmd:
+        print("❌ No 'dev' or 'start' script found in package.json")
+        sys.exit(1)
+    
+    # Add port env var if needed (simple heuristic)
+    env = os.environ.copy()
+    env["PORT"] = str(port)
+    
+    print(f"🚀 Starting preview on port {port}...")
+    
+    with open(LOG_FILE, "w") as log:
+        process = subprocess.Popen(
+            cmd,
+            cwd=str(root),
+            stdout=log,
+            stderr=log,
+            env=env,
+            shell=True # Required for npm on windows often, or consistent path handling
+        )
+    
+    PID_FILE.write_text(str(process.pid))
+    print(f"✅ Preview started! (PID: {process.pid})")
+    print(f"   Logs: {LOG_FILE}")
+    print(f"   URL: http://localhost:{port}")
+
+def stop_server():
+    if not PID_FILE.exists():
+        print("ℹ️  No preview server found.")
+        return
+
+    try:
+        pid = int(PID_FILE.read_text().strip())
+        if is_running(pid):
+            # Try gentle kill first
+            os.kill(pid, signal.SIGTERM) if sys.platform != 'win32' else subprocess.call(['taskkill', '/F', '/T', '/PID', str(pid)])
+            print(f"🛑 Preview stopped (PID: {pid})")
+        else:
+            print("ℹ️  Process was not running.")
+    except Exception as e:
+        print(f"❌ Error stopping server: {e}")
+    finally:
+        if PID_FILE.exists():
+            PID_FILE.unlink()
+
+def status_server():
+    running = False
+    pid = None
+    url = "Unknown"
+    
+    if PID_FILE.exists():
+        try:
+            pid = int(PID_FILE.read_text().strip())
+            if is_running(pid):
+                running = True
+                # Heuristic for URL, strictly we should save it
+                url = "http://localhost:3000" 
+        except:
+            pass
+            
+    print("\n=== Preview Status ===")
+    if running:
+        print(f"✅ Status: Running")
+        print(f"🔢 PID: {pid}")
+        print(f"🌐 URL: {url} (Likely)")
+        print(f"📝 Logs: {LOG_FILE}")
+    else:
+        print("⚪ Status: Stopped")
+    print("===================\n")
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("action", choices=["start", "stop", "status"])
+    parser.add_argument("port", nargs="?", default="3000")
+    
+    args = parser.parse_args()
+    
+    if args.action == "start":
+        start_server(int(args.port))
+    elif args.action == "stop":
+        stop_server()
+    elif args.action == "status":
+        status_server()
+
+if __name__ == "__main__":
+    main()

package/packages/cli/lib/checklist.py

@@ -0,0 +1,222 @@
+#!/usr/bin/env python3
+"""
+Master Checklist Runner - Agent Skills Kit
+==========================================
+
+Orchestrates all validation scripts in priority order.
+Use this for incremental validation during development.
+
+Usage:
+    python scripts/checklist.py .                    # Run core checks
+    python scripts/checklist.py . --url <URL>        # Include performance checks
+
+Priority Order:
+    P0: Security Scan (vulnerabilities, secrets)
+    P1: Lint & Type Check (code quality)
+    P2: Schema Validation (if database exists)
+    P3: Test Runner (unit/integration tests)
+    P4: UX Audit (psychology laws, accessibility)
+    P5: SEO Check (meta tags, structure)
+    P6: Performance (lighthouse - requires URL)
+"""
+
+import sys
+import subprocess
+import argparse
+from pathlib import Path
+from typing import List, Tuple, Optional
+
+# ANSI colors for terminal output
+class Colors:
+    HEADER = '\033[95m'
+    BLUE = '\033[94m'
+    CYAN = '\033[96m'
+    GREEN = '\033[92m'
+    YELLOW = '\033[93m'
+    RED = '\033[91m'
+    ENDC = '\033[0m'
+    BOLD = '\033[1m'
+
+def print_header(text: str):
+    print(f"\n{Colors.BOLD}{Colors.CYAN}{'='*60}{Colors.ENDC}")
+    print(f"{Colors.BOLD}{Colors.CYAN}{text.center(60)}{Colors.ENDC}")
+    print(f"{Colors.BOLD}{Colors.CYAN}{'='*60}{Colors.ENDC}\n")
+
+def print_step(text: str):
+    print(f"{Colors.BOLD}{Colors.BLUE}🔄 {text}{Colors.ENDC}")
+
+def print_success(text: str):
+    print(f"{Colors.GREEN}✅ {text}{Colors.ENDC}")
+
+def print_warning(text: str):
+    print(f"{Colors.YELLOW}⚠️  {text}{Colors.ENDC}")
+
+def print_error(text: str):
+    print(f"{Colors.RED}❌ {text}{Colors.ENDC}")
+
+# Define priority-ordered checks
+CORE_CHECKS = [
+    ("Security Scan", ".agent/skills/vulnerability-scanner/scripts/security_scan.py", True),
+    ("Smart Audit", ".agent/scripts/audit.js", True),
+    ("Lint Check", ".agent/skills/lint-and-validate/scripts/lint_runner.py", True),
+    ("Schema Validation", ".agent/skills/database-design/scripts/schema_validator.py", False),
+    ("Test Runner", ".agent/skills/testing-patterns/scripts/test_runner.py", False),
+    ("UX Audit", ".agent/skills/frontend-design/scripts/ux_audit.py", False),
+    ("SEO Check", ".agent/skills/seo-fundamentals/scripts/seo_checker.py", False),
+]
+
+PERFORMANCE_CHECKS = [
+    ("Lighthouse Audit", ".agent/skills/performance-profiling/scripts/lighthouse_audit.py", True),
+    ("Playwright E2E", ".agent/skills/webapp-testing/scripts/playwright_runner.py", False),
+]
+
+def check_script_exists(script_path: Path) -> bool:
+    """Check if script file exists"""
+    return script_path.exists() and script_path.is_file()
+
+def run_script(name: str, script_path: Path, project_path: str, url: Optional[str] = None) -> dict:
+    """
+    Run a validation script and capture results
+    
+    Returns:
+        dict with keys: name, passed, output, skipped
+    """
+    if not check_script_exists(script_path):
+        print_warning(f"{name}: Script not found, skipping")
+        return {"name": name, "passed": True, "output": "", "skipped": True}
+    
+    print_step(f"Running: {name}")
+    
+    # Build command
+    if str(script_path).endswith('.js'):
+        cmd = ["node", str(script_path), project_path]
+    else:
+        cmd = ["python", str(script_path), project_path]
+        
+    if url and ("lighthouse" in script_path.name.lower() or "playwright" in script_path.name.lower()):
+        cmd.append(url)
+    
+    # Run script
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=300  # 5 minute timeout
+        )
+        
+        passed = result.returncode == 0
+        
+        if passed:
+            print_success(f"{name}: PASSED")
+        else:
+            print_error(f"{name}: FAILED")
+            if result.stderr:
+                print(f"  Error: {result.stderr[:200]}")
+        
+        return {
+            "name": name,
+            "passed": passed,
+            "output": result.stdout,
+            "error": result.stderr,
+            "skipped": False
+        }
+    
+    except subprocess.TimeoutExpired:
+        print_error(f"{name}: TIMEOUT (>5 minutes)")
+        return {"name": name, "passed": False, "output": "", "error": "Timeout", "skipped": False}
+    
+    except Exception as e:
+        print_error(f"{name}: ERROR - {str(e)}")
+        return {"name": name, "passed": False, "output": "", "error": str(e), "skipped": False}
+
+def print_summary(results: List[dict]):
+    """Print final summary report"""
+    print_header("📊 CHECKLIST SUMMARY")
+    
+    passed_count = sum(1 for r in results if r["passed"] and not r.get("skipped"))
+    failed_count = sum(1 for r in results if not r["passed"] and not r.get("skipped"))
+    skipped_count = sum(1 for r in results if r.get("skipped"))
+    
+    print(f"Total Checks: {len(results)}")
+    print(f"{Colors.GREEN}✅ Passed: {passed_count}{Colors.ENDC}")
+    print(f"{Colors.RED}❌ Failed: {failed_count}{Colors.ENDC}")
+    print(f"{Colors.YELLOW}⏭️  Skipped: {skipped_count}{Colors.ENDC}")
+    print()
+    
+    # Detailed results
+    for r in results:
+        if r.get("skipped"):
+            status = f"{Colors.YELLOW}⏭️ {Colors.ENDC}"
+        elif r["passed"]:
+            status = f"{Colors.GREEN}✅{Colors.ENDC}"
+        else:
+            status = f"{Colors.RED}❌{Colors.ENDC}"
+        
+        print(f"{status} {r['name']}")
+    
+    print()
+    
+    if failed_count > 0:
+        print_error(f"{failed_count} check(s) FAILED - Please fix before proceeding")
+        return False
+    else:
+        print_success("All checks PASSED ✨")
+        return True
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Run Agent Skills Kit validation checklist",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  python scripts/checklist.py .                      # Core checks only
+  python scripts/checklist.py . --url http://localhost:3000  # Include performance
+        """
+    )
+    parser.add_argument("project", help="Project path to validate")
+    parser.add_argument("--url", help="URL for performance checks (lighthouse, playwright)")
+    parser.add_argument("--skip-performance", action="store_true", help="Skip performance checks even if URL provided")
+    
+    args = parser.parse_args()
+    
+    project_path = Path(args.project).resolve()
+    
+    if not project_path.exists():
+        print_error(f"Project path does not exist: {project_path}")
+        sys.exit(1)
+    
+    print_header("🚀 AGENT SKILLS KIT - MASTER CHECKLIST")
+    print(f"Project: {project_path}")
+    print(f"URL: {args.url if args.url else 'Not provided (performance checks skipped)'}")
+    
+    results = []
+    
+    # Run core checks
+    print_header("📋 CORE CHECKS")
+    for name, script_path, required in CORE_CHECKS:
+        script = project_path / script_path
+        result = run_script(name, script, str(project_path))
+        results.append(result)
+        
+        # If required check fails, stop
+        if required and not result["passed"] and not result.get("skipped"):
+            print_error(f"CRITICAL: {name} failed. Stopping checklist.")
+            print_summary(results)
+            sys.exit(1)
+    
+    # Run performance checks if URL provided
+    if args.url and not args.skip_performance:
+        print_header("⚡ PERFORMANCE CHECKS")
+        for name, script_path, required in PERFORMANCE_CHECKS:
+            script = project_path / script_path
+            result = run_script(name, script, str(project_path), args.url)
+            results.append(result)
+    
+    # Print summary
+    all_passed = print_summary(results)
+    
+    sys.exit(0 if all_passed else 1)
+
+if __name__ == "__main__":
+    main()