optikit 1.3.0 → 1.4.0

package/.claude/settings.local.json

@@ -24,5 +24,8 @@
       "WebSearch",
       "Bash(git add:*)"
     ]
-  }
+  },
+  "enabledMcpjsonServers": [
+    "optikit"
+  ]
 }

package/CHANGELOG.md

@@ -12,6 +12,14 @@ We follow **Semantic Versioning (SemVer)**:
 
 ---
 
+### 🌟 [1.4.0] - Interactive Repo Picker & Module Cleanup
+
+- 📂 Interactive arrow-key directory picker for `gen repo` — browse, open, go back, or create folders
+- 🔄 Removed repo from `generate module` — lighter module scaffolding
+- 🏗️ Repo is now standalone (own import, no `part of`) and can live anywhere
+
+---
+
 ### 🌟 [1.3.0] - MCP Plugin, Short Aliases & Combo Flags
 
 - 🤖 **Claude Code Integration**:

package/dist/commands/project/commands.js

@@ -29,7 +29,7 @@ export const projectCommands = [
         builder: (yargs) => {
             return yargs.positional("moduleName", { describe: "The module name", type: "string" });
         },
-        handler: (argv) => { generateRepoModule(argv.moduleName); },
+        handler: async (argv) => { await generateRepoModule(argv.moduleName); },
     },
     {
         command: "add-route <moduleName>",

package/dist/commands/project/generate.js

@@ -1,5 +1,6 @@
 import fs from "fs";
 import path from "path";
+import chalk from "chalk";
 import { createDirectories, writeFile, getClassName, } from "../../utils/helpers/file.js";
 import { LoggerHelpers } from "../../utils/services/logger.js";
 import { handleCommandError } from "../../utils/helpers/error.js";
@@ -31,7 +32,6 @@ function generateModule(moduleName) {
         generateScreen(moduleName, path.join(modulePath, "screen"));
         generateImport(moduleName, path.join(modulePath, "import"));
         generateStateFactory(moduleName, path.join(modulePath, "factory"));
-        generateRepo(moduleName, path.join(modulePath, "repo"));
         LoggerHelpers.success(`Module ${moduleName} created with full structure.`);
     }
     catch (error) {
@@ -136,7 +136,6 @@ part '../event/${moduleName}_event.dart';
 part '../screen/${moduleName}_screen.dart';
 part '../state/${moduleName}_state.dart';
 part '../factory/${moduleName}_factory.dart';
-part '../repo/${moduleName}_repo.dart';
   `;
     writeFile(importFilePath, template);
     LoggerHelpers.success(`Import file ${moduleName}_import.dart created in ${importPath}`);
@@ -159,7 +158,7 @@ class ${className}Factory extends BaseFactory {
 function generateRepo(moduleName, repoPath) {
     const repoFilePath = path.join(repoPath, `${moduleName}_repo.dart`);
     const className = getClassName(moduleName);
-    const template = `part of '../import/${moduleName}_import.dart';
+    const template = `import 'package:opticore/opticore.dart';
 
 class ${className}Repo extends BaseRepo {
 
@@ -170,17 +169,213 @@ class ${className}Repo extends BaseRepo {
     );
   }
 }
-  `;
+`;
     writeFile(repoFilePath, template);
     LoggerHelpers.success(`Repo file ${moduleName}_repo.dart created in ${repoPath}`);
 }
+function buildPickerItems(currentPath, rootPath) {
+    const items = [];
+    // "Select here" always first
+    items.push({ label: "Select this directory", icon: "✔", action: "select" });
+    // Go back (unless at root)
+    const canGoBack = currentPath !== rootPath && currentPath !== ".";
+    if (canGoBack) {
+        items.push({ label: "..", icon: "↩", action: "back" });
+    }
+    // Subdirectories
+    if (fs.existsSync(currentPath)) {
+        const dirs = fs.readdirSync(currentPath, { withFileTypes: true })
+            .filter(e => e.isDirectory() && !e.name.startsWith('.'))
+            .map(e => e.name)
+            .sort();
+        for (const dir of dirs) {
+            items.push({ label: `${dir}/`, icon: "📁", action: "open", dirName: dir });
+        }
+    }
+    // Create new folder always last
+    items.push({ label: "Create new folder", icon: "✚", action: "create" });
+    return items;
+}
 /**
- * Generates a repository for an existing module.
- * Creates repo directory, generates repo file, and appends part directive to import file.
+ * Interactive arrow-key directory picker.
+ * Navigate with arrow keys, enter to select/open, esc to cancel.
  */
-function generateRepoModule(moduleName) {
+function pickDirectory(startPath) {
+    return new Promise((resolve, reject) => {
+        let currentPath = startPath;
+        const rootPath = startPath;
+        let cursor = 0;
+        let items = buildPickerItems(currentPath, rootPath);
+        let totalLines = 0;
+        let creatingFolder = false;
+        let folderInput = "";
+        const stdin = process.stdin;
+        const wasRaw = stdin.isRaw ?? false;
+        stdin.setRawMode(true);
+        stdin.resume();
+        stdin.setEncoding("utf8");
+        function render() {
+            // Clear previous output
+            if (totalLines > 0) {
+                process.stdout.write(`\x1B[${totalLines}A`);
+                process.stdout.write("\x1B[0J");
+            }
+            const lines = [];
+            // Header — current path with breadcrumb
+            lines.push("");
+            lines.push(chalk.cyan.bold(`  📂 ${currentPath}/`));
+            lines.push(chalk.gray("  ─────────────────────────────────────"));
+            // Menu items
+            for (let i = 0; i < items.length; i++) {
+                const item = items[i];
+                const isActive = i === cursor;
+                if (isActive) {
+                    const pointer = chalk.cyan.bold("❯");
+                    const icon = item.action === "select" ? chalk.green(item.icon) :
+                        item.action === "back" ? chalk.yellow(item.icon) :
+                            item.action === "create" ? chalk.magenta(item.icon) :
+                                chalk.blue(item.icon);
+                    lines.push(`  ${pointer} ${icon}  ${chalk.white.bold(item.label)}`);
+                }
+                else {
+                    const icon = chalk.gray(item.icon);
+                    lines.push(`    ${icon}  ${chalk.gray(item.label)}`);
+                }
+            }
+            lines.push(chalk.gray("  ─────────────────────────────────────"));
+            if (creatingFolder) {
+                lines.push(chalk.magenta(`  ✚ New folder name: `) + chalk.white.bold(folderInput) + chalk.gray("▌"));
+            }
+            else {
+                lines.push(chalk.gray("  ↑↓ navigate  ⏎ select/open  ← back  esc cancel"));
+            }
+            const output = lines.join("\n") + "\n";
+            process.stdout.write(output);
+            totalLines = lines.length;
+        }
+        function cleanup() {
+            stdin.setRawMode(wasRaw);
+            stdin.removeListener("data", onKeypress);
+            stdin.pause();
+        }
+        function refreshItems() {
+            items = buildPickerItems(currentPath, rootPath);
+            cursor = 0;
+        }
+        function onKeypress(key) {
+            // Handle folder creation mode
+            if (creatingFolder) {
+                if (key === "\r") {
+                    // Enter — create the folder
+                    const trimmed = folderInput.trim();
+                    if (trimmed.length > 0) {
+                        const newPath = path.join(currentPath, trimmed);
+                        fs.mkdirSync(newPath, { recursive: true });
+                        currentPath = newPath;
+                        refreshItems();
+                    }
+                    creatingFolder = false;
+                    folderInput = "";
+                    render();
+                }
+                else if (key === "\x1B") {
+                    // Esc — cancel folder creation
+                    creatingFolder = false;
+                    folderInput = "";
+                    render();
+                }
+                else if (key === "\x7F" || key === "\b") {
+                    // Backspace
+                    folderInput = folderInput.slice(0, -1);
+                    render();
+                }
+                else if (key.length === 1 && key.charCodeAt(0) >= 32) {
+                    // Regular character
+                    folderInput += key;
+                    render();
+                }
+                return;
+            }
+            const item = items[cursor];
+            // Escape — cancel (single \x1B only, not arrow key sequences)
+            if (key === "\x1B" && key.length === 1) {
+                cleanup();
+                reject(new Error("Directory selection cancelled."));
+                return;
+            }
+            // Arrow keys
+            if (key === "\x1B[A") {
+                // Up
+                cursor = cursor > 0 ? cursor - 1 : items.length - 1;
+                render();
+                return;
+            }
+            if (key === "\x1B[B") {
+                // Down
+                cursor = cursor < items.length - 1 ? cursor + 1 : 0;
+                render();
+                return;
+            }
+            if (key === "\x1B[D") {
+                // Left arrow — go back
+                if (currentPath !== rootPath && currentPath !== ".") {
+                    currentPath = path.dirname(currentPath);
+                    refreshItems();
+                    render();
+                }
+                return;
+            }
+            if (key === "\x1B[C") {
+                // Right arrow — open directory if cursor is on a folder
+                if (item.action === "open" && item.dirName) {
+                    currentPath = path.join(currentPath, item.dirName);
+                    refreshItems();
+                    render();
+                }
+                return;
+            }
+            // Enter — perform action
+            if (key === "\r") {
+                if (item.action === "select") {
+                    cleanup();
+                    resolve(currentPath);
+                    return;
+                }
+                if (item.action === "back") {
+                    currentPath = path.dirname(currentPath);
+                    refreshItems();
+                    render();
+                    return;
+                }
+                if (item.action === "open" && item.dirName) {
+                    currentPath = path.join(currentPath, item.dirName);
+                    refreshItems();
+                    render();
+                    return;
+                }
+                if (item.action === "create") {
+                    creatingFolder = true;
+                    folderInput = "";
+                    render();
+                    return;
+                }
+            }
+            // Ctrl+C
+            if (key === "\x03") {
+                cleanup();
+                process.exit(0);
+            }
+        }
+        stdin.on("data", onKeypress);
+        render();
+    });
+}
+/**
+ * Generates a repository file at a user-selected location.
+ * Opens an interactive directory picker starting from lib/.
+ */
+async function generateRepoModule(moduleName) {
     try {
-        // Validate module name
         if (!moduleName || moduleName.trim().length === 0) {
             LoggerHelpers.error(ERROR_MESSAGES.MODULE_NAME_EMPTY);
             process.exit(1);
@@ -189,37 +384,15 @@ function generateRepoModule(moduleName) {
             LoggerHelpers.error(ERROR_MESSAGES.MODULE_NAME_INVALID);
             process.exit(1);
         }
-        const modulePath = path.join("lib", "module", moduleName);
-        // Verify module exists
-        if (!fs.existsSync(modulePath)) {
-            LoggerHelpers.error(`Module ${moduleName} does not exist at ${modulePath}. Create it first with: optikit generate module ${moduleName}`);
-            process.exit(1);
-        }
-        // Create repo directory
-        const repoPath = path.join(modulePath, "repo");
+        LoggerHelpers.info(`Generating repository for ${moduleName}...`);
+        LoggerHelpers.info("Select where to create the repo file:");
+        const startDir = fs.existsSync("lib") ? "lib" : ".";
+        const repoPath = await pickDirectory(startDir);
         if (!fs.existsSync(repoPath)) {
             fs.mkdirSync(repoPath, { recursive: true });
         }
-        LoggerHelpers.info(`Adding repository to module ${moduleName}...`);
         generateRepo(moduleName, repoPath);
-        // Append part directive to import file if not already present
-        const importFilePath = path.join(modulePath, "import", `${moduleName}_import.dart`);
-        if (fs.existsSync(importFilePath)) {
-            const importContent = fs.readFileSync(importFilePath, "utf8");
-            const repoPartLine = `part '../repo/${moduleName}_repo.dart';`;
-            if (!importContent.includes(repoPartLine)) {
-                const updatedContent = importContent.trimEnd() + `\n${repoPartLine}\n`;
-                writeFile(importFilePath, updatedContent);
-                LoggerHelpers.success(`Added repo part directive to ${moduleName}_import.dart`);
-            }
-            else {
-                LoggerHelpers.info("Repo part directive already exists in import file.");
-            }
-        }
-        else {
-            LoggerHelpers.warning(`Import file not found at ${importFilePath}. Add the part directive manually.`);
-        }
-        LoggerHelpers.success(`Repository added to module ${moduleName}.`);
+        LoggerHelpers.success(`Repository created at ${path.join(repoPath, `${moduleName}_repo.dart`)}`);
     }
     catch (error) {
         handleCommandError(error, "Error generating repo");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "optikit",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "OptiKit CLI",
   "main": "src/cli.ts",
   "type": "module",

package/src/commands/project/commands.ts

@@ -29,7 +29,7 @@ export const projectCommands: CommandModule[] = [
     builder: (yargs) => {
       return yargs.positional("moduleName", { describe: "The module name", type: "string" as const });
     },
-    handler: (argv) => { generateRepoModule(argv.moduleName as string); },
+    handler: async (argv) => { await generateRepoModule(argv.moduleName as string); },
   },
   {
     command: "add-route <moduleName>",

package/src/commands/project/generate.ts

@@ -1,5 +1,6 @@
 import fs from "fs";
 import path from "path";
+import chalk from "chalk";
 import {
   createDirectories,
   writeFile,
@@ -44,7 +45,6 @@ function generateModule(moduleName: string) {
     generateScreen(moduleName, path.join(modulePath, "screen"));
     generateImport(moduleName, path.join(modulePath, "import"));
     generateStateFactory(moduleName, path.join(modulePath, "factory"));
-    generateRepo(moduleName, path.join(modulePath, "repo"));
 
     LoggerHelpers.success(`Module ${moduleName} created with full structure.`);
   } catch (error) {
@@ -170,7 +170,6 @@ part '../event/${moduleName}_event.dart';
 part '../screen/${moduleName}_screen.dart';
 part '../state/${moduleName}_state.dart';
 part '../factory/${moduleName}_factory.dart';
-part '../repo/${moduleName}_repo.dart';
   `;
 
   writeFile(importFilePath, template);
@@ -206,7 +205,7 @@ function generateRepo(moduleName: string, repoPath: string) {
   const repoFilePath = path.join(repoPath, `${moduleName}_repo.dart`);
   const className = getClassName(moduleName);
 
-  const template = `part of '../import/${moduleName}_import.dart';
+  const template = `import 'package:opticore/opticore.dart';
 
 class ${className}Repo extends BaseRepo {
 
@@ -217,7 +216,7 @@ class ${className}Repo extends BaseRepo {
     );
   }
 }
-  `;
+`;
 
   writeFile(repoFilePath, template);
   LoggerHelpers.success(
@@ -226,12 +225,238 @@ class ${className}Repo extends BaseRepo {
 }
 
 /**
- * Generates a repository for an existing module.
- * Creates repo directory, generates repo file, and appends part directive to import file.
+ * Builds the list of selectable items for the directory picker.
+ */
+interface PickerItem {
+  label: string;
+  icon: string;
+  action: "select" | "back" | "open" | "create";
+  dirName?: string;
+}
+
+function buildPickerItems(currentPath: string, rootPath: string): PickerItem[] {
+  const items: PickerItem[] = [];
+
+  // "Select here" always first
+  items.push({ label: "Select this directory", icon: "✔", action: "select" });
+
+  // Go back (unless at root)
+  const canGoBack = currentPath !== rootPath && currentPath !== ".";
+  if (canGoBack) {
+    items.push({ label: "..", icon: "↩", action: "back" });
+  }
+
+  // Subdirectories
+  if (fs.existsSync(currentPath)) {
+    const dirs = fs.readdirSync(currentPath, { withFileTypes: true })
+      .filter(e => e.isDirectory() && !e.name.startsWith('.'))
+      .map(e => e.name)
+      .sort();
+    for (const dir of dirs) {
+      items.push({ label: `${dir}/`, icon: "📁", action: "open", dirName: dir });
+    }
+  }
+
+  // Create new folder always last
+  items.push({ label: "Create new folder", icon: "✚", action: "create" });
+
+  return items;
+}
+
+/**
+ * Interactive arrow-key directory picker.
+ * Navigate with arrow keys, enter to select/open, esc to cancel.
+ */
+function pickDirectory(startPath: string): Promise<string> {
+  return new Promise((resolve, reject) => {
+    let currentPath = startPath;
+    const rootPath = startPath;
+    let cursor = 0;
+    let items = buildPickerItems(currentPath, rootPath);
+    let totalLines = 0;
+    let creatingFolder = false;
+    let folderInput = "";
+
+    const stdin = process.stdin;
+    const wasRaw = stdin.isRaw ?? false;
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+
+    function render() {
+      // Clear previous output
+      if (totalLines > 0) {
+        process.stdout.write(`\x1B[${totalLines}A`);
+        process.stdout.write("\x1B[0J");
+      }
+
+      const lines: string[] = [];
+
+      // Header — current path with breadcrumb
+      lines.push("");
+      lines.push(chalk.cyan.bold(`  📂 ${currentPath}/`));
+      lines.push(chalk.gray("  ─────────────────────────────────────"));
+
+      // Menu items
+      for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+        const isActive = i === cursor;
+
+        if (isActive) {
+          const pointer = chalk.cyan.bold("❯");
+          const icon = item.action === "select" ? chalk.green(item.icon) :
+                       item.action === "back" ? chalk.yellow(item.icon) :
+                       item.action === "create" ? chalk.magenta(item.icon) :
+                       chalk.blue(item.icon);
+          lines.push(`  ${pointer} ${icon}  ${chalk.white.bold(item.label)}`);
+        } else {
+          const icon = chalk.gray(item.icon);
+          lines.push(`    ${icon}  ${chalk.gray(item.label)}`);
+        }
+      }
+
+      lines.push(chalk.gray("  ─────────────────────────────────────"));
+
+      if (creatingFolder) {
+        lines.push(chalk.magenta(`  ✚ New folder name: `) + chalk.white.bold(folderInput) + chalk.gray("▌"));
+      } else {
+        lines.push(chalk.gray("  ↑↓ navigate  ⏎ select/open  ← back  esc cancel"));
+      }
+
+      const output = lines.join("\n") + "\n";
+      process.stdout.write(output);
+      totalLines = lines.length;
+    }
+
+    function cleanup() {
+      stdin.setRawMode(wasRaw);
+      stdin.removeListener("data", onKeypress);
+      stdin.pause();
+    }
+
+    function refreshItems() {
+      items = buildPickerItems(currentPath, rootPath);
+      cursor = 0;
+    }
+
+    function onKeypress(key: string) {
+      // Handle folder creation mode
+      if (creatingFolder) {
+        if (key === "\r") {
+          // Enter — create the folder
+          const trimmed = folderInput.trim();
+          if (trimmed.length > 0) {
+            const newPath = path.join(currentPath, trimmed);
+            fs.mkdirSync(newPath, { recursive: true });
+            currentPath = newPath;
+            refreshItems();
+          }
+          creatingFolder = false;
+          folderInput = "";
+          render();
+        } else if (key === "\x1B") {
+          // Esc — cancel folder creation
+          creatingFolder = false;
+          folderInput = "";
+          render();
+        } else if (key === "\x7F" || key === "\b") {
+          // Backspace
+          folderInput = folderInput.slice(0, -1);
+          render();
+        } else if (key.length === 1 && key.charCodeAt(0) >= 32) {
+          // Regular character
+          folderInput += key;
+          render();
+        }
+        return;
+      }
+
+      const item = items[cursor];
+
+      // Escape — cancel (single \x1B only, not arrow key sequences)
+      if (key === "\x1B" && key.length === 1) {
+        cleanup();
+        reject(new Error("Directory selection cancelled."));
+        return;
+      }
+
+      // Arrow keys
+      if (key === "\x1B[A") {
+        // Up
+        cursor = cursor > 0 ? cursor - 1 : items.length - 1;
+        render();
+        return;
+      }
+      if (key === "\x1B[B") {
+        // Down
+        cursor = cursor < items.length - 1 ? cursor + 1 : 0;
+        render();
+        return;
+      }
+      if (key === "\x1B[D") {
+        // Left arrow — go back
+        if (currentPath !== rootPath && currentPath !== ".") {
+          currentPath = path.dirname(currentPath);
+          refreshItems();
+          render();
+        }
+        return;
+      }
+      if (key === "\x1B[C") {
+        // Right arrow — open directory if cursor is on a folder
+        if (item.action === "open" && item.dirName) {
+          currentPath = path.join(currentPath, item.dirName);
+          refreshItems();
+          render();
+        }
+        return;
+      }
+
+      // Enter — perform action
+      if (key === "\r") {
+        if (item.action === "select") {
+          cleanup();
+          resolve(currentPath);
+          return;
+        }
+        if (item.action === "back") {
+          currentPath = path.dirname(currentPath);
+          refreshItems();
+          render();
+          return;
+        }
+        if (item.action === "open" && item.dirName) {
+          currentPath = path.join(currentPath, item.dirName);
+          refreshItems();
+          render();
+          return;
+        }
+        if (item.action === "create") {
+          creatingFolder = true;
+          folderInput = "";
+          render();
+          return;
+        }
+      }
+
+      // Ctrl+C
+      if (key === "\x03") {
+        cleanup();
+        process.exit(0);
+      }
+    }
+
+    stdin.on("data", onKeypress);
+    render();
+  });
+}
+
+/**
+ * Generates a repository file at a user-selected location.
+ * Opens an interactive directory picker starting from lib/.
  */
-function generateRepoModule(moduleName: string) {
+async function generateRepoModule(moduleName: string) {
   try {
-    // Validate module name
     if (!moduleName || moduleName.trim().length === 0) {
       LoggerHelpers.error(ERROR_MESSAGES.MODULE_NAME_EMPTY);
       process.exit(1);
@@ -242,41 +467,19 @@ function generateRepoModule(moduleName: string) {
       process.exit(1);
     }
 
-    const modulePath = path.join("lib", "module", moduleName);
+    LoggerHelpers.info(`Generating repository for ${moduleName}...`);
+    LoggerHelpers.info("Select where to create the repo file:");
 
-    // Verify module exists
-    if (!fs.existsSync(modulePath)) {
-      LoggerHelpers.error(`Module ${moduleName} does not exist at ${modulePath}. Create it first with: optikit generate module ${moduleName}`);
-      process.exit(1);
-    }
+    const startDir = fs.existsSync("lib") ? "lib" : ".";
+    const repoPath = await pickDirectory(startDir);
 
-    // Create repo directory
-    const repoPath = path.join(modulePath, "repo");
     if (!fs.existsSync(repoPath)) {
       fs.mkdirSync(repoPath, { recursive: true });
     }
 
-    LoggerHelpers.info(`Adding repository to module ${moduleName}...`);
     generateRepo(moduleName, repoPath);
 
-    // Append part directive to import file if not already present
-    const importFilePath = path.join(modulePath, "import", `${moduleName}_import.dart`);
-    if (fs.existsSync(importFilePath)) {
-      const importContent = fs.readFileSync(importFilePath, "utf8");
-      const repoPartLine = `part '../repo/${moduleName}_repo.dart';`;
-
-      if (!importContent.includes(repoPartLine)) {
-        const updatedContent = importContent.trimEnd() + `\n${repoPartLine}\n`;
-        writeFile(importFilePath, updatedContent);
-        LoggerHelpers.success(`Added repo part directive to ${moduleName}_import.dart`);
-      } else {
-        LoggerHelpers.info("Repo part directive already exists in import file.");
-      }
-    } else {
-      LoggerHelpers.warning(`Import file not found at ${importFilePath}. Add the part directive manually.`);
-    }
-
-    LoggerHelpers.success(`Repository added to module ${moduleName}.`);
+    LoggerHelpers.success(`Repository created at ${path.join(repoPath, `${moduleName}_repo.dart`)}`);
   } catch (error) {
     handleCommandError(error, "Error generating repo");
   }