@lucapimenta/copy-chief-black 1.0.0

package/framework/.aios-core/copy-chief/utils/file-discovery.ts

@@ -0,0 +1,241 @@
+/**
+ * file-discovery.ts — Copy Chief OS Layer
+ * copy-chief/utils/file-discovery.ts
+ *
+ * Business logic for "Discovery Before Implementation":
+ * before a new file is created, search for similar existing files nearby
+ * and emit a warning if any are found.
+ *
+ * Used by hook: ~/.claude/hooks/discovery-before-create.ts
+ */
+
+import { existsSync, readdirSync, statSync } from 'fs';
+import { join, dirname, basename, extname } from 'path';
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export interface PreToolUseInput {
+  tool_name: string;
+  tool_input: Record<string, unknown>;
+}
+
+export interface SimilarFile {
+  path: string;
+  modified: string;
+  similarity: string;
+}
+
+export interface DiscoveryResult {
+  shouldWarn: boolean;
+  filePath: string;
+  similar: SimilarFile[];
+}
+
+// ─── Constants ───────────────────────────────────────────────────────────────
+
+export const MAX_EXECUTION_MS = 3000;
+export const MAX_SIMILAR_FILES = 5;
+export const MAX_DEPTH = 2;
+
+/** Directories where new files are expected — suppress warnings. */
+export const EXCLUDED_PATTERNS = [
+  /\/production\//i,
+  /\/research\//i,
+  /\/tmp\//i,
+  /\/temp\//i,
+  /session-state\//i,
+  /node_modules\//i,
+  /\.git\//i,
+  /\/raw\//i,
+  /\/processed\//i,
+];
+
+// ─── Path helpers ─────────────────────────────────────────────────────────────
+
+export function extractFilePath(toolInput: Record<string, unknown>): string | null {
+  for (const field of ['file_path', 'path', 'filePath']) {
+    if (typeof toolInput[field] === 'string') {
+      return toolInput[field] as string;
+    }
+  }
+  return null;
+}
+
+export function isExcludedPath(filePath: string): boolean {
+  return EXCLUDED_PATTERNS.some((pattern) => pattern.test(filePath));
+}
+
+export function getFileModifiedDate(filePath: string): string {
+  try {
+    const stats = statSync(filePath);
+    const d = stats.mtime;
+    return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+  } catch {
+    return 'unknown';
+  }
+}
+
+// ─── Similarity ───────────────────────────────────────────────────────────────
+
+/**
+ * Compute similarity between two filenames using Jaccard on word segments
+ * plus a prefix bonus.
+ *
+ * @returns value in [0, 1]
+ */
+export function filenameSimilarity(name1: string, name2: string): number {
+  const base1 = basename(name1, extname(name1)).toLowerCase();
+  const base2 = basename(name2, extname(name2)).toLowerCase();
+
+  if (base1 === base2) return 1.0;
+
+  const words1 = new Set(base1.split(/[-_.\s]+/).filter((w) => w.length > 1));
+  const words2 = new Set(base2.split(/[-_.\s]+/).filter((w) => w.length > 1));
+
+  if (words1.size === 0 || words2.size === 0) return 0;
+
+  let intersection = 0;
+  for (const w of words1) {
+    if (words2.has(w)) intersection++;
+  }
+  const union = words1.size + words2.size - intersection;
+  if (union === 0) return 0;
+
+  const jaccard = intersection / union;
+
+  const firstWord1 = [...words1][0];
+  const firstWord2 = [...words2][0];
+  const prefixBonus = firstWord1 === firstWord2 ? 0.15 : 0;
+
+  return Math.min(1.0, jaccard + prefixBonus);
+}
+
+// ─── Directory search ─────────────────────────────────────────────────────────
+
+/**
+ * Find files in a single directory that are similar to targetName.
+ * Non-recursive.
+ */
+export function findSimilarInDir(
+  dir: string,
+  targetName: string,
+  targetExt: string,
+): SimilarFile[] {
+  const results: SimilarFile[] = [];
+
+  try {
+    if (!existsSync(dir)) return results;
+
+    const entries = readdirSync(dir);
+
+    for (const entry of entries) {
+      if (entry.startsWith('.')) continue;
+
+      const fullPath = join(dir, entry);
+
+      try {
+        const stats = statSync(fullPath);
+        if (!stats.isFile()) continue;
+      } catch {
+        continue;
+      }
+
+      const entryExt = extname(entry);
+      const similarity = filenameSimilarity(targetName, entry);
+
+      const sameExt = entryExt === targetExt;
+      const threshold = sameExt ? 0.3 : 0.5;
+
+      if (similarity >= threshold) {
+        results.push({
+          path: fullPath,
+          modified: getFileModifiedDate(fullPath),
+          similarity: sameExt
+            ? `nome ${Math.round(similarity * 100)}% similar, mesma extensao`
+            : `nome ${Math.round(similarity * 100)}% similar`,
+        });
+      }
+    }
+  } catch {
+    /* directory read error — skip silently */
+  }
+
+  return results;
+}
+
+// ─── Main discovery ───────────────────────────────────────────────────────────
+
+/**
+ * Run the full discovery check for a Write tool PreToolUse event.
+ * Returns a result indicating whether a warning should be emitted.
+ */
+export function discoverSimilarFiles(input: PreToolUseInput): DiscoveryResult {
+  const noWarn: DiscoveryResult = { shouldWarn: false, filePath: '', similar: [] };
+
+  if (input.tool_name !== 'Write') return noWarn;
+
+  const filePath = extractFilePath(input.tool_input);
+  if (!filePath) return noWarn;
+
+  // If the file already exists, this is an intentional overwrite — allow silently
+  if (existsSync(filePath)) return noWarn;
+
+  if (isExcludedPath(filePath)) return noWarn;
+
+  const targetDir = dirname(filePath);
+  const targetName = basename(filePath);
+  const targetExt = extname(filePath);
+
+  const allSimilar: SimilarFile[] = [];
+
+  allSimilar.push(...findSimilarInDir(targetDir, targetName, targetExt));
+
+  let currentDir = targetDir;
+  for (let i = 0; i < MAX_DEPTH; i++) {
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) break;
+
+    allSimilar.push(...findSimilarInDir(parentDir, targetName, targetExt));
+    currentDir = parentDir;
+  }
+
+  // Deduplicate by path
+  const seen = new Set<string>();
+  const unique = allSimilar.filter((f) => {
+    if (seen.has(f.path)) return false;
+    seen.add(f.path);
+    return true;
+  });
+
+  // Sort by similarity percentage descending
+  unique.sort((a, b) => {
+    const pctA = parseInt(a.similarity.match(/(\d+)%/)?.[1] || '0');
+    const pctB = parseInt(b.similarity.match(/(\d+)%/)?.[1] || '0');
+    return pctB - pctA;
+  });
+
+  const topResults = unique.slice(0, MAX_SIMILAR_FILES);
+
+  return {
+    shouldWarn: topResults.length > 0,
+    filePath,
+    similar: topResults,
+  };
+}
+
+/**
+ * Format the discovery result into a human-readable stderr warning message.
+ */
+export function formatDiscoveryWarning(result: DiscoveryResult): string {
+  const fileList = result.similar
+    .map((f) => `  - ${f.path} (modificado: ${f.modified}) [${f.similarity}]`)
+    .join('\n');
+
+  return (
+    `\n\ud83d\udd0d DISCOVERY CHECK: Criando novo arquivo "${basename(result.filePath)}"\n` +
+    `Arquivos similares encontrados:\n` +
+    `${fileList}\n\n` +
+    `Considere: Estender existente ao inves de criar novo?\n` +
+    `(Este e um aviso — a criacao NAO foi bloqueada)\n\n`
+  );
+}

