@nexical/cli 0.11.17 → 0.11.19

package/src/commands/prompt.ts

@@ -1,14 +1,9 @@
 import { type CommandDefinition, BaseCommand, logger } from '@nexical/cli-core';
 import fs from 'fs-extra';
 import path from 'path';
-import os from 'node:os';
-import nunjucks from 'nunjucks';
 import minimist from 'minimist';
-import readline from 'node:readline';
 import YAML from 'yaml';
-import { pack } from 'repomix';
-import { existsSync, statSync } from 'node:fs';
-import { AiClientFactory } from '@nexical/ai';
+import { PromptRunner } from '@nexical/ai';
 
 export default class PromptCommand extends BaseCommand {
   static usage = 'prompt <prompt-name> [args...]';
@@ -57,7 +52,7 @@ export default class PromptCommand extends BaseCommand {
 
     // Parse additional template flags
     const argv = minimist(options.args || []);
-    const isInteractive = options.interactive || options.i || argv.interactive || argv.i;
+    const isInteractive = !!(options.interactive || options.i || argv.interactive || argv.i);
     const moduleName = options.module || options.m || argv.module || argv.m;
     const modelsArg =
       options.models || argv.models || 'gemini-3-flash-preview,gemini-3-pro-preview';
@@ -66,8 +61,6 @@ export default class PromptCommand extends BaseCommand {
       .map((m: string) => m.trim())
       .filter(Boolean);
 
-    // Resolve prompt file from multiple directories
-    const promptFileName = promptName.endsWith('.md') ? promptName : `${promptName}.md`;
     const PROMPTS_DIRS = [path.join(projectRoot, 'prompts')];
     const generatorAgentsPrompts = path.join(projectRoot, 'packages/generator/prompts/agents');
 
@@ -75,23 +68,6 @@ export default class PromptCommand extends BaseCommand {
       PROMPTS_DIRS.push(generatorAgentsPrompts);
     }
 
-    let promptFile: string | undefined;
-    for (const dir of PROMPTS_DIRS) {
-      const candidate = path.join(dir, promptFileName);
-      if (await fs.pathExists(candidate)) {
-        promptFile = candidate;
-        break;
-      }
-    }
-
-    if (!promptFile) {
-      this.error(
-        `Prompt file '${promptFileName}' not found in any of the search directories:\n` +
-          PROMPTS_DIRS.map((d) => `  - ${d}`).join('\n'),
-      );
-      return;
-    }
-
     // Module Resolution Logic
     const contextVars = { ...argv };
     if (moduleName) {
@@ -127,183 +103,6 @@ export default class PromptCommand extends BaseCommand {
       }
     }
 
-    // Configure Nunjucks
-    const env = new nunjucks.Environment(new nunjucks.FileSystemLoader(PROMPTS_DIRS), {
-      autoescape: false,
-      trimBlocks: true,
-      lstripBlocks: true,
-    });
-
-    const asyncResolvers = new Map<string, Promise<string>>();
-    let resolverId = 0;
-
-    // Helper: context(path) -> runs repomix
-    env.addGlobal('context', (targetPath: string) => {
-      const id = `__NEXICAL_ASYNC_CONTEXT_${resolverId++}__`;
-      const promise = (async () => {
-        try {
-          if (!existsSync(targetPath)) {
-            logger.debug(`[Context] Path not found: ${targetPath}`);
-            return `[Path not found: ${targetPath}]`;
-          }
-
-          const stats = statSync(targetPath);
-          if (stats.isFile()) {
-            logger.debug(`[Context] Reading file directly at: ${targetPath}`);
-            const content = await fs.readFile(targetPath, 'utf-8');
-            return `<CODEBASE_CONTEXT path="${targetPath}">\n${content}\n</CODEBASE_CONTEXT>`;
-          }
-
-          logger.debug(`[Context] Analyzing codebase at: ${targetPath}`);
-          const tempOutputFile = path.join(
-            os.tmpdir(),
-            `repomix-output-${Date.now()}-${Math.random().toString(36).substring(7)}.xml`,
-          );
-
-          await pack([targetPath], {
-            input: { maxFileSize: 1024 * 1024 * 10 },
-            output: {
-              filePath: tempOutputFile,
-              style: 'xml',
-              showLineNumbers: false,
-              fileSummary: false,
-              directoryStructure: false,
-              removeComments: false,
-              removeEmptyLines: false,
-              includeEmptyDirectories: false,
-              topFilesLength: 5,
-              parsableStyle: false,
-              files: true,
-              compress: false,
-              truncateBase64: true,
-              copyToClipboard: false,
-              includeDiffs: false,
-              includeLogs: false,
-              includeLogsCount: 0,
-              gitSortByChanges: false,
-              includeFullDirectoryStructure: false,
-            },
-            ignore: {
-              useGitignore: true,
-              useDotIgnore: true,
-              useDefaultPatterns: true,
-              customPatterns: ['**/node_modules', '**/dist'],
-            },
-            include: [],
-            security: { enableSecurityCheck: false },
-            tokenCount: { encoding: 'o200k_base' },
-            cwd: targetPath,
-          } as unknown as Parameters<typeof pack>[1]);
-
-          const output = await fs.readFile(tempOutputFile, 'utf-8');
-          try {
-            await fs.unlink(tempOutputFile);
-          } catch {
-            /* ignore */
-          }
-          return `<CODEBASE_CONTEXT path="${targetPath}">\n${output}\n</CODEBASE_CONTEXT>`;
-        } catch (error) {
-          logger.error(`[Context] Error generating context for ${targetPath}: ${error}`);
-          return `[Error generating context for ${targetPath}]`;
-        }
-      })();
-      asyncResolvers.set(id, promise);
-      return id;
-    });
-
-    // Helper: read(path) -> reads local file
-    env.addGlobal('read', (relativePath: string | string[]) => {
-      const id = `__NEXICAL_ASYNC_READ_${resolverId++}__`;
-      const promise = (async () => {
-        try {
-          const cwdStr = process.cwd();
-          if (Array.isArray(relativePath)) {
-            const contents = await Promise.all(
-              relativePath.map(async (p) => {
-                const resolvedPath = path.resolve(cwdStr, p);
-                if (!existsSync(resolvedPath)) {
-                  logger.debug(`[Read] File not found: ${resolvedPath}`);
-                  return `[File not found: ${resolvedPath}]`;
-                }
-                return await fs.readFile(resolvedPath, 'utf-8');
-              }),
-            );
-            return contents.join('\n\n');
-          } else if (typeof relativePath === 'string' && relativePath.includes(',')) {
-            const contents = await Promise.all(
-              relativePath.split(',').map(async (p) => {
-                const resolvedPath = path.resolve(cwdStr, p.trim());
-                if (!existsSync(resolvedPath)) {
-                  logger.debug(`[Read] File not found: ${resolvedPath}`);
-                  return `[File not found: ${resolvedPath}]`;
-                }
-                return await fs.readFile(resolvedPath, 'utf-8');
-              }),
-            );
-            return contents.join('\n\n');
-          }
-
-          const resolvedPath = path.resolve(cwdStr, relativePath as string);
-          if (!existsSync(resolvedPath)) {
-            logger.debug(`[Read] File not found: ${resolvedPath}`);
-            return `[File not found: ${resolvedPath}]`;
-          }
-          return await fs.readFile(resolvedPath, 'utf-8');
-        } catch {
-          logger.warn(`[Read] Warning: Could not read file: ${relativePath}`);
-          return `[Error reading file ${relativePath}]`;
-        }
-      })();
-      asyncResolvers.set(id, promise);
-      return id;
-    });
-
-    // Read template content
-    let templateContent: string;
-    try {
-      templateContent = await fs.readFile(promptFile, 'utf-8');
-    } catch (error) {
-      if (error instanceof Error) {
-        this.error(`Error reading prompt file: ${error.message}`);
-      } else {
-        this.error(`Error reading prompt file: ${String(error)}`);
-      }
-      return;
-    }
-
-    // Render template
-    logger.debug(
-      `[Render] Rendering template with variables:`,
-      JSON.stringify(contextVars, null, 2),
-    );
-    let renderedPrompt: string;
-    try {
-      renderedPrompt = env.renderString(templateContent, {
-        ...contextVars,
-      });
-    } catch (e) {
-      this.error(`Template render error: ${e}`);
-      return;
-    }
-
-    // Resolve placeholders
-    for (const [id, promise] of asyncResolvers.entries()) {
-      try {
-        const resolvedValue = await promise;
-        renderedPrompt = renderedPrompt.replace(id, resolvedValue);
-      } catch (e) {
-        logger.error(`[Render] Failed to resolve async variable ${id}: ${e}`);
-        renderedPrompt = renderedPrompt.replace(id, `[Error resolving id]`);
-      }
-    }
-
-    // Buffer to file
-    const tempFile = path.join(os.tmpdir(), '.temp_prompt_active.md');
-    await fs.writeFile(tempFile, renderedPrompt, 'utf-8');
-    logger.debug(`[Buffer] Wrote active prompt to ${tempFile}`);
-
-    logger.info(`[Agent] Model rotation strategy: [${models.join(', ')}]`);
-
     // Extract AI configuration from nexical.yaml
     const configPath = path.join(projectRoot, 'nexical.yaml');
     let aiConfig: Record<string, unknown> = {};
@@ -317,76 +116,14 @@ export default class PromptCommand extends BaseCommand {
       }
     }
 
-    // Create AI client
-    const aiClient = AiClientFactory.create(aiConfig);
-
-    let currentPrompt = renderedPrompt;
-    let finalCode = 0;
-
-    while (true) {
-      let success = false;
-      let lastOutput = '';
-
-      for (const model of models) {
-        logger.info(`[Agent] Attempting with model: \x1b[36m${model}\x1b[0m...`);
-        const result = await aiClient.run(model, currentPrompt);
-
-        if (result.code === 0) {
-          success = true;
-          lastOutput = result.output;
-          break;
-        }
-
-        if (result.shouldRetry) {
-          logger.info(`[Agent] Switching to next model...`);
-          continue;
-        } else {
-          finalCode = result.code;
-          break;
-        }
-      }
-
-      if (!success) {
-        if (finalCode === 0) finalCode = 1;
-        this.error(`[Agent] \u274C All attempts failed.`);
-        break;
-      }
-
-      if (!isInteractive) {
-        break;
-      }
-
-      currentPrompt += `\n${lastOutput}`;
-
-      const askLink = () => {
-        const rl = readline.createInterface({
-          input: process.stdin,
-          output: process.stdout,
-        });
-        return new Promise<string>((resolve) => {
-          this.info('\n(Type "exit" or "quit" to end the session)');
-          rl.question('> ', (ans) => {
-            rl.close();
-            resolve(ans);
-          });
-        });
-      };
-
-      const answer = await askLink();
-
-      if (['exit', 'quit'].includes(answer.trim().toLowerCase())) {
-        break;
-      }
-
-      currentPrompt += `\nUser: ${answer}\n`;
-    }
-
-    try {
-      await fs.unlink(tempFile);
-      logger.debug(`[Cleanup] Removed active prompt file`);
-    } catch {
-      // ignore cleanup errors
-    }
+    const finalCode = await PromptRunner.run({
+      promptName,
+      promptDirs: PROMPTS_DIRS,
+      args: contextVars,
+      aiConfig,
+      models,
+      interactive: isInteractive as boolean,
+    });
 
     if (finalCode !== 0) {
       process.exit(finalCode);

package/src/utils/filter.ts

@@ -0,0 +1,47 @@
+import path from 'node:path';
+
+/**
+ * Filters out duplicate core commands and source versions from additional command directories.
+ * @param additionalCommands List of discovered command directories.
+ * @param coreCommandsDir The primary core commands directory.
+ * @returns Filtered list of additional command directories.
+ */
+export function filterCommandDirectories(
+  additionalCommands: string[],
+  coreCommandsDir: string,
+): string[] {
+  return additionalCommands.filter((dir) => {
+    const resolvedDir = path.resolve(dir);
+    const resolvedCore = path.resolve(coreCommandsDir);
+
+    if (resolvedDir === resolvedCore) return false;
+
+    // Check if this is another instance of the core CLI commands (by checking path suffix)
+    const coreSuffix = path.join('@nexical', 'cli', 'dist', 'src', 'commands');
+    const coreSuffixSrc = path.join('packages', 'cli', 'dist', 'src', 'commands');
+    const coreSuffixRawSrc = path.join('packages', 'cli', 'src', 'commands');
+
+    if (
+      resolvedDir.endsWith(coreSuffix) ||
+      resolvedDir.endsWith(coreSuffixSrc) ||
+      resolvedDir.endsWith(coreSuffixRawSrc)
+    ) {
+      return false;
+    }
+
+    // Handle mismatch between dist/src and src/
+    const distSuffix = path.join('dist', 'src', 'commands');
+    const srcSuffix = path.join('src', 'commands');
+    if (resolvedCore.endsWith(distSuffix)) {
+      const baseDir = resolvedCore.substring(0, resolvedCore.length - distSuffix.length);
+      const srcVersion = path.join(baseDir, srcSuffix);
+      const normalizedDir = path.normalize(resolvedDir);
+      const normalizedSrc = path.normalize(srcVersion);
+      if (normalizedDir === normalizedSrc) {
+        return false;
+      }
+    }
+
+    return true;
+  });
+}

package/test/integration/commands/prompt.integration.test.ts

@@ -0,0 +1,110 @@
+import { describe, it, expect, vi, beforeEach, afterAll } from 'vitest';
+import PromptCommand from '../../../src/commands/prompt.js';
+import { createTempDir, createMockRepo, cleanupTestRoot } from '../../utils/integration-helpers.js';
+import path from 'node:path';
+import fs from 'fs-extra';
+import { CLI } from '@nexical/cli-core';
+import { PromptRunner } from '@nexical/ai';
+
+vi.mock('@nexical/ai', () => ({
+  PromptRunner: {
+    run: vi.fn().mockResolvedValue(0),
+  },
+}));
+
+describe('Prompt Command Integration', () => {
+  let projectDir: string;
+
+  beforeEach(async () => {
+    const temp = await createTempDir('prompt-integration-');
+    projectDir = await createMockRepo(temp, {
+      'package.json': '{"name": "prompt-project", "version": "1.0.0"}',
+      'nexical.yaml': 'ai:\n  provider: vertex',
+      'prompts/test-prompt.md': 'Testing {{ name }}',
+    });
+  });
+
+  afterAll(async () => {
+    await cleanupTestRoot();
+  });
+
+  it('should resolve project config and call PromptRunner', async () => {
+    const originalCwd = process.cwd();
+    try {
+      process.chdir(projectDir);
+      const cli = new CLI({ commandName: 'nexical' });
+      const command = new PromptCommand(cli);
+
+      // We need to set projectRoot manually because BaseCommand detection
+      // might fail if not properly initialized in test env
+      (command as unknown as { projectRoot: string }).projectRoot = projectDir;
+
+      await command.run({ promptName: 'test-prompt' });
+
+      expect(PromptRunner.run).toHaveBeenCalledWith(
+        expect.objectContaining({
+          promptName: 'test-prompt',
+          promptDirs: [path.join(projectDir, 'prompts')],
+          aiConfig: { provider: 'vertex' },
+        }),
+      );
+    } finally {
+      process.chdir(originalCwd);
+    }
+  });
+
+  it('should resolve module context in integration', async () => {
+    const originalCwd = process.cwd();
+    try {
+      process.chdir(projectDir);
+
+      const moduleDir = path.join(projectDir, 'apps/frontend/modules/my-mod');
+      await fs.ensureDir(moduleDir);
+
+      const cli = new CLI({ commandName: 'nexical' });
+      const command = new PromptCommand(cli);
+      (command as unknown as { projectRoot: string }).projectRoot = projectDir;
+
+      await command.run({ promptName: 'test-prompt', module: 'my-mod' });
+
+      expect(PromptRunner.run).toHaveBeenCalledWith(
+        expect.objectContaining({
+          args: expect.objectContaining({
+            module_name: 'my-mod',
+            module_type: 'frontend',
+            module_root: moduleDir,
+          }),
+        }),
+      );
+    } finally {
+      process.chdir(originalCwd);
+    }
+  });
+
+  it('should include generator agents prompts if they exist in integration', async () => {
+    const originalCwd = process.cwd();
+    try {
+      process.chdir(projectDir);
+
+      const generatorPromptsDir = path.join(projectDir, 'packages/generator/prompts/agents');
+      await fs.ensureDir(generatorPromptsDir);
+
+      const cli = new CLI({ commandName: 'nexical' });
+      const command = new PromptCommand(cli);
+      (command as unknown as { projectRoot: string }).projectRoot = projectDir;
+
+      await command.run({ promptName: 'test-prompt' });
+
+      expect(PromptRunner.run).toHaveBeenCalledWith(
+        expect.objectContaining({
+          promptDirs: expect.arrayContaining([
+            path.join(projectDir, 'prompts'),
+            generatorPromptsDir,
+          ]),
+        }),
+      );
+    } finally {
+      process.chdir(originalCwd);
+    }
+  });
+});