@donotdev/cli 0.0.14 → 0.0.15

package/dist/bin/commands/sync-secrets.js

@@ -7534,11 +7534,39 @@ var init_PathResolver = __esm({
 });
 
 // packages/tooling/src/utils/errors.ts
-var DoNotDevError;
+var DO_NOT_DEV_ERROR_CODES, DoNotDevError;
 var init_errors = __esm({
   "packages/tooling/src/utils/errors.ts"() {
     "use strict";
     init_utils();
+    DO_NOT_DEV_ERROR_CODES = {
+      CONFIGURATION_ERROR: "configuration-error",
+      CONFIG_NOT_FOUND: "config-not-found",
+      CONFIG_INVALID: "config-invalid",
+      PATH_RESOLUTION_ERROR: "path-resolution-error",
+      FILE_OPERATION_ERROR: "file-operation-error",
+      FILE_NOT_FOUND: "file-not-found",
+      PERMISSION_DENIED: "permission-denied",
+      GENERATION_ERROR: "generation-error",
+      TEMPLATE_ERROR: "template-error",
+      TEMPLATE_NOT_FOUND: "template-not-found",
+      CLI_EXECUTION_ERROR: "cli-execution-error",
+      COMMAND_NOT_FOUND: "command-not-found",
+      COMMAND_FAILED: "command-failed",
+      VALIDATION_ERROR: "validation-error",
+      SCHEMA_ERROR: "schema-error",
+      DEPENDENCY_ERROR: "dependency-error",
+      DEPENDENCY_NOT_FOUND: "dependency-not-found",
+      DEPENDENCY_VERSION_ERROR: "dependency-version-error",
+      INVALID_ARGUMENT: "invalid-argument",
+      MISSING_ARGUMENT: "missing-argument",
+      MISSING_PROJECT_ID: "missing-project-id",
+      FIREBASE_CLI_ERROR: "firebase-cli-error",
+      DEPLOYMENT_FAILED: "deployment-failed",
+      OPERATION_CANCELLED: "operation-cancelled",
+      TIMEOUT_ERROR: "timeout-error",
+      UNKNOWN_ERROR: "unknown-error"
+    };
     DoNotDevError = class _DoNotDevError extends Error {
       /** The error code categorizing this error */
       code;
@@ -7558,7 +7586,7 @@ var init_errors = __esm({
        * @param {Record<string, any>} [options.context] - Additional context data
        * @param {boolean} [options.displayable=true] - Whether this error should be displayed to the user
        */
-      constructor(message, code = "unknown-error", options) {
+      constructor(message, code = DO_NOT_DEV_ERROR_CODES.UNKNOWN_ERROR, options) {
         super(message);
         this.name = "DoNotDevError";
         this.code = code;
@@ -7589,7 +7617,7 @@ var init_errors = __esm({
        * @param {boolean} [options.displayable=true] - Whether this error should be displayed to the user
        * @returns {DoNotDevError} New DoNotDev error wrapping the original
        */
-      static from(error2, context, code = "unknown-error", options) {
+      static from(error2, context, code = DO_NOT_DEV_ERROR_CODES.UNKNOWN_ERROR, options) {
         if (!(error2 instanceof Error)) {
           return new _DoNotDevError(
             `Unknown error: ${String(error2)}`,
@@ -7626,21 +7654,21 @@ var init_errors = __esm({
         }
         const message = error2.message.toLowerCase();
         if (error2.name === "ValidationError" || message.includes("validation")) {
-          return "validation-error";
+          return DO_NOT_DEV_ERROR_CODES.VALIDATION_ERROR;
         }
         if (message.includes("not found") || message.includes("no such file")) {
-          return "file-not-found";
+          return DO_NOT_DEV_ERROR_CODES.FILE_NOT_FOUND;
         }
         if (message.includes("permission") || message.includes("access denied")) {
-          return "permission-denied";
+          return DO_NOT_DEV_ERROR_CODES.PERMISSION_DENIED;
         }
         if (message.includes("timeout") || message.includes("timed out")) {
-          return "timeout-error";
+          return DO_NOT_DEV_ERROR_CODES.TIMEOUT_ERROR;
         }
         if (message.includes("dependency") || message.includes("module not found")) {
-          return "dependency-error";
+          return DO_NOT_DEV_ERROR_CODES.DEPENDENCY_ERROR;
         }
-        return "unknown-error";
+        return DO_NOT_DEV_ERROR_CODES.UNKNOWN_ERROR;
       }
     };
   }
@@ -7717,18 +7745,7 @@ var init_utils = __esm({
   }
 });
 
-// packages/cli/src/bin/commands/sync-secrets.ts
-init_utils();
-
-// packages/tooling/src/index.ts
-init_utils();
-
-// packages/tooling/src/cli/index.ts
-init_utils();
-
 // packages/tooling/src/utils/cli-input.ts
-init_utils();
-init_dist2();
 async function askForSelection(message, choices, defaultValue = 0) {
   const options = choices.map((choice) => ({
     value: choice.value,
@@ -7746,13 +7763,16 @@ async function askForSelection(message, choices, defaultValue = 0) {
   }
   return result;
 }
+var init_cli_input = __esm({
+  "packages/tooling/src/utils/cli-input.ts"() {
+    "use strict";
+    init_utils();
+    init_dist2();
+  }
+});
 
 // packages/tooling/src/apps/sync-secrets.ts
-init_utils();
 import { spawnSync } from "node:child_process";
-init_cli_output();
-init_errors();
-init_pathResolver();
 function parseEnvFile(filePath) {
   if (!pathExists(filePath)) {
     throw new DoNotDevError(
@@ -7761,7 +7781,8 @@ function parseEnvFile(filePath) {
       { context: { filePath } }
     );
   }
-  const content = readSync(filePath, { format: "text" });
+  const contentRaw = readSync(filePath, { format: "text" });
+  const content = typeof contentRaw === "string" ? contentRaw : null;
   if (!content) {
     throw new Error(`Failed to read secrets file: ${filePath}`);
   }
@@ -7836,7 +7857,8 @@ function detectFirebaseProjectId(cwd) {
   const firebasercPath = joinPath(searchDir, ".firebaserc");
   if (pathExists(firebasercPath)) {
     try {
-      const firebaserc = readSync(firebasercPath, { format: "json" });
+      const firebasercRaw = readSync(firebasercPath, { format: "json" });
+      const firebaserc = firebasercRaw && typeof firebasercRaw === "object" ? firebasercRaw : null;
       if (firebaserc && firebaserc.projects?.default) {
         return firebaserc.projects.default;
       }
@@ -7849,7 +7871,8 @@ function detectFirebaseProjectId(cwd) {
     const firebasercPath2 = joinPath(current, ".firebaserc");
     if (pathExists(firebasercPath2)) {
       try {
-        const firebaserc = readSync(firebasercPath2, { format: "json" });
+        const firebasercRaw = readSync(firebasercPath2, { format: "json" });
+        const firebaserc = firebasercRaw && typeof firebasercRaw === "object" ? firebasercRaw : null;
         if (firebaserc && firebaserc.projects?.default) {
           return firebaserc.projects.default;
         }
@@ -8065,12 +8088,99 @@ function setVercelSecret(key, value, projectId, dryRun = false) {
     );
   }
 }
+function detectGitHubRepo() {
+  try {
+    const result = spawnSync("git", ["remote", "get-url", "origin"], {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    if (result.status !== 0 || !result.stdout) return void 0;
+    const url = result.stdout.trim();
+    const sshMatch = url.match(/github\.com[:/]([^/]+\/[^/.]+)/);
+    if (sshMatch) return sshMatch[1];
+    const httpsMatch = url.match(/github\.com\/([^/]+\/[^/.]+)/);
+    if (httpsMatch) return httpsMatch[1];
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function setGitHubSecret(key, value, repo, dryRun = false) {
+  if (dryRun) {
+    log.info(
+      `[DRY RUN] Would set GitHub secret: ${key}${repo ? ` (repo: ${repo})` : ""}`
+    );
+    return;
+  }
+  try {
+    log.info(`Setting GitHub secret: ${key}${repo ? ` (repo: ${repo})` : ""}`);
+    const args = ["secret", "set", key];
+    if (repo) {
+      args.push("--repo", repo);
+    }
+    const result = spawnSync("gh", args, {
+      input: value,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    if (result.error) {
+      throw result.error;
+    }
+    if (result.status !== 0) {
+      const stderr = result.stderr?.toString() || "";
+      const stdout = result.stdout?.toString() || "";
+      const errorOutput = stderr || stdout;
+      if (errorOutput.includes("not logged in") || errorOutput.includes("authentication")) {
+        throw new DoNotDevError(
+          `GitHub CLI authentication required. Run 'gh auth login' to authenticate.`,
+          "permission-denied",
+          { context: { key, error: errorOutput } }
+        );
+      }
+      throw new Error(
+        `gh CLI exited with code ${result.status}
+${errorOutput}`
+      );
+    }
+    log.success(`GitHub secret ${key} set successfully`);
+  } catch (err) {
+    if (err instanceof DoNotDevError) throw err;
+    log.error(`Failed to set GitHub secret ${key}:`, err);
+    throw new DoNotDevError(
+      `Failed to set GitHub secret ${key}`,
+      "command-failed",
+      {
+        context: {
+          target: "github",
+          key,
+          error: err instanceof Error ? err.message : String(err)
+        }
+      }
+    );
+  }
+}
+function uploadServiceAccountToGitHub(appDir, repo, dryRun = false, staging = false) {
+  const fileName = staging ? "service-account-key.staging.json" : "service-account-key.json";
+  const secretName = staging ? "FIREBASE_SERVICE_ACCOUNT_STAGING" : "FIREBASE_SERVICE_ACCOUNT";
+  const filePath = joinPath(appDir, fileName);
+  if (!pathExists(filePath)) {
+    log.debug(`No ${fileName} found in ${appDir}, skipping GitHub upload`);
+    return;
+  }
+  const contentRaw = readSync(filePath, { format: "text" });
+  const content = typeof contentRaw === "string" ? contentRaw : null;
+  if (!content) return;
+  const encoded = Buffer2.from(content).toString("base64");
+  setGitHubSecret(secretName, encoded, repo, dryRun);
+}
 async function main(options = {}) {
   const config = {
     envFile: options.envFile || ".env",
     platform: options.platform,
     projectId: options.projectId,
     vercelProjectId: options.vercelProjectId,
+    target: options.target || "runtime",
+    repo: options.repo,
     dryRun: options.dryRun ?? false,
     verbose: options.verbose ?? false
   };
@@ -8082,20 +8192,22 @@ Usage: bun run sync-secrets [options]
 
 Options:
   --env-file <path>       Path to .env file (default: .env)
-  --platform <platform>   Platform to sync to: 'firebase' or 'vercel' (auto-detected if not specified)
+  --target <target>       Sync target: 'runtime' (default) or 'github'
+  --platform <platform>   Platform to sync to: 'firebase' or 'vercel' (runtime target only, auto-detected)
   --project <id>          Firebase project ID (for Firebase platform)
   --vercel-project <id>   Vercel project ID (for Vercel platform)
+  --repo <owner/repo>     GitHub repository (github target only, auto-detected from git remote)
   --dry-run, --dry        Show what would be done without actually setting secrets
   --verbose               Show detailed output
   --help                  Show this help message
 
 Examples:
-  bun run sync-secrets
-  bun run sync-secrets --platform=firebase
-  bun run sync-secrets --platform=vercel
-  bun run sync-secrets --dry-run
-  bun run sync-secrets --env-file .env.production --project my-project
-  bun run sync-secrets --platform=vercel --vercel-project my-vercel-project
+  dndev sync-secrets                                      # sync to Firebase/Vercel runtime
+  dndev sync-secrets --target github                      # sync to GitHub Secrets
+  dndev sync-secrets --target github --repo owner/repo    # sync to specific repo
+  dndev sync-secrets --platform=firebase
+  dndev sync-secrets --dry-run
+  dndev sync-secrets --env-file .env.production --project my-project
         `);
     return 0;
   }
@@ -8135,6 +8247,51 @@ Examples:
       }
     }
     const envFilePath = joinPath(currentDir, config.envFile);
+    const syncTarget = config.target || "runtime";
+    if (syncTarget === "github") {
+      const repo = config.repo || detectGitHubRepo();
+      if (!repo) {
+        log.error(
+          "Could not detect GitHub repository. Use --repo owner/repo or ensure a GitHub remote is configured."
+        );
+        return 1;
+      }
+      log.info(`Syncing secrets to GitHub repository: ${repo}`);
+      const secrets2 = parseEnvFile(envFilePath);
+      const secretKeys2 = Object.keys(secrets2);
+      if (secretKeys2.length === 0) {
+        log.info("No secrets found in .env file");
+      } else {
+        log.info(`Found ${secretKeys2.length} secrets to sync to GitHub:`);
+        secretKeys2.forEach((key) => log.info(`  ${key}`));
+        for (const [key, value] of Object.entries(secrets2)) {
+          setGitHubSecret(key, value, repo, config.dryRun);
+        }
+      }
+      if (firebaseProjectDir) {
+        uploadServiceAccountToGitHub(
+          firebaseProjectDir,
+          repo,
+          config.dryRun,
+          false
+        );
+        uploadServiceAccountToGitHub(
+          firebaseProjectDir,
+          repo,
+          config.dryRun,
+          true
+        );
+      } else {
+        uploadServiceAccountToGitHub(currentDir, repo, config.dryRun, false);
+        uploadServiceAccountToGitHub(currentDir, repo, config.dryRun, true);
+      }
+      if (config.dryRun) {
+        log.success("\nDry run completed. No GitHub secrets were set.");
+      } else {
+        log.success("\nAll secrets synced to GitHub successfully!");
+      }
+      return 0;
+    }
     const platform = config.platform || detectPlatform();
     log.info(`Reading secrets from: ${envFilePath}`);
     if (config.verbose) {
@@ -8195,6 +8352,26 @@ All secrets synced successfully to ${platform}!`);
     return 1;
   }
 }
+var init_sync_secrets = __esm({
+  "packages/tooling/src/apps/sync-secrets.ts"() {
+    "use strict";
+    init_utils();
+    init_cli_input();
+    init_cli_output();
+    init_errors();
+    init_pathResolver();
+  }
+});
+
+// packages/cli/src/bin/commands/sync-secrets.ts
+init_utils();
+
+// packages/tooling/src/index.ts
+init_utils();
+
+// packages/tooling/src/cli/index.ts
+init_utils();
+init_sync_secrets();
 export {
   main
 };

package/dist/bin/commands/type-check.d.ts

@@ -0,0 +1,14 @@
+export interface TypeCheckOptions {
+    /** Optional: scope to one app subdirectory */
+    app?: string;
+    verbose?: boolean;
+    quiet?: boolean;
+}
+/**
+ * Type-check all packages with a `type-check` script in the consumer project.
+ *
+ * @param options - Command options
+ * @returns Exit code: 0 = all pass, 1 = any failure
+ */
+export declare function main(options?: TypeCheckOptions): Promise<number>;
+//# sourceMappingURL=type-check.d.ts.map

package/dist/bin/commands/type-check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-check.d.ts","sourceRoot":"","sources":["../../../src/bin/commands/type-check.ts"],"names":[],"mappings":"AAgBA,MAAM,WAAW,gBAAgB;IAC/B,8CAA8C;IAC9C,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAoQD;;;;;GAKG;AACH,wBAAsB,IAAI,CAAC,OAAO,GAAE,gBAAqB,GAAG,OAAO,CAAC,MAAM,CAAC,CAkF1E"}

package/dist/bin/commands/type-check.js

@@ -0,0 +1,314 @@
+// packages/cli/src/bin/commands/type-check.ts
+/**
+ * @fileoverview dndev tc — TypeScript type-check for consumer projects
+ * Discovers packages with a `type-check` script and runs them.
+ * Agent-friendly: plain structured output when not a TTY.
+ *
+ * @version 0.0.1
+ * @since 0.0.1
+ * @author AMBROISE PARK Consulting
+ */
+import { spawn } from 'node:child_process';
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+// ---------------------------------------------------------------------------
+// Package manager detection
+// ---------------------------------------------------------------------------
+/**
+ * Detect package manager from lockfile in a directory.
+ * Walks up to find the nearest lockfile.
+ */
+function detectPackageManager(dir) {
+    let current = dir;
+    for (let i = 0; i < 10; i++) {
+        if (existsSync(join(current, 'bun.lockb')))
+            return 'bun';
+        if (existsSync(join(current, 'yarn.lock')))
+            return 'yarn';
+        if (existsSync(join(current, 'pnpm-lock.yaml')))
+            return 'pnpm';
+        if (existsSync(join(current, 'package-lock.json')))
+            return 'npm';
+        const parent = join(current, '..');
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return 'bun'; // default
+}
+// ---------------------------------------------------------------------------
+// Package discovery
+// ---------------------------------------------------------------------------
+const SKIP_DIRS = new Set([
+    'node_modules',
+    'dist',
+    '.next',
+    '.turbo',
+    'build',
+    'coverage',
+    '.git',
+    '.bun',
+]);
+/**
+ * Find all package.json files recursively from a root directory,
+ * skipping common non-source directories.
+ */
+function findPackageJsonFiles(rootDir) {
+    const results = [];
+    function walk(dir) {
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (SKIP_DIRS.has(entry))
+                continue;
+            const fullPath = join(dir, entry);
+            try {
+                const stat = statSync(fullPath);
+                if (stat.isDirectory()) {
+                    walk(fullPath);
+                }
+                else if (entry === 'package.json') {
+                    results.push(fullPath);
+                }
+            }
+            catch {
+                // skip inaccessible
+            }
+        }
+    }
+    walk(rootDir);
+    return results;
+}
+/**
+ * Discover packages with a `type-check` script in cwd.
+ * Optionally filtered to packages whose path or name includes `filter`.
+ */
+function discoverPackages(cwd, filter) {
+    const packageFiles = findPackageJsonFiles(cwd);
+    const packages = [];
+    for (const pkgFile of packageFiles) {
+        try {
+            // Read synchronously — we're in a CLI
+            const raw = readFileSync(pkgFile, 'utf-8');
+            const json = JSON.parse(raw);
+            const name = typeof json.name === 'string' ? json.name : undefined;
+            const scripts = (json.scripts ?? {});
+            if (!scripts['type-check'])
+                continue;
+            const pkgDir = join(pkgFile, '..');
+            // Compute relative path from cwd
+            const relativePath = pkgDir === cwd
+                ? '.'
+                : pkgDir.startsWith(cwd + '/')
+                    ? pkgDir.slice(cwd.length + 1)
+                    : pkgDir;
+            if (filter) {
+                const filterLower = filter.toLowerCase();
+                const nameLower = (name ?? '').toLowerCase();
+                const relLower = relativePath.toLowerCase();
+                if (!nameLower.includes(filterLower) && !relLower.includes(filterLower)) {
+                    continue;
+                }
+            }
+            packages.push({
+                name: name ?? relativePath,
+                path: pkgDir,
+                relativePath,
+            });
+        }
+        catch {
+            continue;
+        }
+    }
+    return packages.sort((a, b) => a.name.localeCompare(b.name));
+}
+// ---------------------------------------------------------------------------
+// TypeScript error parsing
+// ---------------------------------------------------------------------------
+/**
+ * Parse TypeScript errors from tsc output.
+ * Returns lines matching `error TS####` format.
+ */
+function parseTypeScriptErrors(output) {
+    const lines = output.split('\n');
+    const errorLines = [];
+    const errorPattern = /error TS\d+/;
+    let errorCount = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (!line)
+            continue;
+        if (errorPattern.test(line)) {
+            errorCount++;
+            errorLines.push(line.trim());
+            // Include indented continuation line if present
+            if (i + 1 < lines.length) {
+                const next = lines[i + 1];
+                if (next && /^\s+/.test(next)) {
+                    errorLines.push(next.trimEnd());
+                    i++;
+                }
+            }
+        }
+    }
+    return { errorCount, errorLines };
+}
+// ---------------------------------------------------------------------------
+// Per-package type-check runner
+// ---------------------------------------------------------------------------
+/**
+ * Run `bun run type-check` (or appropriate package manager) in a package dir.
+ */
+function runTypeCheckInPackage(pkg, pm) {
+    return new Promise((resolve) => {
+        let stdout = '';
+        let stderr = '';
+        const [cmd, ...cmdArgs] = pm === 'bun'
+            ? ['bun', 'run', 'type-check']
+            : pm === 'yarn'
+                ? ['yarn', 'run', 'type-check']
+                : pm === 'pnpm'
+                    ? ['pnpm', 'run', 'type-check']
+                    : ['npm', 'run', 'type-check'];
+        const child = spawn(cmd, cmdArgs, {
+            cwd: pkg.path,
+            stdio: 'pipe',
+            shell: true,
+        });
+        child.stdout?.on('data', (data) => {
+            stdout += data.toString('utf8');
+        });
+        child.stderr?.on('data', (data) => {
+            stderr += data.toString('utf8');
+        });
+        child.on('close', (code) => {
+            const allOutput = stdout + (stderr ? '\n' + stderr : '');
+            const { errorCount, errorLines } = parseTypeScriptErrors(allOutput);
+            resolve({
+                success: code === 0,
+                output: allOutput,
+                errors: errorLines,
+                errorCount,
+            });
+        });
+        child.on('error', (err) => {
+            const msg = `Failed to run type-check: ${err.message}`;
+            resolve({
+                success: false,
+                output: msg,
+                errors: [msg],
+                errorCount: 1,
+            });
+        });
+    });
+}
+// ---------------------------------------------------------------------------
+// TTY spinner (clack) — only imported when running in TTY
+// ---------------------------------------------------------------------------
+async function runWithSpinner(pkg, pm) {
+    // Dynamic import to avoid side effects when not needed
+    const { spinner } = await import('@clack/prompts');
+    const s = spinner();
+    s.start(`Type-checking ${pkg.name} (${pkg.relativePath})...`);
+    const result = await runTypeCheckInPackage(pkg, pm);
+    if (result.success) {
+        s.stop(`${pkg.name} — No errors`);
+    }
+    else {
+        s.stop(`${pkg.name} — ${result.errorCount} error(s)`);
+    }
+    return result;
+}
+// ---------------------------------------------------------------------------
+// Main entry point
+// ---------------------------------------------------------------------------
+/**
+ * Type-check all packages with a `type-check` script in the consumer project.
+ *
+ * @param options - Command options
+ * @returns Exit code: 0 = all pass, 1 = any failure
+ */
+export async function main(options = {}) {
+    const cwd = process.cwd();
+    const isTTY = process.stdout.isTTY;
+    const packages = discoverPackages(cwd, options.app);
+    if (packages.length === 0) {
+        if (isTTY) {
+            console.log('No packages with a type-check script found.');
+            if (options.app) {
+                console.log(`  Filter: ${options.app}`);
+            }
+        }
+        else {
+            console.log('RESULT: 0 passed, 0 failed, 0 total errors');
+        }
+        return 0;
+    }
+    const pm = detectPackageManager(cwd);
+    let passed = 0;
+    let failed = 0;
+    let totalErrors = 0;
+    if (isTTY) {
+        // TTY mode: spinner per package + summary
+        const { intro, outro } = await import('@clack/prompts');
+        intro('dndev tc — TypeScript type-check');
+        const failedPackages = [];
+        for (const pkg of packages) {
+            const result = await runWithSpinner(pkg, pm);
+            if (result.success) {
+                passed++;
+            }
+            else {
+                failed++;
+                totalErrors += result.errorCount;
+                failedPackages.push({ pkg, result });
+            }
+        }
+        if (failedPackages.length > 0 && options.verbose) {
+            const { log } = await import('@clack/prompts');
+            for (const { pkg, result } of failedPackages) {
+                log.error(`\n${pkg.name} (${pkg.relativePath}) — ${result.errorCount} error(s):`);
+                for (const line of result.errors) {
+                    log.error(`  ${line}`);
+                }
+            }
+        }
+        else if (failedPackages.length > 0) {
+            const { log } = await import('@clack/prompts');
+            log.info('Run with --verbose to see detailed error messages');
+        }
+        if (failed === 0) {
+            outro(`All ${passed} package(s) passed type-check`);
+        }
+        else {
+            outro(`${passed} passed, ${failed} failed, ${totalErrors} total error(s)`);
+        }
+    }
+    else {
+        // Non-TTY (agent) mode: structured plain text
+        for (const pkg of packages) {
+            console.log(`CHECKING ${pkg.name} (${pkg.relativePath})`);
+            const result = await runTypeCheckInPackage(pkg, pm);
+            if (result.success) {
+                console.log(`PASS ${pkg.name}`);
+                passed++;
+            }
+            else {
+                console.log(`FAIL ${pkg.name}: ${result.errorCount} error(s)`);
+                for (const line of result.errors) {
+                    console.log(`  ${line}`);
+                }
+                failed++;
+                totalErrors += result.errorCount;
+            }
+        }
+        console.log(`RESULT: ${passed} passed, ${failed} failed, ${totalErrors} total errors`);
+    }
+    return failed > 0 ? 1 : 0;
+}
+//# sourceMappingURL=type-check.js.map