@kjerneverk/riotplan 1.0.7-dev.1 → 1.0.8

package/README.md

@@ -1,18 +1,38 @@
-# riotplan
+# RiotPlan
 
-Framework for long-lived, stateful AI workflows (plans).
+**A plan is bigger than a list of tasks.**
+
+RiotPlan treats plans as **constructs**—full lifecycles from idea exploration through execution. Think before you execute. Support complex, multi-session workflows. Make your plans truly yours.
+
+Part of [Kjerneverk](https://kjerneverk.github.io) - structured formats for working with generative AI.
 
 **Now available as an MCP server!** Integrate with Cursor and other AI assistants - see [MCP Integration](#mcp-integration) below.
 
-## What is a Plan?
+## Why RiotPlan?
+
+### Before: Inadequate Planning
+
+- **Tool-generated inadequacy**: Depending on AI tools to generate simplistic task lists
+- **Markdown chaos**: Plans are markdown files that pile up without structure or lifecycle
+- **Issue trackers without thinking**: Systems like Beads (Steve Yegge's git-backed tracker) address markdown problems but don't support deep, thoughtful planning
+- **No analysis phase**: Jumping straight to execution without exploring ideas or comparing approaches
 
-A **plan** is a structured way to manage multi-step AI-assisted tasks that:
+### After: Plans as Lifecycle
 
-- **Span multiple sessions** - Work on a task over days or weeks
-- **Have persistent state** - Track progress in STATUS.md
-- **Are organized into steps** - Numbered files (01-STEP.md, 02-STEP.md)
+- **Standard lifecycle**: Idea exploration → Shaping approaches → Building detailed plan → Execution → Completion
+- **Thinking before execution**: You can't just create a plan and execute it. RiotPlan supports analysis, elaboration, research.
+- **Standard infrastructure**: MCP resources, tools, and prompts that know how to work with plans. Not just a format, but a system.
+- **Tool independence**: Works from CLI with API keys, via MCP with any model, or through future GUI applications.
+
+## What is a RiotPlan?
+
+A **plan** is a construct that manages multi-step AI-assisted tasks:
+
+- **Spans multiple sessions** - Work on a task over days or weeks
+- **Has persistent state** - Track progress in STATUS.md
+- **Organized into steps** - Numbered files (01-STEP.md, 02-STEP.md)
 - **Can be interrupted and resumed** - Pick up where you left off
-- **Support collaboration** - Human reviews, feedback loops
+- **Supports deep thinking** - Idea exploration, approach comparison, analysis before action
 
 ## Plan Structure
 
@@ -249,20 +269,52 @@ riotplan generate ./my-plan --provider anthropic --model claude-sonnet-4-5
 
 ### Configuration
 
-Create `.riotplanrc.json` in your plan directory:
+RiotPlan uses a flexible **four-tier configuration system** to determine where plans are stored:
+
+1. **Environment Variable** (`RIOTPLAN_PLAN_DIRECTORY`) - Highest priority
+2. **Config File** (`riotplan.config.*`, `.riotplan/config.*`, etc.) - Project-level
+3. **Auto-Detection** - Automatically finds `plans/` directory by walking up the tree
+4. **Fallback** - Uses `./plans` in current directory (zero-config experience)
+
+**Quick Start:**
+
+```bash
+# Most users: Just start using RiotPlan - it finds plans/ automatically!
+riotplan create my-feature
+
+# Create a config file (optional)
+riotplan --init-config
+
+# Check current configuration
+riotplan check-config
+```
+
+**Example: `riotplan.config.yaml`**
+
+```yaml
+planDirectory: ./plans
+defaultProvider: anthropic
+defaultModel: claude-3-5-sonnet-20241022
+```
+
+**MCP Server Configuration:**
 
 ```json
 {
-  "defaultProvider": "anthropic",
-  "autoUpdateStatus": true,
-  "stepTemplate": "detailed",
-  "analysis": {
-    "enabled": true,
-    "directory": "analysis"
+  "mcpServers": {
+    "riotplan": {
+      "command": "npx",
+      "args": ["-y", "@riotprompt/riotplan"],
+      "env": {
+        "RIOTPLAN_PLAN_DIRECTORY": "/path/to/plans"
+      }
+    }
   }
 }
 ```
 
+See [Configuration Guide](./guide/configuration.md) for complete documentation.
+
 ## Programmatic Usage
 
 ```typescript
@@ -371,12 +423,17 @@ Add to your Cursor MCP settings (`~/.cursor/mcp.json`):
   "mcpServers": {
     "riotplan": {
       "command": "npx",
-      "args": ["-y", "@riotprompt/riotplan", "riotplan-mcp"]
+      "args": ["-y", "@riotprompt/riotplan"],
+      "env": {
+        "RIOTPLAN_PLAN_DIRECTORY": "/path/to/plans"
+      }
     }
   }
 }
 ```
 
+**Zero-Config Experience:** If you don't set `RIOTPLAN_PLAN_DIRECTORY`, RiotPlan will automatically find your `plans/` directory by walking up from your workspace root. No configuration needed!
+
 ### MCP Tools
 
 - **`riotplan_create`** - Create new plans with AI-generated steps
@@ -424,6 +481,30 @@ riotplan_step_start({ path: "./user-auth", step: 1 })
 riotplan_step_complete({ path: "./user-auth", step: 1 })
 ```
 
+### For AI Assistants: Executing Plans with Tracking
+
+**When executing a RiotPlan, you MUST use RiotPlan's tracking infrastructure:**
+
+1. **Check if step files exist** in `plan/` directory
+   - If `EXECUTION_PLAN.md` exists but step files don't, create them first
+   - Step files (e.g., `01-step.md`, `02-step.md`) are required for tracking
+
+2. **For each step you execute:**
+   - Call `riotplan_step_start({ path, step: N })` **BEFORE** doing any work
+   - Do the actual work (implement, test, document)
+   - Call `riotplan_step_complete({ path, step: N })` **AFTER** completing the work
+   - Let RiotPlan update STATUS.md automatically
+
+3. **Use the `execute_plan` prompt** for guided execution:
+   ```
+   /riotplan/execute_plan
+   ```
+   This provides the complete workflow for executing with tracking.
+
+**Key Principle**: If you're working on a RiotPlan, RiotPlan should manage the execution, not just the planning. Don't just do the work - use the tracking tools!
+
+**Common Mistake**: Executing steps without using `riotplan_step_start` and `riotplan_step_complete`. This bypasses RiotPlan's execution management and breaks progress tracking.
+
 See [guide/mcp.md](./guide/mcp.md) for detailed MCP documentation.
 
 ## Philosophy

package/TESTING-CHECKLIST.md

@@ -0,0 +1,140 @@
+# Testing Checklist for Plan Directory Configuration
+
+This document provides checklists for manually testing the plan directory configuration feature.
+
+## MCP Server Testing (Step 13)
+
+### Scenario 1: MCP with Environment Variable
+- [ ] Set `RIOTPLAN_PLAN_DIRECTORY` in `.cursor/mcp.json`:
+  ```json
+  {
+    "mcpServers": {
+      "riotplan": {
+        "command": "npx",
+        "args": ["-y", "@riotprompt/riotplan"],
+        "env": {
+          "RIOTPLAN_PLAN_DIRECTORY": "/path/to/custom/plans"
+        }
+      }
+    }
+  }
+  ```
+- [ ] Restart Cursor/IDE to load MCP server
+- [ ] Run `riotplan idea create test-idea "Test idea"` via MCP
+- [ ] Verify plan created in `/path/to/custom/plans/test-idea`
+- [ ] Run `riotplan check-config` via MCP or CLI
+- [ ] Verify output shows "Environment variable (tier 1)" as source
+
+### Scenario 2: MCP with Config File
+- [ ] Create `riotplan.config.yaml` in project root:
+  ```yaml
+  planDirectory: ./my-plans
+  ```
+- [ ] Remove `RIOTPLAN_PLAN_DIRECTORY` from `.cursor/mcp.json` (if set)
+- [ ] Restart Cursor/IDE
+- [ ] Run `riotplan idea create test-idea "Test"` via MCP
+- [ ] Verify plan created in `./my-plans/test-idea`
+- [ ] Run `riotplan check-config`
+- [ ] Verify output shows "Config file (tier 2)" as source
+
+### Scenario 3: MCP with Walk-Up
+- [ ] Remove `RIOTPLAN_PLAN_DIRECTORY` from `.cursor/mcp.json`
+- [ ] Remove or rename `riotplan.config.yaml`
+- [ ] Ensure `plans/` directory exists in project root
+- [ ] Restart Cursor/IDE
+- [ ] Run `riotplan idea create test-idea "Test"` via MCP
+- [ ] Verify plan created in `plans/test-idea`
+- [ ] Run `riotplan check-config`
+- [ ] Verify output shows "Walk-up detection (tier 3)" as source
+
+### Scenario 4: MCP with Fallback
+- [ ] Remove `RIOTPLAN_PLAN_DIRECTORY` from `.cursor/mcp.json`
+- [ ] Remove `riotplan.config.yaml`
+- [ ] Remove or rename `plans/` directory
+- [ ] Restart Cursor/IDE
+- [ ] Run `riotplan idea create test-idea "Test"` via MCP
+- [ ] Verify plan created in `./plans/test-idea` (fallback)
+- [ ] Run `riotplan check-config`
+- [ ] Verify output shows "Fallback (tier 4)" as source
+
+### Scenario 5: Precedence Testing
+- [ ] Set `RIOTPLAN_PLAN_DIRECTORY` in `.cursor/mcp.json`
+- [ ] Create `riotplan.config.yaml` with different `planDirectory`
+- [ ] Ensure `plans/` directory exists
+- [ ] Restart Cursor/IDE
+- [ ] Run `riotplan check-config`
+- [ ] Verify env var takes precedence (tier 1)
+- [ ] Remove env var, restart, verify config takes precedence (tier 2)
+- [ ] Remove config, restart, verify walk-up takes precedence (tier 3)
+
+## CLI Testing (Step 14)
+
+### Scenario 1: CLI with No Configuration
+- [ ] Navigate to empty directory (no config, no plans/)
+- [ ] Run `riotplan idea create test-idea "Test idea"`
+- [ ] Verify `./plans` directory created
+- [ ] Verify plan created in `./plans/test-idea`
+- [ ] Run `riotplan check-config`
+- [ ] Verify shows "Fallback (tier 4)"
+
+### Scenario 2: CLI with Existing plans/ Directory
+- [ ] Create `plans/` directory in project root
+- [ ] Navigate to subdirectory: `cd src/utils`
+- [ ] Run `riotplan idea create test-idea "Test"`
+- [ ] Verify walk-up found `plans/` in project root
+- [ ] Verify plan created in project root `plans/test-idea`
+- [ ] Run `riotplan check-config`
+- [ ] Verify shows "Walk-up detection (tier 3)"
+
+### Scenario 3: CLI with Config File
+- [ ] Create `riotplan.config.yaml`:
+  ```yaml
+  planDirectory: ./custom-plans
+  ```
+- [ ] Run from any directory in project
+- [ ] Run `riotplan idea create test-idea "Test"`
+- [ ] Verify plan created in `./custom-plans/test-idea`
+- [ ] Run `riotplan check-config`
+- [ ] Verify shows "Config file (tier 2)"
+
+### Scenario 4: CLI with Environment Variable
+- [ ] Set `export RIOTPLAN_PLAN_DIRECTORY=/tmp/test-plans`
+- [ ] Run from any directory
+- [ ] Run `riotplan idea create test-idea "Test"`
+- [ ] Verify plan created in `/tmp/test-plans/test-idea`
+- [ ] Run `riotplan check-config`
+- [ ] Verify shows "Environment variable (tier 1)"
+
+### Scenario 5: CLI with Explicit Path
+- [ ] Run `riotplan idea create test-idea "Test" --path /custom/explicit/path`
+- [ ] Verify explicit path takes precedence over all tiers
+- [ ] Verify plan created in `/custom/explicit/path/test-idea`
+- [ ] Verify backward compatibility maintained
+
+### Scenario 6: CLI Configuration Commands
+- [ ] Run `riotplan --init-config`
+- [ ] Verify `riotplan.config.yaml` created with defaults
+- [ ] Verify file contains `planDirectory: ./plans`
+- [ ] Run `riotplan check-config`
+- [ ] Verify shows correct configuration source
+- [ ] Verify shows resolved plan directory
+
+## Performance Testing
+
+- [ ] Run `riotplan check-config` multiple times - should be fast (cached)
+- [ ] Test MCP server startup time - should not be significantly slower
+- [ ] Test walk-up from deep nested directory (e.g., `src/components/ui/buttons/`)
+- [ ] Verify caching works (second call should be instant)
+
+## Error Scenarios
+
+- [ ] Invalid config file (malformed YAML/JSON) - should show helpful error
+- [ ] Config file with invalid `planDirectory` (non-existent absolute path)
+- [ ] Permission issues (read-only directory)
+- [ ] Missing CardiganTime dependency (should fail gracefully)
+
+## Notes
+
+- All tests should be performed in a clean environment
+- Clear caches between tests if needed: `clearResolverCache()`, `clearConfigCache()`, `clearWalkUpCache()`
+- Document any issues found during testing

package/dist/bin.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { q as createProgram } from "./cli-zlZlG2Bw.js";
+import { q as createProgram } from "./cli-BNnX3BBS.js";
 const program = createProgram();
 program.parse();
 //# sourceMappingURL=bin.js.map

package/dist/{cli-zlZlG2Bw.js → cli-BNnX3BBS.js}

@@ -1,11 +1,13 @@
 import { Command } from "commander";
 import chalk from "chalk";
-import { readFileSync } from "node:fs";
+import { existsSync, statSync, writeFileSync, readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { resolve, join, basename, dirname } from "node:path";
 import { readFile, stat, readdir, writeFile, mkdir, access, rename, rm } from "node:fs/promises";
 import "node:os";
 import inquirer from "inquirer";
+import { z } from "zod";
+import { create } from "@utilarium/cardigantime";
 const PLAN_CONVENTIONS = {
   /** Meta-prompt file patterns */
   metaPromptPatterns: [
@@ -1179,6 +1181,18 @@ None currently.
 
 ---
 
+## Execution Tracking
+
+**To execute this plan with RiotPlan tracking:**
+
+1. Use \`riotplan_step_start({ path, step: N })\` **before** starting each step
+2. Complete the work for the step
+3. Use \`riotplan_step_complete({ path, step: N })\` **after** completing each step
+
+**For AI Assistants:** When executing this plan, always use RiotPlan's tracking tools. Don't just do the work - use \`riotplan_step_start\` and \`riotplan_step_complete\` to track progress. This ensures STATUS.md stays up-to-date and the plan can be resumed later.
+
+---
+
 *Last updated: ${date}*
 `;
 }
@@ -6144,6 +6158,297 @@ function registerVerifyCommand(program) {
     }
   });
 }
