simplify cli output

packages/cli/src/commands/codegen.ts

···
 import { ensureDir } from "@std/fs";
 import { generateTypeScript } from "@slices/codegen";
 import { logger } from "../utils/logger.ts";
-import { findLexiconFiles, readAndParseLexicon } from "../utils/lexicon.ts";
+import {
+  findLexiconFiles,
+  validateLexiconFiles,
+  printValidationSummary,
+} from "../utils/lexicon.ts";
 import { SlicesConfigLoader, mergeConfig } from "../utils/config.ts";
 
 function showCodegenHelp() {
···
     --lexicons <PATH>      Directory containing lexicon files (default: ./lexicons or from slices.json)
     --output <PATH>        Output file path (default: ./generated_client.ts or from slices.json)
     --slice <SLICE_URI>    Target slice URI (required, or from slices.json)
-    --exclude-slices       Exclude @slices/client integration
+    --include-slices       Include Slices XRPC methods
     -h, --help            Show this help message
 
 EXAMPLES:
     slices codegen --slice at://did:plc:example/slice
     slices codegen --lexicons ./my-lexicons --output ./src/client.ts --slice at://did:plc:example/slice
-    slices codegen --exclude-slices --slice at://did:plc:example/slice
+    slices codegen --include-slices --slice at://did:plc:example/slice
     slices codegen  # Uses config from slices.json
 `);
 }
···
   _globalArgs: Record<string, unknown>
 ): Promise<void> {
   const args = parseArgs(commandArgs as string[], {
-    boolean: ["help", "exclude-slices"],
+    boolean: ["help", "include-slices"],
     string: ["lexicons", "output", "slice"],
     alias: {
       h: "help",
···
   if (!mergedConfig.slice) {
     logger.error("--slice is required");
     if (!slicesConfig.slice) {
-      logger.info("💡 Tip: Create a slices.json file with your slice URI to avoid passing --slice every time");
+      logger.info(
+        "💡 Tip: Create a slices.json file with your slice URI to avoid passing --slice every time"
+      );
     }
     console.log("\nRun 'slices codegen --help' for usage information.");
     Deno.exit(1);
···
   const lexiconsPath = resolve(mergedConfig.lexiconPath!);
   const outputPath = resolve(mergedConfig.clientOutputPath!);
   const sliceUri = mergedConfig.slice!;
-  const excludeSlices = args["exclude-slices"] as boolean;
-
-  logger.step("🔍 Finding lexicon files...");
-  logger.info(`📁 Scanning directory: ${lexiconsPath}`);
+  const excludeSlices = !args["include-slices"] as boolean;
 
   try {
     const lexiconFiles = await findLexiconFiles(lexiconsPath);
···
       return;
     }
 
-    logger.info(`📄 Found ${lexiconFiles.length} lexicon files`);
-
-    logger.step("📖 Reading lexicon files...");
-    const lexicons: unknown[] = [];
+    const validationResult = await validateLexiconFiles(lexiconFiles, false);
 
-    for (let i = 0; i < lexiconFiles.length; i++) {
-      const filePath = lexiconFiles[i];
-      logger.progress("Reading lexicons", i + 1, lexiconFiles.length);
-
-      try {
-        const content = await readAndParseLexicon(filePath);
-        lexicons.push(content);
-      } catch (error) {
-        const err = error as Error;
-        logger.warn(`Failed to read ${filePath}: ${err.message}`);
-      }
+    if (validationResult.invalidFiles > 0) {
+      printValidationSummary(validationResult);
+      logger.error("Cannot generate client with invalid lexicon files");
+      Deno.exit(1);
     }
 
-    if (lexicons.length === 0) {
+    if (validationResult.validFiles === 0) {
       logger.error("No valid lexicon files found");
       Deno.exit(1);
     }
 
-    logger.step("⚡ Generating TypeScript client...");
-    const generatedCode = await generateTypeScript(lexicons, {
+    const validLexicons = validationResult.files
+      .filter((f) => f.valid)
+      .map((f) => f.content);
+
+    const generatedCode = await generateTypeScript(validLexicons, {
       sliceUri,
       excludeSlicesClient: excludeSlices,
     });
 
-    logger.step("💾 Writing generated client...");
-
-    // Ensure output directory exists
     const outputDir = dirname(outputPath);
     await ensureDir(outputDir);
 
-    // Write the generated code
     await Deno.writeTextFile(outputPath, generatedCode);
 
-    logger.success(`✅ Generated client written to: ${outputPath}`);
-    logger.info(`📊 Generated from ${lexicons.length} lexicons`);
-    logger.info(`🎯 Slice URI: ${sliceUri}`);
+    logger.success(`Generated client: ${outputPath}`);
 
     if (!excludeSlices) {
-      logger.info("📦 Includes network.slices XRPC client methods");
+      logger.result("Includes network.slices XRPC client methods");
     }
-
   } catch (error) {
     const err = error as Error;
-    logger.error(`❌ Code generation failed: ${err.message}`);
+    logger.error(`Code generation failed: ${err.message}`);
     Deno.exit(1);
   }
-}
+}

packages/cli/src/commands/lexicon/import.ts

···
 import { parseArgs } from "@std/cli/parse-args";
 import { resolve } from "@std/path";
-import { AtProtoClient } from "../../generated_client.ts";
+import type { AtProtoClient } from "../../generated_client.ts";
 import { ConfigManager } from "../../auth/config.ts";
 import { createAuthenticatedClient } from "../../utils/client.ts";
 import { logger } from "../../utils/logger.ts";
···
   printValidationSummary,
   type LexiconValidationResult,
 } from "../../utils/lexicon.ts";
+import type { LexiconDoc } from "@slices/lexicon";
 
 function showImportHelp() {
   console.log(`
···
     const file = validFiles[i];
     stats.attempted++;
 
-    logger.progress("Uploading lexicons", i + 1, validFiles.length);
 
     try {
-      const lexicon = file.content as any;
+      const lexicon = file.content as LexiconDoc & { definitions?: unknown };
       const nsid = lexicon.id;
 
       if (dryRun) {
···
             limit: 1
           });
           existingRecord = response.records.length > 0 ? response.records[0] : null;
-        } catch (error) {
-          logger.debug(`Could not check for existing lexicon ${nsid}: ${error}`);
+        } catch (_error) {
+          // Ignore error - assume lexicon doesn't exist
         }
 
         if (existingRecord) {
···
           limit: 1
         });
         existingRecord = response.records.length > 0 ? response.records[0] : null;
