add slices.json config to cli to reduce the number of args you have to pass

packages/cli/README.md

···
 ## Features
 
 - 🔐 **Device Code Authentication** - Secure OAuth 2.0 device flow login
-- 📝 **Lexicon Import** - Bulk import and validate lexicon files
+- 📝 **Lexicon Management** - Import, list, and validate lexicon files
+- 🧬 **Code Generation** - Generate TypeScript clients from lexicons
+- ⚙️ **Project Configuration** - Optional `slices.json` config file support
 - ✅ **Validation** - Built-in lexicon validation using `@slices/lexicon`
 - 🔧 **Configuration Management** - Persistent authentication and settings
 - 📊 **Progress Tracking** - Real-time progress for batch operations
···
    slices login
    ```
 
-2. **Import lexicon files**
+2. **Create a project config (optional)**
+   ```bash
+   echo '{"slice": "at://did:plc:example/slice"}' > slices.json
+   ```
+
+3. **Import lexicon files**
    ```bash
-   slices import --slice at://did:plc:example/slice --path ./lexicons
+   slices lexicon import
    ```
 
 ## Commands
···
 slices login --aip-url https://custom-aip.example.com
 ```
 
-### `slices import`
+### `slices lexicon import`
 
 Import lexicon files to your slice with automatic validation.
 
 ```bash
-slices import [OPTIONS]
+slices lexicon import [OPTIONS]
 
 OPTIONS:
-    --path <PATH>          Directory containing lexicon files (default: ./lexicons)
-    --slice <SLICE_URI>    Target slice URI (required)
+    --path <PATH>          Directory containing lexicon files (default: ./lexicons or from slices.json)
+    --slice <SLICE_URI>    Target slice URI (required, or from slices.json)
     --validate-only        Only validate files, don't upload
     --dry-run             Show what would be imported without uploading
-    --api-url <URL>       Slices API base URL (default: https://api.slices.network)
+    --api-url <URL>       Slices API base URL (default: https://api.slices.network or from slices.json)
+    -h, --help            Show help
+```
+
+### `slices lexicon list`
+
+List all lexicons in your slice.
+
+```bash
+slices lexicon list [OPTIONS]
+
+OPTIONS:
+    --slice <SLICE_URI>    Target slice URI (required, or from slices.json)
+    --api-url <URL>        Slices API base URL (default: https://api.slices.network or from slices.json)
+    -h, --help            Show help
+```
+
+### `slices codegen`
+
+Generate TypeScript client from lexicon files.
+
+```bash
+slices codegen [OPTIONS]
+
+OPTIONS:
+    --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
     -h, --help            Show help
 ```
 
 **Examples:**
 ```bash
-# Import all lexicons from ./lexicons
-slices import --slice at://did:plc:example/slice
+# Import all lexicons from ./lexicons (using slices.json config)
+slices lexicon import
 
 # Import from custom directory
-slices import --path ./my-lexicons --slice at://did:plc:example/slice
+slices lexicon import --path ./my-lexicons --slice at://did:plc:example/slice
 
 # Validate only (no upload)
-slices import --validate-only --path ./lexicons
+slices lexicon import --validate-only --path ./lexicons
 
 # Dry run (see what would be imported)
-slices import --dry-run --slice at://did:plc:example/slice
+slices lexicon import --dry-run
+
+# List lexicons in slice
+slices lexicon list
+
+# Generate TypeScript client
+slices codegen
 ```
 
 ## Global Options
···
 
 ## Configuration
 
+### Authentication Config
+
 The CLI stores authentication and configuration in `~/.config/slices/config.json`.
 
