mysystem-cli 1.0.0

package/src/commands/init.ts

@@ -0,0 +1,252 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as readline from 'readline/promises';
+import { detectProject } from '../utils/detector';
+
+export async function runInit(projectRoot: string) {
+  console.log('\n🔍 Scanning project codebase...');
+  const detected = detectProject(projectRoot);
+
+  console.log(`Detected application type: \x1b[36m${detected.type}\x1b[0m`);
+  console.log(`Default container port: \x1b[36m${detected.port}\x1b[0m`);
+  console.log(`Requires database: \x1b[36m${detected.hasDatabase ? 'Yes' : 'No'}\x1b[0m`);
+  console.log(`Requires Redis:    \x1b[36m${detected.hasRedis ? 'Yes' : 'No'}\x1b[0m\n`);
+
+  // Prompt the user for overrides using native readline
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  try {
+    const appNameInput = await rl.question(`Enter application name [${detected.name}]: `);
+    const appName = appNameInput.trim() || detected.name;
+
+    const awsRegionInput = await rl.question(`Enter AWS region [us-east-1]: `);
+    const awsRegion = awsRegionInput.trim() || 'us-east-1';
+
+    console.log('Select your AWS hosting tier:');
+    console.log('  \x1b[36m1. Production\x1b[0m [ECS Fargate + RDS + ALB + WAF] (~$17/mo free-tier, ~$51/mo standard)');
+    console.log('  \x1b[36m2. Hobbyist\x1b[0m   [Single EC2 + Docker Compose + Postgres] ($0/mo free-tier, ~$3.20/mo standard)');
+    const tierInput = await rl.question('Choose tier [1]: ');
+    const isProductionTier = tierInput.trim() !== '2';
+
+    let enableDatabase = detected.hasDatabase;
+    let enableRedis = detected.hasRedis;
+    let enableRdsProxy = false;
+
+    if (isProductionTier) {
+      const enableDbInput = await rl.question(`Enable RDS PostgreSQL database? (y/n) [${detected.hasDatabase ? 'y' : 'n'}]: `);
+      enableDatabase = enableDbInput.trim() ? enableDbInput.trim().toLowerCase() === 'y' : detected.hasDatabase;
+
+      const enableRedisInput = await rl.question(`Enable ElastiCache Redis? (y/n) [${detected.hasRedis ? 'y' : 'n'}]: `);
+      enableRedis = enableRedisInput.trim() ? enableRedisInput.trim().toLowerCase() === 'y' : detected.hasRedis;
+
+      if (enableDatabase) {
+        const enableProxyInput = await rl.question(`Enable RDS Proxy (PgBouncer connection pooler)? (y/n) [n]: `);
+        enableRdsProxy = enableProxyInput.trim().toLowerCase() === 'y';
+      }
+    } else {
+      // Hobby tier runs Postgres inside Docker Compose on the same instance (flat cost)
+      enableDatabase = true;
+      enableRedis = false;
+      enableRdsProxy = false;
+    }
+
+    const billingEmailInput = await rl.question(`Enter email for AWS budget alerts (press Enter to skip): `);
+    const billingEmail = billingEmailInput.trim();
+
+    const customDomainInput = await rl.question(`Enable custom domain & HTTPS SSL certificate? (y/n) [n]: `);
+    const enableCustomDomain = customDomainInput.trim().toLowerCase() === 'y';
+
+    let domainName = '';
+    let dnsProvider = 'external';
+    if (enableCustomDomain) {
+      const domainInput = await rl.question(`Enter custom domain (e.g., app.myproduct.com): `);
+      domainName = domainInput.trim();
+
+      const providerInput = await rl.question(`Is your domain DNS managed on AWS Route 53? (y/n) [n]: `);
+      dnsProvider = providerInput.trim().toLowerCase() === 'y' ? 'route53' : 'external';
+    }
+
+    const enableSentryInput = await rl.question(`Enable Sentry Error Tracking? (y/n) [n]: `);
+    const enableSentry = enableSentryInput.trim().toLowerCase() === 'y';
+    let sentryDsn = '';
+    if (enableSentry) {
+      const dsnInput = await rl.question(`Enter Sentry DSN (press Enter to skip and configure later): `);
+      sentryDsn = dsnInput.trim();
+    }
+
+    rl.close();
+
+    console.log('\n🚀 Generating deployment assets...');
+
+    // Find templates directory relative to CLI source or dist
+    let templatesDir = '';
+    const pathsToCheck = [
+      path.join(__dirname, '../../templates'),       // Packaged location relative to dist/commands/
+      path.join(__dirname, '../../../templates'),      // Local dev relative to src/commands/
+      path.join(__dirname, '../../../../templates'),    // Local dev relative to packages/cli/dist/commands
+      path.join(__dirname, '../../../../../templates'),  // Fallback
+    ];
+
+    for (const p of pathsToCheck) {
+      if (fs.existsSync(p)) {
+        templatesDir = p;
+        break;
+      }
+    }
+
+    if (!fs.existsSync(templatesDir)) {
+      throw new Error(`Templates directory not found. Looked in: ${templatesDir}`);
+    }
+
+    // 1. Copy Dockerfile
+    let dockerfileTemplate = '';
+    switch (detected.type) {
+      case 'nextjs':
+        dockerfileTemplate = 'nextjs.Dockerfile';
+        break;
+      case 'react-vite':
+        dockerfileTemplate = 'react.Dockerfile';
+        break;
+      case 'fastapi':
+        dockerfileTemplate = 'fastapi.Dockerfile';
+        break;
+      default:
+        dockerfileTemplate = 'node.Dockerfile';
+    }
+
+    const srcDockerfile = path.join(templatesDir, 'docker', dockerfileTemplate);
+    const destDockerfile = path.join(projectRoot, 'Dockerfile');
+    if (fs.existsSync(srcDockerfile)) {
+      fs.copyFileSync(srcDockerfile, destDockerfile);
+      console.log('  ✅ Created Dockerfile');
+    }
+
+    // 2. Create GitHub Actions folder & copy deploy.yml and destroy.yml
+    const githubWorkflowDir = path.join(projectRoot, '.github', 'workflows');
+    fs.mkdirSync(githubWorkflowDir, { recursive: true });
+    
+    const srcDeployWorkflow = path.join(templatesDir, 'github', isProductionTier ? 'deploy.yml' : 'deploy-ec2.yml');
+    const destDeployWorkflow = path.join(githubWorkflowDir, 'mysystem-deploy.yml');
+    if (fs.existsSync(srcDeployWorkflow)) {
+      let workflowContent = fs.readFileSync(srcDeployWorkflow, 'utf8');
+      workflowContent = workflowContent.replace(/aws-region: us-east-1/g, `aws-region: ${awsRegion}`);
+      fs.writeFileSync(destDeployWorkflow, workflowContent, 'utf8');
+      console.log('  ✅ Created .github/workflows/mysystem-deploy.yml');
+    }
+
+    const srcDestroyWorkflow = path.join(templatesDir, 'github', 'destroy.yml');
+    const destDestroyWorkflow = path.join(githubWorkflowDir, 'mysystem-destroy.yml');
+    if (fs.existsSync(srcDestroyWorkflow)) {
+      let workflowContent = fs.readFileSync(srcDestroyWorkflow, 'utf8');
+      workflowContent = workflowContent.replace(/aws-region: us-east-1/g, `aws-region: ${awsRegion}`);
+      fs.writeFileSync(destDestroyWorkflow, workflowContent, 'utf8');
+      console.log('  ✅ Created .github/workflows/mysystem-destroy.yml');
+    }
+
+    // 3. Create Terraform directory & copy templates
+    const terraformDir = path.join(projectRoot, 'terraform');
+    fs.mkdirSync(terraformDir, { recursive: true });
+
+    const srcTerraformDir = path.join(templatesDir, isProductionTier ? 'terraform' : 'terraform-ec2');
+    if (fs.existsSync(srcTerraformDir)) {
+      const files = fs.readdirSync(srcTerraformDir);
+      for (const file of files) {
+        const filePath = path.join(srcTerraformDir, file);
+        if (fs.statSync(filePath).isFile() && file !== 'bootstrap-oidc.yaml') {
+          fs.copyFileSync(filePath, path.join(terraformDir, file));
+        }
+      }
+      console.log('  ✅ Created Terraform modules in /terraform');
+    }
+
+    // 4. Write terraform.tfvars
+    const tfvarsContent = `aws_region           = "${awsRegion}"
+app_name             = "${appName}"
+container_port       = ${detected.port}
+enable_database      = ${enableDatabase}
+enable_redis         = ${enableRedis}
+enable_rds_proxy     = ${enableRdsProxy}
+billing_email        = "${billingEmail}"
+enable_custom_domain = ${enableCustomDomain}
+domain_name          = "${domainName}"
+dns_provider         = "${dnsProvider}"
+sentry_dsn           = "${sentryDsn}"
+`;
+    fs.writeFileSync(path.join(terraformDir, 'terraform.tfvars'), tfvarsContent, 'utf8');
+    console.log('  ✅ Created terraform/terraform.tfvars');
+
+    // 5. Copy AGENTS.md
+    let srcAgentsMd = '';
+    const agentsPathsToCheck = [
+      path.join(__dirname, '../../AGENTS.md'),
+      path.join(__dirname, '../../../AGENTS.md'),
+      path.join(__dirname, '../../../../AGENTS.md'),
+      path.join(__dirname, '../../../../../AGENTS.md'),
+    ];
+    for (const p of agentsPathsToCheck) {
+      if (fs.existsSync(p)) {
+        srcAgentsMd = p;
+        break;
+      }
+    }
+    const destAgentsMd = path.join(projectRoot, 'AGENTS.md');
+    if (fs.existsSync(srcAgentsMd)) {
+      fs.copyFileSync(srcAgentsMd, destAgentsMd);
+      console.log('  ✅ Created AGENTS.md');
+    }
+
+    // 6. Write project configuration mysystem.json
+    const config = {
+      name: appName,
+      region: awsRegion,
+      port: detected.port,
+      tier: isProductionTier ? 'production' : 'hobbyist',
+      database: enableDatabase,
+      redis: enableRedis,
+      rdsProxy: enableRdsProxy,
+      billingEmail: billingEmail,
+      customDomain: enableCustomDomain,
+      domainName: domainName,
+      dnsProvider: dnsProvider,
+      sentryDsn: sentryDsn,
+      type: detected.type,
+      initializedAt: new Date().toISOString(),
+    };
+    fs.writeFileSync(path.join(projectRoot, 'mysystem.json'), JSON.stringify(config, null, 2), 'utf8');
+    console.log('  ✅ Created mysystem.json');
+
+    // Output Setup Guidance
+    const cfUrl = `https://console.aws.amazon.com/cloudformation/home?region=${awsRegion}#/stacks/create/review?templateURL=https://raw.githubusercontent.com/ai-production-standard/mysystem/main/templates/terraform/bootstrap-oidc.yaml&stackName=mysystem-oidc-${appName}`;
+
+    console.log('\n\x1b[32m✨ MySystem deployment files initialized successfully!\x1b[0m\n');
+    console.log('\x1b[1m🚀 NEXT STEPS TO DEPLOY:\x1b[0m\n');
+    console.log('\x1b[33mStep 1: Connect AWS to GitHub (One-Time Setup)\x1b[0m');
+    console.log('--------------------------------------------');
+    console.log('Click this link to configure a secure OIDC Trust stack in AWS:');
+    console.log(`\x1b[36m${cfUrl}\x1b[0m\n`);
+    console.log('Fill in parameters:');
+    console.log('  - GitHubOrg: Your GitHub Org or username (case-sensitive)');
+    console.log('  - GitHubRepo: Your GitHub repository name (case-sensitive)');
+    console.log('\nClick "Create Stack". Once complete, copy the "RoleARN" from outputs.');
+
+    console.log('\n\x1b[33mStep 2: Save Role ARN as a GitHub Secret\x1b[0m');
+    console.log('----------------------------------------');
+    console.log('Go to your GitHub repository -> Settings -> Secrets and variables -> Actions.');
+    console.log('Add a new secret:');
+    console.log('  - Name:  \x1b[1mAWS_ROLE_ARN\x1b[0m');
+    console.log('  - Value: \x1b[32m<copied-role-arn>\x1b[0m');
+
+    console.log('\n\x1b[33mStep 3: Tell your AI coding agent to push and deploy!\x1b[0m');
+    console.log('----------------------------------------------------');
+    console.log('Simply type in your AI chat:');
+    console.log('  \x1b[32m"I have set up the AWS secrets. Push changes to deploy."\x1b[0m');
+    console.log('\nThe agent will commit, push, and initiate the GitHub Actions pipeline.\n');
+
+  } catch (e: any) {
+    rl.close();
+    console.error(`\x1b[31mError during initialization: ${e.message}\x1b[0m`);
+  }
+}

