rrce-workflow 0.2.14 → 0.2.15

package/dist/lib/paths.js

@@ -0,0 +1,296 @@
+import * as fs from 'fs';
+import * as path from 'path';
+// Environment variables
+const RRCE_HOME = process.env.RRCE_HOME || path.join(process.env.HOME || '~', '.rrce-workflow');
+const RRCE_WORKSPACE = process.env.RRCE_WORKSPACE;
+/**
+ * Detect workspace root by walking up from CWD
+ */
+export function detectWorkspaceRoot() {
+    if (RRCE_WORKSPACE) {
+        return RRCE_WORKSPACE;
+    }
+    let current = process.cwd();
+    while (current !== '/') {
+        // Check for .git or .rrce-workflow/config.yaml (new location)
+        // Also check legacy .rrce-workflow.yaml for backwards compatibility
+        if (fs.existsSync(path.join(current, '.git')) ||
+            fs.existsSync(path.join(current, '.rrce-workflow', 'config.yaml')) ||
+            fs.existsSync(path.join(current, '.rrce-workflow.yaml'))) {
+            return current;
+        }
+        current = path.dirname(current);
+    }
+    return process.cwd();
+}
+/**
+ * Get the config file path for a workspace
+ * New location: .rrce-workflow/config.yaml
+ * Legacy location: .rrce-workflow.yaml (for backwards compatibility)
+ */
+export function getConfigPath(workspaceRoot) {
+    const newPath = path.join(workspaceRoot, '.rrce-workflow', 'config.yaml');
+    const legacyPath = path.join(workspaceRoot, '.rrce-workflow.yaml');
+    // Prefer new location, fall back to legacy
+    if (fs.existsSync(newPath)) {
+        return newPath;
+    }
+    if (fs.existsSync(legacyPath)) {
+        return legacyPath;
+    }
+    // Default to new location for new configs
+    return newPath;
+}
+/**
+ * Get workspace name from directory or config
+ */
+export function getWorkspaceName(workspaceRoot) {
+    // TODO: Check .rrce-workflow.yaml for project.name
+    return path.basename(workspaceRoot);
+}
+/**
+ * Resolve primary data path based on storage mode
+ * Note: For 'both' mode, use resolveAllDataPaths() to get all paths
+ */
+export function resolveDataPath(mode, workspaceName, workspaceRoot) {
+    switch (mode) {
+        case 'global':
+            return path.join(RRCE_HOME, 'workspaces', workspaceName);
+        case 'workspace':
+            return path.join(workspaceRoot, '.rrce-workflow');
+        case 'both':
+            // Primary is workspace for 'both' mode
+            return path.join(workspaceRoot, '.rrce-workflow');
+        default:
+            return path.join(RRCE_HOME, 'workspaces', workspaceName);
+    }
+}
+/**
+ * Resolve ALL data paths based on storage mode
+ * Returns array of paths where data should be stored:
+ * - 'global': [~/.rrce-workflow/workspaces/<name>]
+ * - 'workspace': [<workspace>/.rrce-workflow]
+ * - 'both': [<workspace>/.rrce-workflow, ~/.rrce-workflow/workspaces/<name>]
+ */
+export function resolveAllDataPaths(mode, workspaceName, workspaceRoot) {
+    const globalPath = path.join(RRCE_HOME, 'workspaces', workspaceName);
+    const workspacePath = path.join(workspaceRoot, '.rrce-workflow');
+    switch (mode) {
+        case 'global':
+            return [globalPath];
+        case 'workspace':
+            return [workspacePath];
+        case 'both':
+            return [workspacePath, globalPath];
+        default:
+            return [globalPath];
+    }
+}
+/**
+ * Get RRCE home directory
+ */
+export function getRRCEHome() {
+    return RRCE_HOME;
+}
+/**
+ * List all projects in global storage
+ * @param excludeWorkspace - Workspace name to exclude from the list (typically current workspace)
+ * @returns Array of project names found in ~/.rrce-workflow/workspaces/
+ */
+export function listGlobalProjects(excludeWorkspace) {
+    const workspacesDir = path.join(RRCE_HOME, 'workspaces');
+    if (!fs.existsSync(workspacesDir)) {
+        return [];
+    }
+    try {
+        const entries = fs.readdirSync(workspacesDir, { withFileTypes: true });
+        return entries
+            .filter(entry => entry.isDirectory() && entry.name !== excludeWorkspace)
+            .map(entry => entry.name);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Get the knowledge path for a global project
+ */
+export function getGlobalProjectKnowledgePath(projectName) {
+    return path.join(RRCE_HOME, 'workspaces', projectName, 'knowledge');
+}
+/**
+ * Get the global workspace data path for a project
+ */
+export function getGlobalWorkspacePath(workspaceName) {
+    return path.join(RRCE_HOME, 'workspaces', workspaceName);
+}
+/**
+ * Get the local workspace data path
+ */
+export function getLocalWorkspacePath(workspaceRoot) {
+    return path.join(workspaceRoot, '.rrce-workflow');
+}
+/**
+ * Ensure directory exists
+ */
+export function ensureDir(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+    }
+}
+/**
+ * Get path for agent prompts based on tool
+ * IDE-specific locations so IDEs can auto-discover prompts
+ */
+export function getAgentPromptPath(workspaceRoot, tool) {
+    if (tool === 'copilot') {
+        return path.join(workspaceRoot, '.github', 'agents');
+    }
+    else {
+        return path.join(workspaceRoot, '.agent', 'workflows');
+    }
+}
+/**
+ * Copy a file to all storage paths
+ * @param sourceFile - Absolute path to source file
+ * @param relativePath - Relative path within the data directory (e.g., 'knowledge/context.md')
+ * @param dataPaths - Array of data paths from resolveAllDataPaths()
+ */
+export function copyToAllStoragePaths(sourceFile, relativePath, dataPaths) {
+    const content = fs.readFileSync(sourceFile);
+    for (const dataPath of dataPaths) {
+        const targetPath = path.join(dataPath, relativePath);
+        ensureDir(path.dirname(targetPath));
+        fs.writeFileSync(targetPath, content);
+    }
+}
+/**
+ * Write content to a file in all storage paths
+ * @param content - Content to write
+ * @param relativePath - Relative path within the data directory
+ * @param dataPaths - Array of data paths from resolveAllDataPaths()
+ */
+export function writeToAllStoragePaths(content, relativePath, dataPaths) {
+    for (const dataPath of dataPaths) {
+        const targetPath = path.join(dataPath, relativePath);
+        ensureDir(path.dirname(targetPath));
+        fs.writeFileSync(targetPath, content);
+    }
+}
+/**
+ * Copy a directory recursively to all storage paths
+ * @param sourceDir - Absolute path to source directory
+ * @param relativeDir - Relative directory path within the data directory
+ * @param dataPaths - Array of data paths from resolveAllDataPaths()
+ */
+export function copyDirToAllStoragePaths(sourceDir, relativeDir, dataPaths) {
+    if (!fs.existsSync(sourceDir)) {
+        return;
+    }
+    const entries = fs.readdirSync(sourceDir, { withFileTypes: true });
+    for (const entry of entries) {
+        const sourcePath = path.join(sourceDir, entry.name);
+        const relativePath = path.join(relativeDir, entry.name);
+        if (entry.isDirectory()) {
+            copyDirToAllStoragePaths(sourcePath, relativePath, dataPaths);
+        }
+        else {
+            copyToAllStoragePaths(sourcePath, relativePath, dataPaths);
+        }
+    }
+}
+/**
+ * Sync metadata subdirectories (knowledge, refs, tasks) to all storage paths
+ * Copies from agent-core to all configured storage locations
+ */
+export function syncMetadataToAll(agentCorePath, dataPaths) {
+    const metadataDirs = ['knowledge', 'refs', 'tasks'];
+    for (const dir of metadataDirs) {
+        const sourceDir = path.join(agentCorePath, dir);
+        copyDirToAllStoragePaths(sourceDir, dir, dataPaths);
+    }
+}
+/**
+ * Check if a directory path is writable
+ * Creates a test file and removes it to verify write access
+ */
+export function checkWriteAccess(dirPath) {
+    const testFile = path.join(dirPath, '.rrce-write-test');
+    try {
+        // Ensure directory exists first
+        if (!fs.existsSync(dirPath)) {
+            fs.mkdirSync(dirPath, { recursive: true });
+        }
+        // Try to write and delete a test file
+        fs.writeFileSync(testFile, 'write-test');
+        fs.unlinkSync(testFile);
+        return true;
+    }
+    catch {
+        // Clean up if test file was created but couldn't be deleted
+        try {
+            if (fs.existsSync(testFile)) {
+                fs.unlinkSync(testFile);
+            }
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+        return false;
+    }
+}
+/**
+ * Get the default RRCE_HOME path (from env or ~/.rrce-workflow)
+ */
+export function getDefaultRRCEHome() {
+    return process.env.RRCE_HOME || path.join(process.env.HOME || '~', '.rrce-workflow');
+}
+/**
+ * Get suggested global paths for user selection
+ * Returns array of { path, label, isWritable } objects
+ */
+export function getSuggestedGlobalPaths() {
+    const suggestions = [];
+    // Option 1: RRCE_HOME environment variable (if explicitly set)
+    if (process.env.RRCE_HOME) {
+        suggestions.push({
+            path: process.env.RRCE_HOME,
+            label: 'RRCE_HOME (environment)',
+            isWritable: checkWriteAccess(process.env.RRCE_HOME),
+        });
+    }
+    // Option 2: Standard ~/.rrce-workflow
+    const homeDefault = path.join(process.env.HOME || '~', '.rrce-workflow');
+    if (!process.env.RRCE_HOME || process.env.RRCE_HOME !== homeDefault) {
+        suggestions.push({
+            path: homeDefault,
+            label: '~/.rrce-workflow (default)',
+            isWritable: checkWriteAccess(homeDefault),
+        });
+    }
+    return suggestions;
+}
+/**
+ * Get effective RRCE_HOME by reading from workspace config if available
+ * Falls back to default RRCE_HOME if no custom path is configured
+ */
+export function getEffectiveRRCEHome(workspaceRoot) {
+    // Check workspace config for custom globalPath
+    if (workspaceRoot) {
+        const configPath = getConfigPath(workspaceRoot);
+        if (fs.existsSync(configPath)) {
+            try {
+                const content = fs.readFileSync(configPath, 'utf-8');
+                const globalPathMatch = content.match(/globalPath:\s*["']?([^"'\n]+)["']?/);
+                if (globalPathMatch?.[1]) {
+                    return globalPathMatch[1].trim();
+                }
+            }
+            catch {
+                // Ignore parse errors
+            }
+        }
+    }
+    // Fall back to default
+    return getDefaultRRCEHome();
+}

package/dist/lib/prompts.d.ts

@@ -0,0 +1,18 @@
+import { type ParsedPrompt } from '../types/prompt';
+/**
+ * Parse a prompt file and extract frontmatter + content
+ */
+export declare function parsePromptFile(filePath: string): ParsedPrompt | null;
+/**
+ * Load all prompts from a directory
+ */
+export declare function loadPromptsFromDir(dirPath: string): ParsedPrompt[];
+/**
+ * Get the agent-core root directory
+ * Works with both npm/tsx and Bun
+ */
+export declare function getAgentCoreDir(): string;
+/**
+ * Get the agent-core prompts directory
+ */
+export declare function getAgentCorePromptsDir(): string;

package/dist/lib/prompts.js

@@ -0,0 +1,62 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import matter from 'gray-matter';
+import { PromptFrontmatterSchema } from '../types/prompt';
+// Get __dirname equivalent for ESM (works with both npm/tsx and Bun)
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+/**
+ * Parse a prompt file and extract frontmatter + content
+ */
+export function parsePromptFile(filePath) {
+    try {
+        const fileContent = fs.readFileSync(filePath, 'utf-8');
+        const { data, content } = matter(fileContent);
+        const parsed = PromptFrontmatterSchema.safeParse(data);
+        if (!parsed.success) {
+            console.error(`Failed to parse frontmatter in ${filePath}:`, parsed.error);
+            return null;
+        }
+        return {
+            frontmatter: parsed.data,
+            content: content.trim(),
+            filePath,
+        };
+    }
+    catch (error) {
+        console.error(`Error reading prompt file ${filePath}:`, error);
+        return null;
+    }
+}
+/**
+ * Load all prompts from a directory
+ */
+export function loadPromptsFromDir(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+        return [];
+    }
+    const files = fs.readdirSync(dirPath).filter(f => f.endsWith('.md'));
+    const prompts = [];
+    for (const file of files) {
+        const prompt = parsePromptFile(path.join(dirPath, file));
+        if (prompt) {
+            prompts.push(prompt);
+        }
+    }
+    return prompts;
+}
+/**
+ * Get the agent-core root directory
+ * Works with both npm/tsx and Bun
+ */
+export function getAgentCoreDir() {
+    // Relative to this file: src/lib/prompts.ts -> ../../agent-core
+    return path.join(__dirname, '..', '..', 'agent-core');
+}
+/**
+ * Get the agent-core prompts directory
+ */
+export function getAgentCorePromptsDir() {
+    return path.join(getAgentCoreDir(), 'prompts');
+}

package/dist/types/prompt.d.ts

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+export declare const PromptArgSchema: z.ZodObject<{
+    name: z.ZodString;
+    default: z.ZodOptional<z.ZodString>;
+    prompt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const AutoIdentitySchema: z.ZodObject<{
+    user: z.ZodString;
+    model: z.ZodString;
+}, z.core.$strip>;
+export declare const PromptFrontmatterSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    'argument-hint': z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    'required-args': z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        default: z.ZodOptional<z.ZodString>;
+        prompt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    'optional-args': z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        default: z.ZodOptional<z.ZodString>;
+        prompt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    'auto-identity': z.ZodOptional<z.ZodObject<{
+        user: z.ZodString;
+        model: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PromptArg = z.infer<typeof PromptArgSchema>;
+export type AutoIdentity = z.infer<typeof AutoIdentitySchema>;
+export type PromptFrontmatter = z.infer<typeof PromptFrontmatterSchema>;
+export interface ParsedPrompt {
+    frontmatter: PromptFrontmatter;
+    content: string;
+    filePath: string;
+}
+export type StorageMode = 'global' | 'workspace' | 'both';
+export interface RRCEConfig {
+    version: number;
+    storage: {
+        mode: StorageMode;
+        globalPath?: string;
+    };
+    project: {
+        name: string;
+    };
+    tools: {
+        copilot: boolean;
+        antigravity: boolean;
+    };
+    linked_projects?: string[];
+}

package/dist/types/prompt.js

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+// Prompt frontmatter schema
+export const PromptArgSchema = z.object({
+    name: z.string(),
+    default: z.string().optional(),
+    prompt: z.string().optional(),
+});
+export const AutoIdentitySchema = z.object({
+    user: z.string(),
+    model: z.string(),
+});
+export const PromptFrontmatterSchema = z.object({
+    name: z.string(),
+    description: z.string(),
+    'argument-hint': z.union([z.string(), z.array(z.string())]).optional(),
+    tools: z.array(z.string()).optional(),
+    'required-args': z.array(PromptArgSchema).optional(),
+    'optional-args': z.array(PromptArgSchema).optional(),
+    'auto-identity': AutoIdentitySchema.optional(),
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rrce-workflow",
-  "version": "0.2.14",
+  "version": "0.2.15",
   "description": "RRCE-Workflow TUI - Agentic code workflow generator for AI-assisted development",
   "author": "RRCE Team",
   "license": "MIT",
@@ -20,16 +20,16 @@
     "tui",
     "cli",
     "code-generation",
-    "agentic",
-    "ink"
+    "agentic"
   ],
   "type": "module",
-  "module": "src/index.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "bin": {
     "rrce-workflow": "bin/rrce-workflow.js"
   },
   "files": [
-    "src",
+    "dist",
     "agent-core",
     "docs",
     "bin"
@@ -38,7 +38,9 @@
     "dev": "npx tsx src/index.ts",
     "wizard": "npx tsx src/index.ts wizard",
     "select": "npx tsx src/index.ts select",
-    "start": "npx tsx src/index.ts"
+    "start": "npx tsx src/index.ts",
+    "build": "esbuild src/index.ts --bundle --platform=node --format=esm --outfile=dist/index.js --packages=external",
+    "prepublishOnly": "npm run build"
   },
   "engines": {
     "node": ">=18"
@@ -48,11 +50,12 @@
     "@clack/prompts": "^0.11.0",
     "gray-matter": "^4.0.3",
     "picocolors": "^1.1.1",
-    "tsx": "^4.21.0",
     "zod": "^4.2.1"
   },
   "devDependencies": {
     "@types/node": "^25.0.3",
+    "esbuild": "^0.27.2",
+    "tsx": "^4.21.0",
     "typescript": "^5.9.3"
   }
 }

package/src/commands/selector.ts

@@ -1,42 +0,0 @@
-import { intro, select, note, cancel, isCancel, outro } from '@clack/prompts';
-import pc from 'picocolors';
-import * as path from 'path';
-import { loadPromptsFromDir, getAgentCorePromptsDir } from '../lib/prompts';
-import type { ParsedPrompt } from '../types/prompt';
-
-export async function runSelector() {
-  const workspaceName = path.basename(process.cwd());
-  
-  intro(pc.cyan(pc.inverse(` RRCE-Workflow | ${workspaceName} `)));
-
-  const prompts = loadPromptsFromDir(getAgentCorePromptsDir());
-
-  if (prompts.length === 0) {
-    cancel('No agents found. Run `rrce-workflow` to set up.');
-    process.exit(0);
-  }
-
-  const selection = await select({
-    message: 'Select an agent:',
-    options: prompts.map(p => ({
-      value: p,
-      label: p.frontmatter.name,
-      hint: p.frontmatter.description
-    })),
-  });
-
-  if (isCancel(selection)) {
-    cancel('Selection cancelled.');
-    process.exit(0);
-  }
-
-  const prompt = selection as ParsedPrompt;
-  
-  note(
-    `Use this agent in your IDE by invoking:
-${pc.bold(pc.cyan(`@${prompt.frontmatter.name}`))}`,
-    'Agent Selected'
-  );
-
-  outro('Done');
-}

package/src/commands/wizard/index.ts

@@ -1,114 +0,0 @@
-import { intro, select, spinner, note, outro, cancel, isCancel } from '@clack/prompts';
-import pc from 'picocolors';
-import * as fs from 'fs';
-import { getGitUser } from '../../lib/git';
-import { 
-  detectWorkspaceRoot, 
-  getWorkspaceName, 
-  listGlobalProjects, 
-  getLocalWorkspacePath,
-  getConfigPath
-} from '../../lib/paths';
-
-// Import flows
-import { runSetupFlow } from './setup-flow';
-import { runLinkProjectsFlow } from './link-flow';
-import { runSyncToGlobalFlow } from './sync-flow';
-import { runUpdateFlow } from './update-flow';
-
-export async function runWizard() {
-  intro(pc.cyan(pc.inverse(' RRCE-Workflow Setup ')));
-
-  const s = spinner();
-  s.start('Detecting environment');
-
-  const workspacePath = detectWorkspaceRoot();
-  const workspaceName = getWorkspaceName(workspacePath);
-  const gitUser = getGitUser();
-
-  await new Promise(r => setTimeout(r, 800)); // Dramatic pause
-  s.stop('Environment detected');
-
-  note(
-    `Git User:  ${pc.bold(gitUser || '(not found)')}
-Workspace: ${pc.bold(workspaceName)}`,
-    'Context'
-  );
-
-  // Check for existing projects in global storage
-  const existingProjects = listGlobalProjects(workspaceName);
-  
-  // Check if already configured (using getConfigPath for new/legacy support)
-  const configFilePath = getConfigPath(workspacePath);
-  const isAlreadyConfigured = fs.existsSync(configFilePath);
-  
-  // Check current storage mode from config
-  let currentStorageMode: string | null = null;
-  if (isAlreadyConfigured) {
-    try {
-      const configContent = fs.readFileSync(configFilePath, 'utf-8');
-      const modeMatch = configContent.match(/mode:\s*(global|workspace|both)/);
-      currentStorageMode = modeMatch?.[1] ?? null;
-    } catch {
-      // Ignore parse errors
-    }
-  }
-
-  // Check if workspace has local data that could be synced
-  const localDataPath = getLocalWorkspacePath(workspacePath);
-  const hasLocalData = fs.existsSync(localDataPath);
-
-  // If already configured, show menu
-  if (isAlreadyConfigured) {
-    const menuOptions: { value: string; label: string; hint?: string }[] = [];
-    
-    // Add link option if other projects exist
-    if (existingProjects.length > 0) {
-      menuOptions.push({ 
-        value: 'link', 
-        label: 'Link other project knowledge', 
-        hint: `${existingProjects.length} projects available` 
-      });
-    }
-    
-    // Add sync to global option if using workspace-only mode
-    if (currentStorageMode === 'workspace' && hasLocalData) {
-      menuOptions.push({ 
-        value: 'sync-global', 
-        label: 'Sync to global storage', 
-        hint: 'Share knowledge with other projects' 
-      });
-    }
-    
-    menuOptions.push({ value: 'update', label: 'Update from package', hint: 'Get latest prompts & templates' });
-    menuOptions.push({ value: 'exit', label: 'Exit' });
-
-    const action = await select({
-      message: 'This workspace is already configured. What would you like to do?',
-      options: menuOptions,
-    });
-
-    if (isCancel(action) || action === 'exit') {
-      outro('Exited.');
-      process.exit(0);
-    }
-
-    if (action === 'link') {
-      await runLinkProjectsFlow(workspacePath, workspaceName, existingProjects);
-      return;
-    }
-
-    if (action === 'sync-global') {
-      await runSyncToGlobalFlow(workspacePath, workspaceName);
-      return;
-    }
-
-    if (action === 'update') {
-      await runUpdateFlow(workspacePath, workspaceName, currentStorageMode);
-      return;
-    }
-  }
-
-  // Run full setup flow for new workspaces
-  await runSetupFlow(workspacePath, workspaceName, existingProjects);
-}