rrce-workflow 0.1.0

package/src/index.tsx

@@ -0,0 +1,9 @@
+#!/usr/bin/env bun
+import * as React from 'react';
+import { render } from 'ink';
+import { App } from './App';
+
+// Get command from args
+const command = process.argv[2];
+
+render(<App command={command} />);

package/src/lib/git.ts

@@ -0,0 +1,37 @@
+import { execSync } from 'child_process';
+
+/**
+ * Get git user name from config
+ */
+export function getGitUser(): string | null {
+  try {
+    const result = execSync('git config user.name', { encoding: 'utf-8' });
+    return result.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get git user email from config
+ */
+export function getGitEmail(): string | null {
+  try {
+    const result = execSync('git config user.email', { encoding: 'utf-8' });
+    return result.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if current directory is a git repository
+ */
+export function isGitRepo(): boolean {
+  try {
+    execSync('git rev-parse --git-dir', { encoding: 'utf-8', stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/lib/paths.ts

@@ -0,0 +1,82 @@
+import { execSync } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import type { StorageMode } from '../types/prompt';
+
+// 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(): string {
+  if (RRCE_WORKSPACE) {
+    return RRCE_WORKSPACE;
+  }
+
+  let current = process.cwd();
+  
+  while (current !== '/') {
+    // Check for .git or .rrce-workflow.yaml
+    if (fs.existsSync(path.join(current, '.git')) || 
+        fs.existsSync(path.join(current, '.rrce-workflow.yaml'))) {
+      return current;
+    }
+    current = path.dirname(current);
+  }
+  
+  return process.cwd();
+}
+
+/**
+ * Get workspace name from directory or config
+ */
+export function getWorkspaceName(workspaceRoot: string): string {
+  // TODO: Check .rrce-workflow.yaml for project.name
+  return path.basename(workspaceRoot);
+}
+
+/**
+ * Resolve data path based on storage mode
+ */
+export function resolveDataPath(mode: StorageMode, workspaceName: string, workspaceRoot: string): string {
+  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);
+  }
+}
+
+/**
+ * Get RRCE home directory
+ */
+export function getRRCEHome(): string {
+  return RRCE_HOME;
+}
+
+/**
+ * Ensure directory exists
+ */
+export function ensureDir(dirPath: string): void {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+
+/**
+ * Get path for agent prompts based on tool
+ */
+export function getAgentPromptPath(workspaceRoot: string, tool: 'copilot' | 'antigravity'): string {
+  if (tool === 'copilot') {
+    return path.join(workspaceRoot, '.github', 'agents');
+  } else {
+    return path.join(workspaceRoot, '.agent', 'workflows');
+  }
+}

package/src/lib/prompts.ts

@@ -0,0 +1,59 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import matter from 'gray-matter';
+import { PromptFrontmatterSchema, type ParsedPrompt } from '../types/prompt';
+
+/**
+ * Parse a prompt file and extract frontmatter + content
+ */
+export function parsePromptFile(filePath: string): ParsedPrompt | null {
+  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: string): ParsedPrompt[] {
+  if (!fs.existsSync(dirPath)) {
+    return [];
+  }
+  
+  const files = fs.readdirSync(dirPath).filter(f => f.endsWith('.md'));
+  const prompts: ParsedPrompt[] = [];
+  
+  for (const file of files) {
+    const prompt = parsePromptFile(path.join(dirPath, file));
+    if (prompt) {
+      prompts.push(prompt);
+    }
+  }
+  
+  return prompts;
+}
+
+/**
+ * Get the agent-core prompts directory
+ */
+export function getAgentCorePromptsDir(): string {
+  // Relative to the package root
+  return path.join(import.meta.dir, '..', '..', 'agent-core', 'prompts');
+}

package/src/types/prompt.ts

@@ -0,0 +1,53 @@
+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(),
+});
+
+export type PromptArg = z.infer<typeof PromptArgSchema>;
+export type AutoIdentity = z.infer<typeof AutoIdentitySchema>;
+export type PromptFrontmatter = z.infer<typeof PromptFrontmatterSchema>;
+
+// Parsed prompt with content
+export interface ParsedPrompt {
+  frontmatter: PromptFrontmatter;
+  content: string;
+  filePath: string;
+}
+
+// Storage mode options
+export type StorageMode = 'global' | 'workspace' | 'both';
+
+// Config schema
+export interface RRCEConfig {
+  version: number;
+  storage: {
+    mode: StorageMode;
+  };
+  workspace: {
+    name: string;
+    path: string;
+  };
+  tools: {
+    copilot: boolean;
+    antigravity: boolean;
+  };
+}