package/src/commands/logs.ts

@@ -0,0 +1,48 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { spawn, execSync } from 'child_process';
+
+import { ensureAwsCli } from '../utils/installer';
+
+export async function runLogs(projectRoot: string) {
+  const configPath = path.join(projectRoot, 'mysystem.json');
+  if (!fs.existsSync(configPath)) {
+    console.error('\x1b[31mError: MySystem is not initialized in this directory.\x1b[0m');
+    console.error('Run `npx mysystem init` first.');
+    process.exit(1);
+  }
+
+  const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  const logGroupName = `/ecs/${config.name}`;
+  const region = config.region;
+
+  // 1. Ensure AWS CLI is installed
+  const hasAwsCli = await ensureAwsCli();
+  if (!hasAwsCli) {
+    console.log('\nAlternatively, you can view logs in your browser via the AWS CloudWatch Console:');
+    console.log(`👉 \x1b[36mhttps://console.aws.amazon.com/cloudwatch/home?region=${region}#logsV2:log-groups/log-group/%252Fecs%252F${config.name}\x1b[0m\n`);
+    process.exit(1);
+  }
+
+  console.log(`\n☁️  Streaming logs for \x1b[36m${config.name}\x1b[0m [Log Group: ${logGroupName}] in \x1b[32m${region}\x1b[0m...`);
+  console.log('Press \x1b[33mCtrl+C\x1b[0m to stop streaming.\n');
+
+  // Spawn AWS CLI log tailing command
+  const awsLog = spawn('aws', ['logs', 'tail', logGroupName, '--follow', '--region', region], {
+    stdio: 'inherit',
+    shell: true,
+  });
+
+  awsLog.on('close', (code) => {
+    if (code !== 0 && code !== null) {
+      console.error(`\n\x1b[31m❌ AWS CLI log tailing exited with code ${code}.\x1b[0m`);
+      console.log('Make sure your AWS credentials are configured locally by running `aws configure`.');
+    }
+  });
+
+  // Handle Ctrl+C gracefully
+  process.on('SIGINT', () => {
+    awsLog.kill();
+    process.exit(0);
+  });
+}