package/framework/.aios-core/copy-chief/utils/parallel-executor.js

@@ -0,0 +1,125 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var parallel_executor_exports = {};
+__export(parallel_executor_exports, {
+  ParallelExecutor: () => ParallelExecutor
+});
+module.exports = __toCommonJS(parallel_executor_exports);
+class ParallelExecutor {
+  maxConcurrency;
+  runningTasks;
+  constructor(maxConcurrency = 3) {
+    this.maxConcurrency = maxConcurrency;
+    this.runningTasks = /* @__PURE__ */ new Map();
+  }
+  async executeParallel(phases, executePhase, options = {}) {
+    const maxConcurrency = options.maxConcurrency || this.maxConcurrency;
+    const results = [];
+    const errors = [];
+    const promises = phases.map(async (phase) => {
+      const phaseId = phase.phase || phase.step || 0;
+      this.runningTasks.set(phaseId, { status: "running", startTime: Date.now() });
+      try {
+        const result = await executePhase(phase);
+        this.runningTasks.set(phaseId, { status: "completed", startTime: this.runningTasks.get(phaseId).startTime, endTime: Date.now(), result });
+        return { phase: phaseId, status: "fulfilled", result };
+      } catch (error) {
+        this.runningTasks.set(phaseId, { status: "failed", startTime: this.runningTasks.get(phaseId).startTime, endTime: Date.now(), error: error.message });
+        return { phase: phaseId, status: "rejected", error: error.message };
+      }
+    });
+    const settled = await this._executeWithConcurrencyLimit(promises, maxConcurrency);
+    for (const result of settled) {
+      if (result.status === "fulfilled") {
+        results.push(result.value);
+      } else {
+        errors.push(String(result.reason));
+      }
+    }
+    return {
+      results: results.concat(settled.filter((s) => s.status === "rejected").map((s) => ({ phase: 0, status: "rejected", error: String(s.reason) }))),
+      errors,
+      summary: { total: phases.length, success: results.filter((r) => r.status === "fulfilled").length, failed: errors.length }
+    };
+  }
+  async _executeWithConcurrencyLimit(tasks, limit) {
+    const results = [];
+    const executing = /* @__PURE__ */ new Set();
+    for (const task of tasks) {
+      const p = Promise.resolve().then(() => task);
+      results.push(p);
+      if (limit <= tasks.length) {
+        const e = p.then(() => {
+          executing.delete(e);
+        }).catch(() => {
+          executing.delete(e);
+        });
+        executing.add(e);
+        if (executing.size >= limit) await Promise.race(executing);
+      }
+    }
+    return Promise.allSettled(results);
+  }
+  getStatus() {
+    const status = {};
+    for (const [id, taskStatus] of this.runningTasks) {
+      status[id] = { ...taskStatus };
+      if (taskStatus.startTime && taskStatus.endTime) status[id].duration = taskStatus.endTime - taskStatus.startTime;
+    }
+    return status;
+  }
+  hasRunningTasks() {
+    for (const [, status] of this.runningTasks) {
+      if (status.status === "running") return true;
+    }
+    return false;
+  }
+  async waitForCompletion(timeout = 3e5) {
+    const startTime = Date.now();
+    while (this.hasRunningTasks()) {
+      if (Date.now() - startTime > timeout) throw new Error("Timeout waiting for parallel tasks");
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+  }
+  cancelAll() {
+    for (const [id, status] of this.runningTasks) {
+      if (status.status === "running") this.runningTasks.set(id, { ...status, status: "cancelled" });
+    }
+  }
+  clear() {
+    this.runningTasks.clear();
+  }
+  setMaxConcurrency(max) {
+    this.maxConcurrency = Math.max(1, Math.min(10, max));
+  }
+  getSummary() {
+    let completed = 0, failed = 0, running = 0, totalDuration = 0;
+    for (const [, status] of this.runningTasks) {
+      if (status.status === "completed") {
+        completed++;
+        if (status.startTime && status.endTime) totalDuration += status.endTime - status.startTime;
+      } else if (status.status === "failed") failed++;
+      else if (status.status === "running") running++;
+    }
+    return { total: this.runningTasks.size, completed, failed, running, averageDuration: completed > 0 ? Math.round(totalDuration / completed) : 0 };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ParallelExecutor
+});

package/framework/.aios-core/copy-chief/utils/parallel-executor.ts

@@ -0,0 +1,140 @@
+/**
+ * Parallel Executor - Executes multiple phases concurrently
+ * Port of: aios-core/.aios-core/core/orchestration/parallel-executor.js
+ *
+ * @module aios/parallel-executor
+ * @version 1.0.0
+ */
+
+// ============ Types ============
+
+export type PhaseStatus = 'running' | 'completed' | 'failed' | 'cancelled';
+
+export interface PhaseTask {
+  phase?: number;
+  step?: number;
+  [key: string]: any;
+}
+
+export interface PhaseResult {
+  phase: number;
+  status: 'fulfilled' | 'rejected';
+  result?: any;
+  error?: string;
+}
+
+export interface ParallelResult {
+  results: PhaseResult[];
+  errors: string[];
+  summary: { total: number; success: number; failed: number };
+}
+
+// ============ Class ============
+
+export class ParallelExecutor {
+  maxConcurrency: number;
+  runningTasks: Map<number, { status: PhaseStatus; startTime: number; endTime?: number; result?: any; error?: string }>;
+
+  constructor(maxConcurrency = 3) {
+    this.maxConcurrency = maxConcurrency;
+    this.runningTasks = new Map();
+  }
+
+  async executeParallel(phases: PhaseTask[], executePhase: (phase: PhaseTask) => Promise<any>, options: { maxConcurrency?: number } = {}): Promise<ParallelResult> {
+    const maxConcurrency = options.maxConcurrency || this.maxConcurrency;
+    const results: PhaseResult[] = [];
+    const errors: string[] = [];
+
+    const promises = phases.map(async (phase): Promise<PhaseResult> => {
+      const phaseId = phase.phase || phase.step || 0;
+      this.runningTasks.set(phaseId, { status: 'running', startTime: Date.now() });
+
+      try {
+        const result = await executePhase(phase);
+        this.runningTasks.set(phaseId, { status: 'completed', startTime: this.runningTasks.get(phaseId)!.startTime, endTime: Date.now(), result });
+        return { phase: phaseId, status: 'fulfilled', result };
+      } catch (error: any) {
+        this.runningTasks.set(phaseId, { status: 'failed', startTime: this.runningTasks.get(phaseId)!.startTime, endTime: Date.now(), error: error.message });
+        return { phase: phaseId, status: 'rejected', error: error.message };
+      }
+    });
+
+    const settled = await this._executeWithConcurrencyLimit(promises, maxConcurrency);
+
+    for (const result of settled) {
+      if (result.status === 'fulfilled') {
+        results.push(result.value);
+      } else {
+        errors.push(String(result.reason));
+      }
+    }
+
+    return {
+      results: results.concat(settled.filter(s => s.status === 'rejected').map(s => ({ phase: 0, status: 'rejected' as const, error: String(s.reason) }))),
+      errors,
+      summary: { total: phases.length, success: results.filter(r => r.status === 'fulfilled').length, failed: errors.length },
+    };
+  }
+
+  private async _executeWithConcurrencyLimit<T>(tasks: Promise<T>[], limit: number): Promise<PromiseSettledResult<T>[]> {
+    const results: Promise<T>[] = [];
+    const executing = new Set<Promise<void>>();
+
+    for (const task of tasks) {
+      const p = Promise.resolve().then(() => task);
+      results.push(p);
+
+      if (limit <= tasks.length) {
+        const e = p.then(() => { executing.delete(e); }).catch(() => { executing.delete(e); }) as Promise<void>;
+        executing.add(e);
+        if (executing.size >= limit) await Promise.race(executing);
+      }
+    }
+
+    return Promise.allSettled(results);
+  }
+
+  getStatus(): Record<number, { status: PhaseStatus; startTime: number; endTime?: number; duration?: number }> {
+    const status: Record<number, any> = {};
+    for (const [id, taskStatus] of this.runningTasks) {
+      status[id] = { ...taskStatus };
+      if (taskStatus.startTime && taskStatus.endTime) status[id].duration = taskStatus.endTime - taskStatus.startTime;
+    }
+    return status;
+  }
+
+  hasRunningTasks(): boolean {
+    for (const [, status] of this.runningTasks) {
+      if (status.status === 'running') return true;
+    }
+    return false;
+  }
+
+  async waitForCompletion(timeout = 300000): Promise<void> {
+    const startTime = Date.now();
+    while (this.hasRunningTasks()) {
+      if (Date.now() - startTime > timeout) throw new Error('Timeout waiting for parallel tasks');
+      await new Promise(resolve => setTimeout(resolve, 100));
+    }
+  }
+
+  cancelAll(): void {
+    for (const [id, status] of this.runningTasks) {
+      if (status.status === 'running') this.runningTasks.set(id, { ...status, status: 'cancelled' });
+    }
+  }
+
+  clear(): void { this.runningTasks.clear(); }
+
+  setMaxConcurrency(max: number): void { this.maxConcurrency = Math.max(1, Math.min(10, max)); }
+
+  getSummary(): { total: number; completed: number; failed: number; running: number; averageDuration: number } {
+    let completed = 0, failed = 0, running = 0, totalDuration = 0;
+    for (const [, status] of this.runningTasks) {
+      if (status.status === 'completed') { completed++; if (status.startTime && status.endTime) totalDuration += status.endTime - status.startTime; }
+      else if (status.status === 'failed') failed++;
+      else if (status.status === 'running') running++;
+    }
+    return { total: this.runningTasks.size, completed, failed, running, averageDuration: completed > 0 ? Math.round(totalDuration / completed) : 0 };
+  }
+}