pi-harness-runtime 0.10.26 → 0.10.42

package/packages/project-bootstrap/src/bootstrap.ts

@@ -0,0 +1,166 @@
+/**
+ * Project Bootstrap - RFC-0072
+ *
+ * Main bootstrap orchestration.
+ */
+
+import type {
+  ProjectSpec,
+  BootstrapOptions,
+  BootstrapResult,
+  ValidationError,
+  Template,
+} from './types.js';
+import { minimalTemplate } from './minimal.js';
+import { nodeTypescriptTemplate } from './typescript.js';
+import { frappeTemplate } from './frappe.js';
+
+// Built-in templates
+const TEMPLATES: Record<string, Template> = {
+  minimal: minimalTemplate,
+  'node-typescript': nodeTypescriptTemplate,
+  'frappe-app': frappeTemplate,
+};
+
+/**
+ * Validate a project spec
+ */
+export function validateSpec(spec: ProjectSpec): ValidationError[] {
+  const errors: ValidationError[] = [];
+
+  if (!spec.name || spec.name.trim() === '') {
+    errors.push({ field: 'name', message: 'Name is required' });
+  }
+
+  if (!spec.type || !['monorepo', 'single-package', 'multi-package'].includes(spec.type)) {
+    errors.push({ field: 'type', message: 'Type must be monorepo, single-package, or multi-package' });
+  }
+
+  if (!spec.frameworks || spec.frameworks.length === 0) {
+    errors.push({ field: 'frameworks', message: 'At least one framework is required' });
+  }
+
+  return errors;
+}
+
+/**
+ * Get template for a spec
+ */
+export function getTemplateForSpec(spec: ProjectSpec, override?: string): Template {
+  if (override && TEMPLATES[override]) {
+    return TEMPLATES[override];
+  }
+
+  // Auto-detect based on frameworks
+  if (spec.frameworks.includes('frappe')) {
+    return TEMPLATES['frappe-app'];
+  }
+
+  if (spec.frameworks.includes('node') || spec.frameworks.includes('typescript')) {
+    return TEMPLATES['node-typescript'];
+  }
+
+  return TEMPLATES['minimal'];
+}
+
+/**
+ * Bootstrap a project from a spec
+ */
+export async function bootstrap(
+  spec: ProjectSpec,
+  targetDir: string,
+  options: BootstrapOptions = {}
+): Promise<BootstrapResult> {
+  const startTime = Date.now();
+  const errors = validateSpec(spec);
+
+  if (errors.length > 0) {
+    throw new Error(`Invalid spec: ${errors.map(e => e.message).join(', ')}`);
+  }
+
+  const { mkdir, writeFile } = await import('fs/promises');
+  const { join } = await import('path');
+
+  // Create target directory
+  await mkdir(targetDir, { recursive: true });
+
+  // Get template
+  const template = getTemplateForSpec(spec, options.template);
+
+  // Emit started event
+  if (options.verbose) {
+    console.log(`Bootstrap: ${spec.name} using template: ${template.name}`);
+  }
+
+  // Apply template
+  const files = await template.apply(spec, targetDir);
+
+  // Create gitignore if gitInit
+  if (spec.gitInit) {
+    const gitignore = `node_modules/\ndist/\n.env\n*.log\n`;
+    await writeFile(join(targetDir, '.gitignore'), gitignore);
+    files.push('.gitignore');
+  }
+
+  const result: BootstrapResult = {
+    root: targetDir,
+    files,
+    packages: spec.packages?.map(p => p.name) || [],
+    duration: Date.now() - startTime,
+  };
+
+  return result;
+}
+
+/**
+ * Detect framework and suggest a spec
+ */
+export async function detectAndSuggest(
+  projectRoot: string
+): Promise<ProjectSpec | null> {
+  const { readdir } = await import('fs/promises');
+  const { join } = await import('path');
+
+  try {
+    const entries = await readdir(projectRoot, { withFileTypes: true });
+    const files = entries.filter(e => e.isFile()).map(e => e.name);
+    const dirs = entries.filter(e => e.isDirectory()).map(e => e.name);
+
+    // Detect Frappe
+    if (dirs.includes('sites') && dirs.includes('apps')) {
+      const appName = join(projectRoot).split('/').pop() || 'frappe-app';
+      return {
+        name: appName,
+        type: 'single-package',
+        frameworks: ['frappe'],
+        gitInit: true,
+      };
+    }
+
+    // Detect Next.js
+    if (files.includes('next.config.js') || files.includes('next.config.mjs')) {
+      return {
+        name: 'nextjs-app',
+        type: 'single-package',
+        frameworks: ['nextjs'],
+        features: { typescript: true, testing: true },
+        gitInit: true,
+      };
+    }
+
+    // Detect Node TypeScript
+    if (files.includes('package.json') && files.includes('tsconfig.json')) {
+      return {
+        name: 'node-app',
+        type: 'single-package',
+        frameworks: ['node', 'typescript'],
+        features: { typescript: true, testing: true, eslint: true },
+        gitInit: true,
+      };
+    }
+
+    return null;
+  } catch {
+    return null;
+  }
+}