package/src/index.ts

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+
+import { runInit } from './commands/init';
+import { runAudit } from './commands/audit';
+import { runDestroy } from './commands/destroy';
+import { runLogs } from './commands/logs';
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+function printHelp() {
+  console.log(`
+\x1b[1mMySystem CLI - Production Deployment for Vibecoders\x1b[0m
+
+Usage:
+  npx mysystem-cli <command> [options]
+
+Commands:
+  \x1b[36minit\x1b[0m      Initialize AWS Terraform configs, Dockerfiles, and GitHub workflows.
+  \x1b[36maudit\x1b[0m     Audit local files for production-readiness, security, and compliance.
+  \x1b[36mlogs\x1b[0m      Stream container logs from AWS CloudWatch directly to your terminal.
+  \x1b[36mdestroy\x1b[0m   Teardown all AWS infrastructure resources for this application.
+  \x1b[36mhelp\x1b[0m      Print this help menu.
+
+Examples:
+  $ npx mysystem-cli init
+  $ npx mysystem-cli audit
+  $ npx mysystem-cli logs
+  $ npx mysystem-cli destroy
+  `);
+}
+
+async function main() {
+  switch (command) {
+    case 'init':
+      await runInit(process.cwd());
+      break;
+    case 'audit':
+      runAudit(process.cwd());
+      break;
+    case 'logs':
+      await runLogs(process.cwd());
+      break;
+    case 'destroy':
+      await runDestroy(process.cwd());
+      break;
+    case 'help':
+    case '--help':
+    case '-h':
+      printHelp();
+      break;
+    default:
+      if (!command) {
+        printHelp();
+      } else {
+        console.error(`\x1b[31mUnknown command: ${command}\x1b[0m`);
+        printHelp();
+        process.exit(1);
+      }
+  }
+}
+
+main().catch(err => {
+  console.error('\x1b[31mFatal error occurred:\x1b[0m', err);
+  process.exit(1);
+});