+const RiotPlanConfigSchema = z.object({
+  /**
+   * Path to the directory where plans are stored
+   * Can be relative (resolved from config file location) or absolute
+   * Defaults to './plans' if not specified
+   */
+  planDirectory: z.string().default("./plans"),
+  /**
+   * Default AI provider to use for plan generation
+   * Optional - if not specified, uses system defaults
+   */
+  defaultProvider: z.enum(["anthropic", "openai", "gemini"]).optional(),
+  /**
+   * Default model to use for plan generation
+   * Optional - if not specified, uses provider defaults
+   */
+  defaultModel: z.string().optional(),
+  /**
+   * Path to custom plan templates directory
+   * Can be relative (resolved from config file location) or absolute
+   * Optional - if not specified, uses built-in templates
+   */
+  templateDirectory: z.string().optional()
+});
+const cardigantime = create({
+  defaults: {
+    configDirectory: process.cwd(),
+    isRequired: false
+    // Config file is optional
+  },
+  configShape: RiotPlanConfigSchema.shape,
+  features: ["config"]
+  // Hierarchical discovery is enabled by default in CardiganTime
+});
+let cachedConfig = null;
+let configLoadAttempted = false;
+async function loadConfig() {
+  if (cachedConfig !== null) {
+    return cachedConfig;
+  }
+  if (configLoadAttempted) {
+    return null;
+  }
+  try {
+    configLoadAttempted = true;
+    const args = {};
+    const config = await cardigantime.read(args);
+    await cardigantime.validate(config);
+    cachedConfig = config;
+    return cachedConfig;
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("not found")) {
+      return null;
+    }
+    throw error;
+  }
+}
+const walkUpCache = /* @__PURE__ */ new Map();
+function findPlansDirectory(startPath) {
+  const normalizedStart = resolve(startPath);
+  if (walkUpCache.has(normalizedStart)) {
+    return walkUpCache.get(normalizedStart) ?? null;
+  }
+  let currentPath = normalizedStart;
+  while (currentPath !== "/") {
+    const plansPath = join(currentPath, "plans");
+    if (existsSync(plansPath)) {
+      try {
+        const stats = statSync(plansPath);
+        if (stats.isDirectory()) {
+          walkUpCache.set(normalizedStart, currentPath);
+          return currentPath;
+        }
+      } catch {
+      }
+    }
+    const parentPath = dirname(currentPath);
+    if (parentPath === currentPath) {
+      break;
+    }
+    currentPath = parentPath;
+  }
+  walkUpCache.set(normalizedStart, null);
+  return null;
+}
+let cachedPlanDirectory = null;
+let resolutionAttempted = false;
+async function resolvePlanDirectory() {
+  if (cachedPlanDirectory !== null) {
+    return cachedPlanDirectory;
+  }
+  if (resolutionAttempted && cachedPlanDirectory === null) {
+    return join(process.cwd(), "plans");
+  }
+  resolutionAttempted = true;
+  try {
+    const config = await loadConfig();
+    if (config?.planDirectory) {
+      const resolvedPath = resolve(config.planDirectory);
+      cachedPlanDirectory = resolvedPath;
+      return resolvedPath;
+    }
+  } catch (error) {
+  }
+  const foundPlansParent = findPlansDirectory(process.cwd());
+  if (foundPlansParent) {
+    const plansPath = join(foundPlansParent, "plans");
+    cachedPlanDirectory = resolve(plansPath);
+    return cachedPlanDirectory;
+  }
+  const fallbackPath = join(process.cwd(), "plans");
+  cachedPlanDirectory = resolve(fallbackPath);
+  return cachedPlanDirectory;
+}
+function registerConfigCommands(program) {
+  program.option("--init-config", "Create initial riotplan.config.yaml file").hook("preAction", async (thisCommand) => {
+    if (thisCommand.opts().initConfig) {
+      await handleInitConfig();
+      process.exit(0);
+    }
+  });
+  program.command("check-config").description("Show current configuration resolution and validation").action(async () => {
+    await handleCheckConfig();
+  });
+}
+async function handleInitConfig() {
+  const configPath = resolve(process.cwd(), "riotplan.config.yaml");
+  if (existsSync(configPath)) {
+    console.log(chalk.yellow(`⚠ Configuration file already exists: ${configPath}`));
+    console.log(chalk.dim("Use --check-config to view current configuration."));
+    return;
+  }
+  const configContent = `# RiotPlan Configuration
+# See https://github.com/kjerneverk/riotplan for documentation
+
+# Directory where plans are stored (relative or absolute)
+# Relative paths are resolved from this config file's location
+planDirectory: ./plans
+
+# Optional: Default AI provider for plan generation
+# Options: anthropic, openai, gemini
+# defaultProvider: anthropic
+
+# Optional: Default model to use for plan generation
+# Examples: claude-3-5-sonnet-20241022, gpt-4, gemini-pro
+# defaultModel: claude-3-5-sonnet-20241022
+
+# Optional: Custom template directory
+# templateDirectory: ./.riotplan/templates
+`;
+  try {
+    writeFileSync(configPath, configContent, "utf-8");
+    console.log(chalk.green(`✓ Created configuration file: ${configPath}`));
+    console.log(chalk.dim("\nEdit this file to customize your RiotPlan configuration."));
+    console.log(chalk.dim('Run "riotplan check-config" to verify your configuration.'));
+  } catch (error) {
+    console.error(chalk.red(`✗ Failed to create config file: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+}
+async function handleCheckConfig() {
+  console.log(chalk.bold("\nRiotPlan Configuration Check"));
+  console.log("============================\n");
+  let configSource = "Unknown";
+  let configLocation = null;
+  let planDirectory;
+  let config = null;
+  if (process.env.RIOTPLAN_PLAN_DIRECTORY) {
+    configSource = "Environment variable (tier 1)";
+    planDirectory = resolve(process.env.RIOTPLAN_PLAN_DIRECTORY);
+    console.log(chalk.green("✓ Configuration loaded successfully\n"));
+    console.log(`Source: ${chalk.bold(configSource)}`);
+    console.log(`Environment Variable: ${chalk.cyan("RIOTPLAN_PLAN_DIRECTORY")}`);
+    console.log(`Plan Directory: ${chalk.cyan(planDirectory)} ${existsSync(planDirectory) ? chalk.green("(exists)") : chalk.yellow("(does not exist)")}`);
+  } else {
+    try {
+      config = await loadConfig();
+      if (config) {
+        configSource = "Config file (tier 2)";
+        configLocation = findConfigFileLocation();
+        planDirectory = resolve(config.planDirectory || "./plans");
+        console.log(chalk.green("✓ Configuration loaded successfully\n"));
+        console.log(`Source: ${chalk.bold(configSource)}`);
+        if (configLocation) {
+          console.log(`Location: ${chalk.cyan(configLocation)}`);
+        }
+        console.log(`Plan Directory: ${chalk.cyan(planDirectory)} ${existsSync(planDirectory) ? chalk.green("(exists)") : chalk.yellow("(does not exist)")}`);
+      } else {
+        const foundPlansParent = findPlansDirectory(process.cwd());
+        if (foundPlansParent) {
+          configSource = "Walk-up detection (tier 3)";
+          planDirectory = join(foundPlansParent, "plans");
+          console.log(chalk.green("✓ Configuration resolved successfully\n"));
+          console.log(`Source: ${chalk.bold(configSource)}`);
+          console.log(`Found plans/ directory at: ${chalk.cyan(dirname(planDirectory))}`);
+          console.log(`Plan Directory: ${chalk.cyan(planDirectory)} ${existsSync(planDirectory) ? chalk.green("(exists)") : chalk.yellow("(does not exist)")}`);
+        } else {
+          configSource = "Fallback (tier 4)";
+          planDirectory = join(process.cwd(), "plans");
+          console.log(chalk.yellow("⚠ Using default configuration\n"));
+          console.log(`Source: ${chalk.bold(configSource)}`);
+          console.log(`Plan Directory: ${chalk.cyan(planDirectory)} ${existsSync(planDirectory) ? chalk.green("(exists)") : chalk.yellow("(will be created on first use)")}`);
+        }
+      }
+    } catch (error) {
+      console.log(chalk.red("✗ Configuration error\n"));
+      console.log(`Error: ${chalk.red(error instanceof Error ? error.message : String(error))}`);
+      console.log(chalk.dim("\nFix the configuration error and try again."));
+      process.exit(1);
+    }
+  }
+  try {
+    const resolved = await resolvePlanDirectory();
+    console.log(`
+Resolved Plan Directory: ${chalk.bold.cyan(resolved)}`);
+  } catch (error) {
+    console.log(chalk.yellow(`
+⚠ Could not resolve plan directory: ${error instanceof Error ? error.message : String(error)}`));
+  }
+  if (config) {
+    console.log("\nSettings:");
+    if (config.planDirectory) {
+      console.log(`  planDirectory: ${chalk.cyan(config.planDirectory)}`);
+    }
+    if (config.defaultProvider) {
+      console.log(`  defaultProvider: ${chalk.cyan(config.defaultProvider)}`);
+    }
+    if (config.defaultModel) {
+      console.log(`  defaultModel: ${chalk.cyan(config.defaultModel)}`);
+    }
+    if (config.templateDirectory) {
+      console.log(`  templateDirectory: ${chalk.cyan(config.templateDirectory)}`);
+    }
+    if (!config.planDirectory && !config.defaultProvider && !config.defaultModel && !config.templateDirectory) {
+      console.log(chalk.dim("  (using defaults)"));
+    }
+  }
+  console.log();
+}
+function findConfigFileLocation() {
+  const configNames = [
+    "riotplan.config.yaml",
+    "riotplan.config.yml",
+    "riotplan.config.json",
+    "riotplan.config.js",
+    "riotplan.config.ts",
+    "riotplan.conf.yaml",
+    "riotplan.conf.yml",
+    "riotplan.conf.json",
+    ".riotplanrc.yaml",
+    ".riotplanrc.yml",
+    ".riotplanrc.json",
+    ".riotplanrc"
+  ];
+  let currentPath = process.cwd();
+  while (currentPath !== "/") {
+    for (const name of configNames) {
+      const configPath = join(currentPath, name);
+      if (existsSync(configPath)) {
+        try {
+          const stats = statSync(configPath);
+          if (stats.isFile()) {
+            return configPath;
+          }
+        } catch {
+        }
+      }
+    }
+    const dotRiotplanDir = join(currentPath, ".riotplan");
+    if (existsSync(dotRiotplanDir)) {
+      try {
+        const stats = statSync(dotRiotplanDir);
+        if (stats.isDirectory()) {
+          for (const ext of ["yaml", "yml", "json", "js", "ts"]) {
+            const configPath = join(dotRiotplanDir, `config.${ext}`);
+            if (existsSync(configPath)) {
+              return configPath;
+            }
+          }
+        }
+      } catch {
+      }
+    }
+    const parentPath = dirname(currentPath);
+    if (parentPath === currentPath) {
+      break;
+    }
+    currentPath = parentPath;
+  }
+  return null;
+}
 const __filename$1 = fileURLToPath(import.meta.url);
 const __dirname$1 = dirname(__filename$1);
 let packageJsonPath = join(__dirname$1, "../package.json");
@@ -6174,6 +6479,7 @@ function createProgram() {
   registerAmendCommand(program);
   registerAmendmentsCommands(program);
   registerVerifyCommand(program);
+  registerConfigCommands(program);
   program.option("-v, --verbose", "Verbose output").option("--json", "Output as JSON").option("--no-color", "Disable colored output");
   program.on("command:*", () => {
     console.error(chalk.red(`Unknown command: ${program.args.join(" ")}`));
@@ -6255,4 +6561,4 @@ export {
   getFeedback as y,
   getReadySteps as z
 };
-//# sourceMappingURL=cli-zlZlG2Bw.js.map
+//# sourceMappingURL=cli-BNnX3BBS.js.map