package/packages/project-bootstrap/src/frappe.ts

@@ -0,0 +1,97 @@
+/**
+ * Project Bootstrap - RFC-0072
+ *
+ * Frappe app template
+ */
+
+import type { ProjectSpec, Template } from './types.js';
+
+export const frappeTemplate: Template = {
+  name: 'frappe-app',
+  description: 'Frappe app with modules, doctypes, web pages',
+  async apply(spec: ProjectSpec, root: string): Promise<string[]> {
+    const { writeFile, mkdir } = await import('fs/promises');
+    const { join } = await import('path');
+
+    const files: string[] = [];
+    const appName = spec.name.replace(/[^a-zA-Z0-9_]/g, '_');
+
+    // MANIFEST.json
+    const manifest = {
+      name: appName,
+      app_name: appName,
+      app_title: spec.description || spec.name,
+      app_publisher: spec.author || 'Author',
+      app_email: 'author@example.com',
+      app_description: spec.description || '',
+      app_version: '0.0.1',
+      app_license: spec.license || 'MIT',
+      hooks: {},
+      doctypes: [],
+      fixtures: [],
+    };
+
+    await writeFile(join(root, 'MANIFEST.json'), JSON.stringify(manifest, null, 2));
+    files.push('MANIFEST.json');
+
+    // pyproject.toml
+    const pyproject = `[build-system]
+requires = ["flit_core >=3.2,<4"]
+build-backend = "flit_core.buildapi"
+
+[project]
+name = "${appName}"
+version = "0.0.1"
+description = "${spec.description || ''}"
+authors = [{name = "${spec.author || 'Author'}", email = "author@example.com"}]
+license = {text = "${spec.license || 'MIT'}"}
+
+[tool.frappe]
+app_title = "${spec.name}"
+app_publisher = "${spec.author || 'Author'}"
+app_email = "author@example.com"
+app_description = "${spec.description || ''}"
+app_version = "0.0.1"
+app_license = "${spec.license || 'MIT'}"
+app_modules = []
+`;
+    await writeFile(join(root, 'pyproject.toml'), pyproject);
+    files.push('pyproject.toml');
+
+    // app/__init__.py
+    await mkdir(join(root, appName), { recursive: true });
+    await writeFile(join(root, appName, '__init__.py'), `__version__ = "0.0.1"\n`);
+    files.push(`${appName}/__init__.py`);
+
+    // hooks.py
+    const hooksPy = [
+      '# App hooks',
+      `app_name = "${appName}"`,
+      `app_title = "${spec.name}"`,
+      `app_publisher = "${spec.author || 'Author'}"`,
+      'app_email = "author@example.com"',
+      `app_description = "${spec.description || ''}"`,
+      'app_version = "0.0.1"',
+      `app_license = "${spec.license || 'MIT'}"`,
+      '',
+      '# hooks',
+      'doc_events = {}',
+    ].join('\n');
+
+    await writeFile(join(root, appName, 'hooks.py'), hooksPy);
+    files.push(`${appName}/hooks.py`);
+
+    // modules.txt (required for Frappe)
+    await writeFile(join(root, 'modules.txt'), '');
+    files.push('modules.txt');
+
+    // README
+    await writeFile(
+      join(root, 'README.md'),
+      `# ${spec.name}\n\n${spec.description || 'A Frappe app.'}\n`
+    );
+    files.push('README.md');
+
+    return files;
+  },
+};