package/src/utils/detector.ts

@@ -0,0 +1,89 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+export interface ProjectInfo {
+  type: 'nextjs' | 'react-vite' | 'node' | 'fastapi' | 'unknown';
+  port: number;
+  hasDatabase: boolean;
+  hasRedis: boolean;
+  name: string;
+}
+
+export function detectProject(projectRoot: string): ProjectInfo {
+  const info: ProjectInfo = {
+    type: 'unknown',
+    port: 3000,
+    hasDatabase: false,
+    hasRedis: false,
+    name: path.basename(projectRoot) || 'mysystem-app',
+  };
+
+  // 1. Read package.json if it exists
+  const packageJsonPath = path.join(projectRoot, 'package.json');
+  if (fs.existsSync(packageJsonPath)) {
+    try {
+      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+      if (packageJson.name) {
+        info.name = packageJson.name;
+      }
+
+      const deps = {
+        ...packageJson.dependencies,
+        ...packageJson.devDependencies,
+      };
+
+      // Detect database dependencies (pg, prisma, typeorm, sequelize, knex, sqlite3, mysql2)
+      const dbDeps = ['pg', 'postgres', 'prisma', 'typeorm', 'sequelize', 'knex', 'sqlite3', 'mysql2'];
+      if (Object.keys(deps).some(dep => dbDeps.includes(dep))) {
+        info.hasDatabase = true;
+      }
+
+      // Detect Redis dependencies
+      const redisDeps = ['redis', 'ioredis', 'bull', 'bullmq', 'handy-redis', 'keyv'];
+      if (Object.keys(deps).some(dep => redisDeps.includes(dep))) {
+        info.hasRedis = true;
+      }
+
+      // Framework detection
+      if (deps['next']) {
+        info.type = 'nextjs';
+        info.port = 3000;
+      } else if (deps['vite'] || deps['react']) {
+        // A Vite React app (or standard React)
+        info.type = 'react-vite';
+        info.port = 80; // React SPAs get served on port 80 via Nginx in production
+      } else if (deps['express'] || deps['koa'] || deps['fastify'] || deps['nest']) {
+        info.type = 'node';
+        info.port = 3000;
+      } else {
+        info.type = 'node';
+        info.port = 3000;
+      }
+    } catch (e) {
+      // Ignore JSON parse errors and continue
+    }
+  }
+
+  // 2. Read requirements.txt or main.py if Python
+  const reqTxtPath = path.join(projectRoot, 'requirements.txt');
+  const mainPyPath = path.join(projectRoot, 'main.py');
+  if (fs.existsSync(reqTxtPath) || fs.existsSync(mainPyPath)) {
+    info.type = 'fastapi';
+    info.port = 8000;
+
+    if (fs.existsSync(reqTxtPath)) {
+      const reqs = fs.readFileSync(reqTxtPath, 'utf8');
+      const dbTerms = ['postgresql', 'psycopg2', 'sqlalchemy', 'tortoise-orm', 'peewee', 'asyncpg'];
+      if (dbTerms.some(term => reqs.toLowerCase().includes(term))) {
+        info.hasDatabase = true;
+      }
+
+      const redisTerms = ['redis', 'django-redis', 'celery'];
+      if (redisTerms.some(term => reqs.toLowerCase().includes(term))) {
+        info.hasRedis = true;
+      }
+    }
+  }
+
+  return info;
+}