-      } catch (error) {
+      } catch (_error) {
         // If getRecords fails, assume it doesn't exist and continue with create
-        logger.debug(`Could not check for existing lexicon ${nsid}: ${error}`);
       }
 
       const lexiconRecord = {
···
         const defsEqual = JSON.stringify(existingDefs) === JSON.stringify(newDefs);
 
         if (defsEqual) {
-          logger.debug(`⏭️  Skipped (unchanged): ${nsid}`);
           stats.skipped++;
         } else {
           // Update existing record
···
             updatedAt: new Date().toISOString(),
           };
 
-          const result = await client.network.slices.lexicon.updateRecord(
+          await client.network.slices.lexicon.updateRecord(
             existingRecord.uri.split('/').pop()!, // Extract record ID from URI
             updateRecord
           );
 
-          logger.debug(`🔄 Updated: ${file.path} -> ${result.uri}`);
           stats.updated++;
         }
       } else {
···
           createdAt: new Date().toISOString(),
         };
 
-        const result = await client.network.slices.lexicon.createRecord(createRecord);
+        await client.network.slices.lexicon.createRecord(createRecord);
 
-        logger.debug(`✅ Created: ${file.path} -> ${result.uri}`);
         stats.created++;
       }
     } catch (error) {
       const err = error as Error;
-      logger.debug(`❌ Failed to process: ${file.path} - ${err.message}`);
       stats.failed++;
       stats.errors.push({
         file: file.path,
···
   return stats;
 }
 
-function printImportSummary(stats: ImportStats): void {
-  console.log("\n📤 Import Summary");
-  console.log("━━━━━━━━━━━━━━━━━━");
-  console.log(`📤 Attempted: ${stats.attempted}`);
-  console.log(`✅ Created: ${stats.created}`);
-  console.log(`🔄 Updated: ${stats.updated}`);
-  console.log(`⏭️  Skipped: ${stats.skipped}`);
-  console.log(`❌ Failed: ${stats.failed}`);
-
-  if (stats.failed > 0) {
-    console.log("\n❌ Import Failures:");
-    for (const error of stats.errors) {
-      console.log(`   ${error.file}: ${error.error}`);
-    }
-  }
-}
 
 export async function importCommand(commandArgs: unknown[], _globalArgs: Record<string, unknown>): Promise<void> {
   const args = parseArgs(commandArgs as string[], {
···
   const validateOnly = args["validate-only"] as boolean;
   const dryRun = args["dry-run"] as boolean;
 
-  logger.step("Finding lexicon files...");
-  logger.info(`Scanning directory: ${lexiconPath}`);
-
   const lexiconFiles = await findLexiconFiles(lexiconPath);
 
   if (lexiconFiles.length === 0) {
···
     return;
   }
 
-  logger.info(`Found ${lexiconFiles.length} JSON files`);
-
-  // Validate all lexicon files
-  logger.step("Validating lexicon files...");
-  const validationResult = await validateLexiconFiles(lexiconFiles);
-
-  printValidationSummary(validationResult);
+  const validationResult = await validateLexiconFiles(lexiconFiles, false);
 
   if (validationResult.invalidFiles > 0) {
-    logger.error(`${validationResult.invalidFiles} invalid files found`);
-    if (!validateOnly) {
-      logger.error("Please fix validation errors before importing");
-      Deno.exit(1);
-    }
+    printValidationSummary(validationResult);
+    logger.error("Please fix validation errors before importing");
+    Deno.exit(1);
   }
 
   if (validateOnly) {
···
     Deno.exit(1);
   }
 
-  // Check authentication
   const config = new ConfigManager();
   await config.load();
 
···
     Deno.exit(1);
   }
 
-  // Initialize authenticated client
-  logger.step("Initializing authenticated client...");
   const client = await createAuthenticatedClient(sliceUri, apiUrl);
 
   if (dryRun) {
     logger.info("DRY RUN - No actual uploads will be performed");
-  } else {
-    logger.step(`Uploading ${validationResult.validFiles} valid lexicons to ${sliceUri}...`);
   }
 
-  // Upload lexicons
   const importStats = await uploadLexicons(
     validationResult,
     sliceUri,
···
     dryRun
   );
 
-  printImportSummary(importStats);
-
   if (importStats.failed > 0) {
     logger.error(`${importStats.failed} uploads failed`);
     Deno.exit(1);
   }
 
   if (dryRun) {
-    logger.success(`DRY RUN complete - ${importStats.created} files would be processed`);
+    logger.success(`DRY RUN complete - ${importStats.created + importStats.updated} files would be processed`);
   } else {
-    const total = importStats.created + importStats.updated + importStats.skipped;
-    logger.success(`Import complete - ${total} lexicons processed (${importStats.created} created, ${importStats.updated} updated, ${importStats.skipped} skipped)`);
+    const total = importStats.created + importStats.updated;
+    if (total > 0) {
+      logger.success(`Imported ${total} lexicons (${importStats.created} created, ${importStats.updated} updated)`);
+    } else {
+      logger.success("All lexicons up to date");
+    }
   }
 }

packages/cli/src/commands/lexicon/list.ts

···
     const response = await client.network.slices.lexicon.getRecords();
 
     if (response.records.length === 0) {
-      logger.info("📄 No lexicons found in this slice");
+      logger.info("No lexicons found in this slice");
       return;
     }
 
-    // Group lexicons by namespace for tree view
-    const namespaceTree: Record<string, Array<{ nsid: string; record: any; lexicon: any }>> = {};
+    const namespaceTree: Record<string, Array<{ nsid: string; record: unknown; lexicon: unknown }>> = {};
 
     for (const record of response.records) {
       const lexicon = record.value;
-      const nsid = lexicon.nsid as string;
+      const nsid = (lexicon as { nsid: string }).nsid;
       const parts = nsid.split('.');
 
-      // Group by top-level namespace (e.g., "network", "app", "com")
       const topLevel = parts[0] || 'other';
 
       if (!namespaceTree[topLevel]) {
···
       namespaceTree[topLevel].push({ nsid, record, lexicon });
     }
 
-    console.log(`\nLexicons in slice (${response.records.length} total):`);
+    logger.section(`Lexicons (${response.records.length} total)`);
 
-    // Sort namespaces for consistent output
     const sortedNamespaces = Object.keys(namespaceTree).sort();
 
     for (let i = 0; i < sortedNamespaces.length; i++) {
···
       const lexicons = namespaceTree[namespace];
       const isLastNamespace = i === sortedNamespaces.length - 1;
 
-      // Show namespace
       console.log(`${isLastNamespace ? '└─' : '├─'} ${namespace}/`);
 
-      // Sort lexicons within namespace
       lexicons.sort((a, b) => a.nsid.localeCompare(b.nsid));
 
       for (let j = 0; j < lexicons.length; j++) {
···
         const prefix = isLastNamespace ? '   ' : '│  ';
         const branch = isLastLexicon ? '└─' : '├─';
 
-        // Remove the top-level namespace from display (since it's already shown)
         const displayName = nsid.substring(namespace.length + 1);
 
         console.log(`${prefix}${branch} ${displayName}`);

packages/cli/src/utils/client.ts

···
 import type { AuthProvider } from "@slices/client";
 import { AtProtoClient } from "../generated_client.ts";
 import { ConfigManager } from "../auth/config.ts";
-import { logger } from "./logger.ts";
 
 class DeviceAuthProvider implements AuthProvider {
   private config: ConfigManager;
···
     throw new Error("Not authenticated. Run 'slices login' first.");
   }
 
-  logger.debug("🔐 Initializing authenticated client...");
 
   // Create simple auth provider that uses stored device flow tokens
   const authProvider = new DeviceAuthProvider(config);

packages/cli/src/utils/lexicon.ts

···
 import { walk } from "@std/fs/walk";
 import { extname } from "@std/path";
+import { green, red, dim } from "@std/fmt/colors";
 import { LexiconValidator, type LexiconDoc } from "@slices/lexicon";
 import { logger } from "./logger.ts";
 
···
 }
 
 export function printValidationSummary(result: LexiconValidationResult): void {
-  console.log("\nValidation Summary");
-  console.log("─".repeat(50));
-  console.log(`Total files: ${result.totalFiles}`);
-  console.log(`${colors.green}Valid: ${result.validFiles}${colors.reset}`);
-  console.log(`${colors.red}Invalid: ${result.invalidFiles}${colors.reset}`);
+  logger.section("Validation Summary");
+  logger.result(`Total files: ${result.totalFiles}`);
+  logger.result(`Valid: ${green(result.validFiles.toString())}`);
+  logger.result(`Invalid: ${red(result.invalidFiles.toString())}`);
 
   if (result.invalidFiles > 0) {
-    console.log(`\n${colors.red}Invalid Files:${colors.reset}`);
+    logger.section("Invalid Files");
     for (const file of result.files) {
       if (!file.valid) {
-        console.log(`  ${colors.dim}${file.path}${colors.reset}`);
+        console.log(`  ${dim(file.path)}`);
         if (file.errors) {
           file.errors.forEach((error, index) => {
             console.log(formatError(error, index));

packages/cli/src/utils/logger.ts

···
-import { cyan, green, red, yellow, bold } from "@std/fmt/colors";
+import { cyan, green, red, yellow, bold, dim, gray } from "@std/fmt/colors";
 
 export enum LogLevel {
   DEBUG = 0,
···
 
   debug(message: string, ...args: unknown[]) {
     if (this.level <= LogLevel.DEBUG) {
-      console.log(cyan("🔍 DEBUG:"), message, ...args);
+      console.log(dim("  debug"), message, ...args);
     }
   }
 
   info(message: string, ...args: unknown[]) {
     if (this.level <= LogLevel.INFO) {
-      console.log(green("ℹ️  INFO:"), message, ...args);
+      console.log("       ", message, ...args);
     }
   }
 
   warn(message: string, ...args: unknown[]) {
     if (this.level <= LogLevel.WARN) {
-      console.warn(yellow("⚠️  WARN:"), message, ...args);
+      console.warn(yellow("  warn"), message, ...args);
     }
   }
 
   error(message: string, ...args: unknown[]) {
     if (this.level <= LogLevel.ERROR) {
-      console.error(red("❌ ERROR:"), message, ...args);
+      console.error(red("  error"), message, ...args);
     }
   }
 
   success(message: string, ...args: unknown[]) {
-    console.log(green("✅"), message, ...args);
+    console.log(green("  ✓"), message, ...args);
   }
 
   step(message: string, ...args: unknown[]) {
-    console.log(bold(cyan("🔄")), message, ...args);
+    console.log(cyan("  →"), message, ...args);
   }
 
   progress(message: string, current: number, total: number) {
     const percentage = Math.round((current / total) * 100);
-    const bar = "█".repeat(Math.floor(percentage / 5)) + "░".repeat(20 - Math.floor(percentage / 5));
-    console.log(`${cyan("📊")} ${message} [${bar}] ${percentage}% (${current}/${total})`);
+    const filled = Math.floor(percentage / 4);
+    const bar = "█".repeat(filled) + gray("░".repeat(25 - filled));
+    Deno.stdout.writeSync(new TextEncoder().encode(`\r  ${cyan("→")} ${message} ${bar} ${current}/${total}`));
+    if (current === total) {
+      console.log();
+    }
+  }
+
+  section(title: string) {
+    console.log();
+    console.log(bold(title));
+  }
+
+  result(message: string, value?: string) {
+    if (value) {
+      console.log(`  ${message} ${dim(value)}`);
+    } else {
+      console.log(`  ${message}`);
+    }
+  }
+
+  list(items: string[]) {
+    items.forEach(item => {
+      console.log(`  • ${item}`);
+    });
+  }
+
+  table(headers: string[], rows: string[][]) {
+    console.log(`  ${headers.join("  ")}`);
+    console.log(`  ${headers.map(h => "─".repeat(h.length)).join("  ")}`);
+    rows.forEach(row => {
+      console.log(`  ${row.join("  ")}`);
+    });
   }
 }
 

packages/client/src/mod.ts

···
 
       // Try to read the response body for detailed error information
       let errorMessage = `Request failed: ${response.status} ${response.statusText}`;
-      let errorDetails = "";
 
       try {
         const errorBody = await response.json();
         if (errorBody?.message) {
           errorMessage += ` - ${errorBody.message}`;
-          errorDetails = errorBody.message;
         } else if (errorBody?.error) {
           errorMessage += ` - ${errorBody.error}`;
-          errorDetails = errorBody.error;
         }
 
-        // Log detailed error information for debugging
-        if (response.status === 401) {
-          console.error(`🔍 Authentication Debug Info:`);
-          console.error(`   URL: ${url}`);
-          console.error(`   Method: ${httpMethod}`);
-          console.error(`   Auth Header: ${(requestInit.headers as any)?.Authorization ? 'Present' : 'Missing'}`);
-          if ((requestInit.headers as any)?.Authorization) {
-            const authHeader = (requestInit.headers as any).Authorization;
-            console.error(`   Auth Type: ${authHeader.split(' ')[0]}`);
-            console.error(`   Token Length: ${authHeader.split(' ')[1]?.length || 0} chars`);
-          }
-          console.error(`   Error Details: ${errorDetails}`);
-          console.error(`   Full Response Body:`, errorBody);
-        }
       } catch {
         // If we can't parse the response body, just use the status message
-        if (response.status === 401) {
-          console.error(`🔍 Authentication Debug Info:`);
-          console.error(`   URL: ${url}`);
-          console.error(`   Method: ${httpMethod}`);
-          console.error(`   Auth Header: ${(requestInit.headers as any)?.Authorization ? 'Present' : 'Missing'}`);
-          console.error(`   Could not parse error response body`);
-        }
       }
 
       throw new Error(errorMessage);