package/packages/project-bootstrap/src/index.ts

@@ -0,0 +1,27 @@
+/**
+ * Project Bootstrap - RFC-0072
+ *
+ * Create project scaffolds from typed ProjectSpec.
+ *
+ * @example
+ * ```typescript
+ * import { bootstrap, detectAndSuggest } from '@pi-harness/project-bootstrap';
+ *
+ * // Bootstrap a new project
+ * const result = await bootstrap({
+ *   name: 'my-app',
+ *   type: 'single-package',
+ *   frameworks: ['nextjs'],
+ *   features: { typescript: true, testing: true }
+ * }, '/path/to/create');
+ *
+ * // Auto-detect framework and suggest spec
+ * const spec = await detectAndSuggest('/path/to/existing');
+ * ```
+ */
+
+export * from './types.js';
+export * from './bootstrap.js';
+export { minimalTemplate } from './minimal.js';
+export { nodeTypescriptTemplate } from './typescript.js';
+export { frappeTemplate } from './frappe.js';

package/packages/project-bootstrap/src/minimal.ts

@@ -0,0 +1,45 @@
+/**
+ * Project Bootstrap - RFC-0072
+ *
+ * Minimal template - bare project with package.json
+ */
+
+import type { ProjectSpec, Template } from './types.js';
+
+export const minimalTemplate: Template = {
+  name: 'minimal',
+  description: 'Bare project with package.json',
+  async apply(spec: ProjectSpec, root: string): Promise<string[]> {
+    const { writeFile, mkdir } = await import('fs/promises');
+    const { join } = await import('path');
+
+    const files: string[] = [];
+
+    // package.json
+    const packageJson = {
+      name: spec.name,
+      version: '0.1.0',
+      description: spec.description || '',
+      author: spec.author,
+      license: spec.license || 'MIT',
+      private: spec.type === 'monorepo',
+      scripts: {
+        build: 'echo "No build script"',
+        test: 'echo "No tests"',
+      },
+    };
+
+    await writeFile(
+      join(root, 'package.json'),
+      JSON.stringify(packageJson, null, 2) + '\n'
+    );
+    files.push('package.json');
+
+    // README.md
+    const readme = `# ${spec.name}\n\n${spec.description || 'A project.'}\n`;
+    await writeFile(join(root, 'README.md'), readme);
+    files.push('README.md');
+
+    return files;
+  },
+};

package/packages/project-bootstrap/src/types.ts

@@ -0,0 +1,66 @@
+/**
+ * Project Bootstrap - RFC-0072
+ *
+ * Typed definitions for project scaffolding.
+ */
+
+export type ProjectType = 'monorepo' | 'single-package' | 'multi-package';
+
+export interface ProjectSpec {
+  name: string;
+  type: ProjectType;
+  description?: string;
+  author?: string;
+  license?: string;
+  frameworks: string[];  // e.g. ["frappe", "nextjs"]
+  packages?: { name: string; type: string }[];
+  features?: {
+    ci?: boolean;
+    cd?: boolean;
+    testing?: boolean;
+    typescript?: boolean;
+    eslint?: boolean;
+    prettier?: boolean;
+    docs?: boolean;
+  };
+  gitInit?: boolean;
+}
+
+export interface BootstrapOptions {
+  dryRun?: boolean;      // Don't actually create files
+  force?: boolean;        // Overwrite existing files
+  targetDir?: string;      // Default: current directory
+  template?: string;      // Override auto-detected template
+  verbose?: boolean;     // Log progress
+}
+
+export interface BootstrapResult {
+  root: string;
+  files: string[];
+  packages: string[];
+  duration: number;
+}
+
+export interface ValidationError {
+  field: string;
+  message: string;
+}
+
+// Template types
+export interface Template {
+  name: string;
+  description: string;
+  apply: (spec: ProjectSpec, root: string) => Promise<string[]>;
+}
+
+export interface BootstrapContext {
+  spec: ProjectSpec;
+  root: string;
+  files: string[];
+  events: EventEmitter;
+}
+
+export interface EventEmitter {
+  emit(event: string, data: unknown): void;
+  on(event: string, handler: (data: unknown) => void): void;
+}