package/src/utils/installer.ts

@@ -0,0 +1,89 @@
+import { execSync, spawnSync } from 'child_process';
+import * as readline from 'readline/promises';
+
+export async function ensureAwsCli(): Promise<boolean> {
+  // 1. Check if AWS CLI is already installed
+  try {
+    execSync('aws --version', { stdio: 'ignore' });
+    return true;
+  } catch (e) {
+    // AWS CLI not installed
+  }
+
+  console.log('\n\x1b[33m⚠️  AWS CLI is not installed on your system.\x1b[0m');
+  console.log('The AWS CLI is required to stream container logs and manage local credentials.');
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  const answer = await rl.question('\nWould you like MySystem to install the AWS CLI automatically? (y/n) [y]: ');
+  rl.close();
+
+  if (answer.trim().toLowerCase() === 'n') {
+    return false;
+  }
+
+  const platform = process.platform;
+  console.log(`\n⚙️  Installing AWS CLI for \x1b[36m${platform}\x1b[0m...`);
+
+  try {
+    if (platform === 'win32') {
+      // Windows: Use winget (native Windows Package Manager)
+      console.log('Running winget installer...');
+      const res = spawnSync('winget', ['install', '--id', 'Amazon.AWSCLI', '--silent', '--accept-source-agreements', '--accept-package-agreements'], {
+        stdio: 'inherit',
+        shell: true,
+      });
+      if (res.status === 0) {
+        console.log('\x1b[32m✅ AWS CLI installed successfully! You may need to restart your terminal for changes to take effect.\x1b[0m');
+        return true;
+      }
+    } else if (platform === 'darwin') {
+      // macOS: Try homebrew first
+      let hasBrew = false;
+      try {
+        execSync('brew --version', { stdio: 'ignore' });
+        hasBrew = true;
+      } catch (e) {}
+
+      if (hasBrew) {
+        console.log('Running: brew install awscli...');
+        const res = spawnSync('brew', ['install', 'awscli'], { stdio: 'inherit' });
+        if (res.status === 0) {
+          console.log('\x1b[32m✅ AWS CLI installed successfully via Homebrew!\x1b[0m');
+          return true;
+        }
+      } else {
+        // Fallback: Download pkg installer
+        console.log('Downloading AWS CLI macOS package...');
+        execSync('curl "https://awscli.amazonaws.com/AWSCLIV2.pkg" -o "/tmp/AWSCLIV2.pkg"', { stdio: 'inherit' });
+        console.log('Installing package (requires sudo privileges)...');
+        const res = spawnSync('sudo', ['installer', '-pkg', '/tmp/AWSCLIV2.pkg', '-target', '/'], { stdio: 'inherit' });
+        if (res.status === 0) {
+          console.log('\x1b[32m✅ AWS CLI installed successfully!\x1b[0m');
+          return true;
+        }
+      }
+    } else if (platform === 'linux') {
+      // Linux install
+      console.log('Downloading AWS CLI Linux package...');
+      execSync('curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "/tmp/awscliv2.zip"', { stdio: 'inherit' });
+      execSync('unzip -q /tmp/awscliv2.zip -d /tmp', { stdio: 'inherit' });
+      console.log('Installing package (requires sudo privileges)...');
+      const res = spawnSync('sudo', ['/tmp/aws/install', '--update'], { stdio: 'inherit' });
+      if (res.status === 0) {
+        console.log('\x1b[32m✅ AWS CLI installed successfully!\x1b[0m');
+        return true;
+      }
+    }
+  } catch (err: any) {
+    console.error(`\x1b[31mInstallation failed: ${err.message}\x1b[0m`);
+  }
+
+  console.log('\n\x1b[31m❌ Automatic installation failed.\x1b[0m');
+  console.log('Please install the AWS CLI manually:');
+  console.log('👉 \x1b[36mhttps://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html\x1b[0m\n');
+  return false;
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "CommonJS",
+    "moduleResolution": "node",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}