-**Configuration file structure:**
+**Authentication config structure:**
 ```json
 {
   "auth": {
···
     "expiresAt": 1234567890000,
     "did": "did:plc:example",
     "aipBaseUrl": "https://auth.slices.network"
-  },
-  "defaultSliceUri": "at://did:plc:example/slice",
-  "apiBaseUrl": "https://api.slices.network"
+  }
+}
+```
+
+### Project Config
+
+Create a `slices.json` file in your project root to avoid passing common options every time:
+
+```json
+{
+  "slice": "at://did:plc:example/slice",
+  "lexiconPath": "./lexicons",
+  "clientOutputPath": "./generated_client.ts",
+  "apiUrl": "https://api.slices.network"
 }
 ```
 
+**Config options:**
+- `slice` - Your slice URI (used by `lexicon import`, `lexicon list`, `codegen`)
+- `lexiconPath` - Directory containing lexicon files (default: `./lexicons`)
+- `clientOutputPath` - Output path for generated TypeScript client (default: `./generated_client.ts`)
+- `apiUrl` - Slices API base URL (default: `https://api.slices.network`)
+
+The CLI will search for `slices.json` starting from the current directory and walking up the directory tree. Command line arguments always take precedence over config file values.
+
 ## Lexicon File Requirements
 
 Lexicon files must be valid JSON files with the following structure:
···
 # 1. Authenticate
 slices login
 
-# 2. Validate lexicons first
-slices import --validate-only --path ./my-lexicons
+# 2. Set up project config
+echo '{"slice": "at://did:plc:user123/awesome-slice"}' > slices.json
+
+# 3. Validate lexicons first
+slices lexicon import --validate-only
+
+# 4. Import to slice
+slices lexicon import
+
+# 5. Generate TypeScript client
+slices codegen
 