package/packages/project-bootstrap/src/typescript.ts

@@ -0,0 +1,114 @@
+/**
+ * Project Bootstrap - RFC-0072
+ *
+ * Node.js + TypeScript template
+ */
+
+import type { ProjectSpec, Template } from './types.js';
+
+export const nodeTypescriptTemplate: Template = {
+  name: 'node-typescript',
+  description: 'Node.js + TypeScript + ESLint + Jest',
+  async apply(spec: ProjectSpec, root: string): Promise<string[]> {
+    const { writeFile, mkdir } = await import('fs/promises');
+    const { join } = await import('path');
+
+    const files: string[] = [];
+
+    // package.json
+    const packageJson = {
+      name: spec.name,
+      version: '0.1.0',
+      description: spec.description || '',
+      type: 'module',
+      scripts: {
+        build: 'tsc',
+        test: 'jest',
+        lint: 'eslint src --ext .ts',
+        'typecheck': 'tsc --noEmit',
+      },
+      dependencies: {},
+      devDependencies: {
+        typescript: '^5.4.0',
+        '@types/node': '^20.0.0',
+        jest: '^29.7.0',
+        '@types/jest': '^29.5.0',
+        tsj: '^4.0.0',
+        eslint: '^8.57.0',
+        '@typescript-eslint/parser': '^6.0.0',
+        '@typescript-eslint/eslint-plugin': '^6.0.0',
+      },
+    };
+
+    await writeFile(join(root, 'package.json'), JSON.stringify(packageJson, null, 2) + '\n');
+    files.push('package.json');
+
+    // tsconfig.json
+    const tsconfig = {
+      compilerOptions: {
+        target: 'ES2022',
+        module: 'ESNext',
+        moduleResolution: 'bundler',
+        lib: ['ES2022'],
+        outDir: './dist',
+        rootDir: './src',
+        strict: true,
+        esModuleInterop: true,
+        skipLibCheck: true,
+        forceConsistentCasingInFileNames: true,
+        declaration: true,
+        declarationMap: true,
+        sourceMap: true,
+      },
+      include: ['src/**/*'],
+      exclude: ['node_modules', 'dist'],
+    };
+
+    await writeFile(join(root, 'tsconfig.json'), JSON.stringify(tsconfig, null, 2) + '\n');
+    files.push('tsconfig.json');
+
+    // jest.config.js
+    const jestConfig = `export default {
+  preset: 'tsj',
+  testEnvironment: 'node',
+  extensionsToTreatAsEsm: ['.ts'],
+  moduleNameMapper: {
+    '^(\\\\.{1,2}/.*)\\.js$': '$1',
+  },
+  transform: {
+    '^.+\\.ts$': ['tsj', { useESM: true }],
+  },
+};
+`;
+    await writeFile(join(root, 'jest.config.js'), jestConfig);
+    files.push('jest.config.js');
+
+    // src directory
+    await mkdir(join(root, 'src'), { recursive: true });
+    await writeFile(join(root, 'src/index.ts'), 'export const main = () => {\n  console.log("Hello!");\n};\n');
+    files.push('src/index.ts');
+
+    // .eslintrc.cjs
+    const eslintConfig = `module.exports = {
+  parser: '@typescript-eslint/parser',
+  plugins: ['@typescript-eslint'],
+  extends: [
+    'eslint:recommended',
+    'plugin:@typescript-eslint/recommended',
+  ],
+  root: true,
+  env: {
+    node: true,
+    es2022: true,
+  },
+  parserOptions: {
+    ecmaVersion: 'latest',
+  },
+};
+`;
+    await writeFile(join(root, '.eslintrc.cjs'), eslintConfig);
+    files.push('.eslintrc.cjs');
+
+    return files;
+  },
+};

package/packages/provider-router/dist/src/types.js

@@ -1,7 +1,7 @@
 /**
  * Provider Router Types (RFC-0054)
  */