-# 3. Import to slice
-slices import --slice at://did:plc:user123/awesome-slice --path ./my-lexicons
+# 6. List imported lexicons
+slices lexicon list
 ```
 
-### Batch Operations
+### Working Without Config File
 
 ```bash
 # Import multiple lexicon directories
 for dir in ./lexicons/*/; do
-  slices import --slice at://did:plc:user123/slice --path "$dir"
+  slices lexicon import --slice at://did:plc:user123/slice --path "$dir"
 done
 ```
 

packages/cli/src/commands/codegen.ts

···
 import { generateTypeScript } from "@slices/codegen";
 import { logger } from "../utils/logger.ts";
 import { findLexiconFiles, readAndParseLexicon } from "../utils/lexicon.ts";
+import { SlicesConfigLoader, mergeConfig } from "../utils/config.ts";
 
 function showCodegenHelp() {
   console.log(`
···
     slices codegen [OPTIONS]
 
 OPTIONS:
-    --lexicons <PATH>      Directory containing lexicon files (default: ./lexicons)
-    --output <PATH>        Output file path (default: ./generated_client.ts)
-    --slice <SLICE_URI>    Target slice URI (required)
+    --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
     -h, --help            Show this help message
 
···
     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  # Uses config from slices.json
 `);
 }
 
···
     return;
   }
 
+  // Load config file
+  const configLoader = new SlicesConfigLoader();
+  const slicesConfig = await configLoader.load();
+  const mergedConfig = mergeConfig(slicesConfig, args);
+
   // Validate required arguments
-  if (!args.slice) {
+  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");
+    }
     console.log("\nRun 'slices codegen --help' for usage information.");
     Deno.exit(1);
   }
 
-  const lexiconsPath = resolve(args.lexicons as string || "./lexicons");
-  const outputPath = resolve(args.output as string || "./generated_client.ts");
-  const sliceUri = args.slice as string;
+  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...");

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

···
 import { ConfigManager } from "../../auth/config.ts";
 import { createAuthenticatedClient } from "../../utils/client.ts";
 import { logger } from "../../utils/logger.ts";
+import { SlicesConfigLoader, mergeConfig } from "../../utils/config.ts";
 import {
   findLexiconFiles,
   validateLexiconFiles,
···
     slices lexicon import [OPTIONS]
 
 OPTIONS:
-    --path <PATH>          Directory containing lexicon files (default: ./lexicons)
-    --slice <SLICE_URI>    Target slice URI (required)
+    --path <PATH>          Directory containing lexicon files (default: ./lexicons or from slices.json)
+    --slice <SLICE_URI>    Target slice URI (required, or from slices.json)
     --validate-only        Only validate files, don't upload
     --dry-run             Show what would be imported without uploading
-    --api-url <URL>       Slices API base URL (default: https://api.slices.network)
+    --api-url <URL>       Slices API base URL (default: https://api.slices.network or from slices.json)
     -h, --help            Show this help message
 
 EXAMPLES:
···
     slices lexicon import --path ./my-lexicons --slice at://did:plc:example/slice
     slices lexicon import --validate-only --path ./lexicons
     slices lexicon import --dry-run --slice at://did:plc:example/slice
+    slices lexicon import  # Uses config from slices.json
 `);
 }
 
···
     return;
   }
 
+  // Load config file
+  const configLoader = new SlicesConfigLoader();
+  const slicesConfig = await configLoader.load();
+  const mergedConfig = mergeConfig(slicesConfig, args);
 
   // Validate required arguments
-  if (!args["validate-only"] && !args.slice) {
+  if (!args["validate-only"] && !mergedConfig.slice) {
     logger.error("--slice is required unless using --validate-only");
+    if (!slicesConfig.slice) {
+      logger.info("💡 Tip: Create a slices.json file with your slice URI to avoid passing --slice every time");
+    }
     console.log("\nRun 'slices lexicon import --help' for usage information.");
     Deno.exit(1);
   }
 
-  const lexiconPath = resolve(args.path as string || "./lexicons");
-  const sliceUri = args.slice as string;
-  const apiUrl = args["api-url"] as string || "https://api.slices.network";
+  const lexiconPath = resolve(mergedConfig.lexiconPath!);
+  const sliceUri = mergedConfig.slice!;
+  const apiUrl = mergedConfig.apiUrl!;
   const validateOnly = args["validate-only"] as boolean;
   const dryRun = args["dry-run"] as boolean;
 

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

···
 import { parseArgs } from "@std/cli/parse-args";
 import { createAuthenticatedClient } from "../../utils/client.ts";
 import { logger } from "../../utils/logger.ts";
+import { SlicesConfigLoader, mergeConfig } from "../../utils/config.ts";
 
 function showListHelp() {
   console.log(`
···
     slices lexicon list [OPTIONS]
 
 OPTIONS:
-    --slice <SLICE_URI>    Target slice URI (required)
-    --api-url <URL>        Slices API base URL (default: https://api.slices.network)
+    --slice <SLICE_URI>    Target slice URI (required, or from slices.json)
+    --api-url <URL>        Slices API base URL (default: https://api.slices.network or from slices.json)
     -h, --help             Show this help message
 
 EXAMPLES:
     slices lexicon list --slice at://did:plc:example/slice
+    slices lexicon list  # Uses config from slices.json
 `);
 }
 
···
     return;
   }
 
+  // Load config file
+  const configLoader = new SlicesConfigLoader();
+  const slicesConfig = await configLoader.load();
+  const mergedConfig = mergeConfig(slicesConfig, args);
+
   // Validate required arguments
-  if (!args.slice) {
+  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");
+    }
     console.log("\nRun 'slices lexicon list --help' for usage information.");
     Deno.exit(1);
   }
 
-  const sliceUri = args.slice as string;
-  const apiUrl = args["api-url"] as string || "https://api.slices.network";
+  const sliceUri = mergedConfig.slice!;
+  const apiUrl = mergedConfig.apiUrl!;
 
   try {
     // Initialize authenticated client

packages/cli/src/utils/config.ts

···
+import { resolve, dirname } from "@std/path";
+import { existsSync } from "@std/fs";
+import { logger } from "./logger.ts";
+
+export interface SlicesConfig {
+  slice?: string;
+  apiUrl?: string;
+  lexiconPath?: string;
+  clientOutputPath?: string;
+}
+
+export class SlicesConfigLoader {
+  private configCache: SlicesConfig | null = null;
+  private configPath: string | null = null;
+
+  /**
+   * Find and load slices.json config file, starting from current directory
+   * and walking up the directory tree
+   */
+  async load(startPath = Deno.cwd()): Promise<SlicesConfig> {
+    if (this.configCache && this.configPath) {
+      return this.configCache;
+    }
+
+    const configPath = this.findConfigFile(startPath);
+    if (!configPath) {
+      logger.debug("No slices.json config file found");
+      return {};
+    }
+
+    this.configPath = configPath;
+    logger.debug(`Loading config from: ${configPath}`);
+
+    try {
+      const configText = await Deno.readTextFile(configPath);
+      const config = JSON.parse(configText) as SlicesConfig;
+
+      // Validate config structure
+      this.validateConfig(config);
+
+      this.configCache = config;
+      return config;
+    } catch (error) {
+      const err = error as Error;
+      logger.warn(`Failed to load config file ${configPath}: ${err.message}`);
+      return {};
+    }
+  }
+
+  /**
+   * Get the directory containing the config file
+   */
+  getConfigDir(): string | null {
+    return this.configPath ? dirname(this.configPath) : null;
+  }
+
+  /**
+   * Clear the config cache (useful for testing)
+   */
+  clearCache(): void {
+    this.configCache = null;
+    this.configPath = null;
+  }
+
+  /**
+   * Find slices.json file by walking up the directory tree
+   */
+  private findConfigFile(startPath: string): string | null {
+    let currentPath = resolve(startPath);
+    let lastPath = "";
+
+    while (currentPath !== lastPath) {
+      const configPath = resolve(currentPath, "slices.json");
+      if (existsSync(configPath)) {
+        return configPath;
+      }
+
+      lastPath = currentPath;
+      currentPath = dirname(currentPath);
+    }
+
+    return null;
+  }
+
+  /**
+   * Validate the config file structure
+   */
+  private validateConfig(config: unknown): void {
+    if (typeof config !== "object" || config === null) {
+      throw new Error("Config must be an object");
+    }
+
+    const cfg = config as Record<string, unknown>;
+
+    if (cfg.slice !== undefined && typeof cfg.slice !== "string") {
+      throw new Error("Config 'slice' must be a string");
+    }
+
+    if (cfg.apiUrl !== undefined && typeof cfg.apiUrl !== "string") {
+      throw new Error("Config 'apiUrl' must be a string");
+    }
+
+    if (cfg.lexiconPath !== undefined && typeof cfg.lexiconPath !== "string") {
+      throw new Error("Config 'lexiconPath' must be a string");
+    }
+
+    if (cfg.clientOutputPath !== undefined && typeof cfg.clientOutputPath !== "string") {
+      throw new Error("Config 'clientOutputPath' must be a string");
+    }
+
+    // Validate slice URI format if provided
+    if (cfg.slice && typeof cfg.slice === "string") {
+      if (!cfg.slice.startsWith("at://")) {
+        throw new Error("Config 'slice' must be a valid AT URI (starting with 'at://')");
+      }
+    }
+  }
+}
+
+/**
+ * Merge command line arguments with config file values
+ * Command line arguments take precedence over config file
+ */
+export function mergeConfig(
+  config: SlicesConfig,
+  args: Record<string, unknown>
+): SlicesConfig {
+  return {
+    slice: (args.slice as string) || config.slice,
+    apiUrl: (args["api-url"] as string) || config.apiUrl || "https://api.slices.network",
+    lexiconPath: (args.path as string) || config.lexiconPath || "./lexicons",
+    clientOutputPath: (args.output as string) || config.clientOutputPath || "./generated_client.ts",
+  };
+}