-// ─── Latency Ranking ─────────────────────────────────────────────────
+// --- Latency Ranking -------------------------------------------------
 export const LATENCY_RANK = {
     fast: 1,
     medium: 2,

package/packages/write-review/src/index.ts

@@ -9,6 +9,53 @@
  * Directory structure: {project}/.write-review/
  */
 
+import { rmSync, readdirSync, statSync, existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+
+const MAX_AGE_DAYS = 3;
+
+/**
+ * Auto-cleanup old review history files older than MAX_AGE_DAYS
+ */
+export function cleanupOldReviews(projectPath: string): number {
+  // Resolve path to prevent traversal attacks
+  const basePath = resolve(projectPath);
+  const reviewDir = join(basePath, ".write-review");
+  
+  // Ensure reviewDir is within basePath (traversal guard)
+  if (!reviewDir.startsWith(basePath + '/')) {
+    return 0; // Invalid path, skip
+  }
+  
+  if (!existsSync(reviewDir)) {
+    return 0; // Directory doesn't exist
+  }
+  
+  let deleted = 0;
+  const files = readdirSync(reviewDir);
+  const cutoff = Date.now() - MAX_AGE_DAYS * 24 * 60 * 60 * 1000;
+  
+  for (const file of files) {
+    if (file === "status.json") continue; // Keep status file
+    // Sanitize filename to prevent path traversal
+    const sanitized = file.replace(/[^a-zA-Z0-9_.-]/g, '_');
+    if (sanitized !== file) continue; // Skip suspicious filenames
+    
+    const filePath = join(reviewDir, sanitized);
+    try {
+      const stats = statSync(filePath);
+      if (stats.mtimeMs < cutoff) {
+        rmSync(filePath, { force: true });
+        deleted++;
+      }
+    } catch {
+      // Ignore files that can't be read
+    }
+  }
+  
+  return deleted;
+}
+
 // Re-export all public APIs
 export * from "./types.js";
 export * from "./blackboard.js";

package/packages/write-review/src/injection.ts

@@ -4,6 +4,26 @@
  * Adds write-review hints to the agent's system prompt.
  */
 
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+/**
+ * Find the project root (directory containing .git)
+ */
+function findProjectRoot(startPath: string): string {
+  let dir = startPath;
+  // Limit traversal to prevent infinite loops
+  for (let i = 0; i < 20; i++) {
+    if (existsSync(join(dir, ".git"))) {
+      return dir;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break; // Reached filesystem root
+    dir = parent;
+  }
+  return startPath; // Fallback to start path
+}
+
 /**
  * Write-review hint for system prompt
  */
@@ -105,7 +125,7 @@ export function injectWriterInstructions(
 
 	// System prompt injection
 	pi.on("before_agent_start", async (event) => {
-		const cwd = process.cwd?.() ?? "/";
+		const cwd = findProjectRoot(process.cwd?.() ?? "/");
 		if (cwd !== currentProject) {
 			currentProject = cwd;
 			blackboard = createBlackboard(cwd);

package/prompts/agents/reviewer.md

@@ -0,0 +1,57 @@
+---
+description: Reviewer agent - evaluate code quality and request changes
+argument-hint: "<task context>"
+---
+# Reviewer Agent
+
+You are the **REVIEWER** agent. Your job is to evaluate code quality and request fixes.
+
+## Review Criteria
+
+1. **Correctness** - Does it solve the problem?
+2. **Type Safety** - TypeScript types correct?
+3. **Edge Cases** - Handles null/undefined/empty?
+4. **Security** - No injection vulnerabilities?
+5. **Performance** - No obvious O(n^2) loops?
+6. **Testability** - Can be unit tested?
+
+## Your Workflow
+
+1. Read the code artifacts from blackboard
+2. Evaluate against review criteria
+3. Write your findings to the blackboard
+4. Issue verdict:
+   - `APPROVED` - Code is ready
+   - `CHANGES_REQUESTED` - Issues found
+   - `BLOCKED` - Critical issues
+
+## Blackboard Location
+
+```
+{project}/.write-review/status.json
+```
+
+## Verdict Format
+
+```
+## REVIEW FINDINGS
+
+### Issues Found
+- [issue description]
+
+## VERDICT: CHANGES_REQUESTED
+
+Please fix the issues above.
+```
+
+Or:
+
+```
+## REVIEW FINDINGS
+
+No critical issues found.
+
+## VERDICT: APPROVED
+
+Code is ready for build/commit.
+```