@lucapimenta/copy-chief-black 1.0.0

package/framework/.aios-core/copy-chief/context/context-tiering.ts

@@ -0,0 +1,268 @@
+// ~/.claude/hooks/lib/context-tiering.ts
+// Context Tiering — Bracket-aware memory bridge for context management
+// Estimates context usage and adjusts injection strategy accordingly
+// Part of P4: Context Tiering (AIOS Gap Closure)
+// Created: 2026-02-24
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const HOME = homedir();
+const STATE_DIR = join(HOME, '.claude', 'session-state');
+const COUNTER_FILE = join(STATE_DIR, 'context-counter.json');
+
+// ==========================================
+// Types
+// ==========================================
+
+export type ContextBracket = 'FRESH' | 'MODERATE' | 'DEPLETED' | 'CRITICAL';
+
+export interface ContextState {
+  tool_calls: number;
+  estimated_tokens: number;
+  estimated_pct: number;
+  bracket: ContextBracket;
+  session_start: string;
+  last_updated: string;
+  warnings_emitted: number;
+  last_compact_at?: string;
+}
+
+export interface InjectionStrategy {
+  bracket: ContextBracket;
+  load_hot: boolean;
+  load_warm: boolean;
+  load_cold: boolean;
+  max_injection_tokens: number;
+  should_compact: boolean;
+  force_compact: boolean;
+  warning?: string;
+}
+
+// ==========================================
+// Constants
+// ==========================================
+
+const MAX_CONTEXT_TOKENS = 200_000;
+const AVG_TOKENS_PER_TOOL_CALL = 800; // Conservative average including input + output
+
+const BRACKETS: Record<ContextBracket, { min_pct: number; max_pct: number }> = {
+  FRESH:    { min_pct: 0,  max_pct: 30 },
+  MODERATE: { min_pct: 30, max_pct: 50 },
+  DEPLETED: { min_pct: 50, max_pct: 70 },
+  CRITICAL: { min_pct: 70, max_pct: 100 },
+};
+
+// ==========================================
+// State I/O
+// ==========================================
+
+function ensureDir(): void {
+  if (!existsSync(STATE_DIR)) {
+    mkdirSync(STATE_DIR, { recursive: true });
+  }
+}
+
+export function loadState(): ContextState {
+  ensureDir();
+
+  if (existsSync(COUNTER_FILE)) {
+    try {
+      const raw = readFileSync(COUNTER_FILE, 'utf-8');
+      return JSON.parse(raw) as ContextState;
+    } catch {
+      // Corrupted, start fresh
+    }
+  }
+
+  const now = new Date().toISOString();
+  return {
+    tool_calls: 0,
+    estimated_tokens: 0,
+    estimated_pct: 0,
+    bracket: 'FRESH',
+    session_start: now,
+    last_updated: now,
+    warnings_emitted: 0,
+  };
+}
+
+function saveState(state: ContextState): void {
+  ensureDir();
+  state.last_updated = new Date().toISOString();
+  writeFileSync(COUNTER_FILE, JSON.stringify(state, null, 2));
+}
+
+// ==========================================
+// Bracket Detection
+// ==========================================
+
+function detectBracket(pct: number): ContextBracket {
+  if (pct < BRACKETS.FRESH.max_pct) return 'FRESH';
+  if (pct < BRACKETS.MODERATE.max_pct) return 'MODERATE';
+  if (pct < BRACKETS.DEPLETED.max_pct) return 'DEPLETED';
+  return 'CRITICAL';
+}
+
+// ==========================================
+// Core API
+// ==========================================
+
+/**
+ * Increment tool call counter and recalculate bracket.
+ * Called from PostToolUse hook.
+ * @param additionalTokens - Optional override for specific tool token count
+ */
+export function recordToolCall(additionalTokens?: number): ContextState {
+  const state = loadState();
+
+  state.tool_calls++;
+  state.estimated_tokens += additionalTokens || AVG_TOKENS_PER_TOOL_CALL;
+  state.estimated_pct = Math.min(100, Math.round((state.estimated_tokens / MAX_CONTEXT_TOKENS) * 100));
+  state.bracket = detectBracket(state.estimated_pct);
+
+  saveState(state);
+  return state;
+}
+
+/**
+ * Get the current injection strategy based on bracket.
+ * Used by synapse-inject.ts to decide what to load.
+ */
+export function getInjectionStrategy(): InjectionStrategy {
+  const state = loadState();
+
+  switch (state.bracket) {
+    case 'FRESH':
+      return {
+        bracket: 'FRESH',
+        load_hot: true,
+        load_warm: true,
+        load_cold: false,
+        max_injection_tokens: 30_000,
+        should_compact: false,
+        force_compact: false,
+      };
+
+    case 'MODERATE':
+      return {
+        bracket: 'MODERATE',
+        load_hot: true,
+        load_warm: true,
+        load_cold: false,
+        max_injection_tokens: 20_000,
+        should_compact: false,
+        force_compact: false,
+      };
+
+    case 'DEPLETED':
+      return {
+        bracket: 'DEPLETED',
+        load_hot: true,
+        load_warm: false,
+        load_cold: false,
+        max_injection_tokens: 10_000,
+        should_compact: true,
+        force_compact: false,
+        warning: `Context ${state.estimated_pct}% — DEPLETED. /compact recomendado. Warm files nao serao injetados.`,
+      };
+
+    case 'CRITICAL':
+      return {
+        bracket: 'CRITICAL',
+        load_hot: true,
+        load_warm: false,
+        load_cold: false,
+        max_injection_tokens: 5_000,
+        should_compact: true,
+        force_compact: true,
+        warning: `Context ${state.estimated_pct}% — CRITICAL! /compact URGENTE. Qualidade degradando significativamente.`,
+      };
+  }
+}
+
+/**
+ * Reset counter (called after /compact or session start).
+ */
+export function resetCounter(reason: 'compact' | 'session_start'): ContextState {
+  const state = loadState();
+
+  if (reason === 'compact') {
+    // After compact, estimate context reduced by ~60%
+    state.estimated_tokens = Math.round(state.estimated_tokens * 0.4);
+    state.last_compact_at = new Date().toISOString();
+  } else {
+    // Fresh session
+    state.tool_calls = 0;
+    state.estimated_tokens = 0;
+    state.warnings_emitted = 0;
+    state.session_start = new Date().toISOString();
+  }
+
+  state.estimated_pct = Math.min(100, Math.round((state.estimated_tokens / MAX_CONTEXT_TOKENS) * 100));
+  state.bracket = detectBracket(state.estimated_pct);
+
+  saveState(state);
+  return state;
+}
+
+/**
+ * Check if a warning should be emitted (avoid spamming).
+ * Emits at most once per bracket transition.
+ */
+export function shouldEmitWarning(): { emit: boolean; message?: string } {
+  const state = loadState();
+  const strategy = getInjectionStrategy();
+
+  if (!strategy.warning) {
+    return { emit: false };
+  }
+
+  // Emit warning at most 3 times per session
+  if (state.warnings_emitted >= 3) {
+    return { emit: false };
+  }
+
+  state.warnings_emitted++;
+  saveState(state);
+
+  return { emit: true, message: strategy.warning };
+}
+
+/**
+ * Get context health report for display.
+ */
+export function getContextHealth(): {
+  bracket: ContextBracket;
+  pct: number;
+  tool_calls: number;
+  tokens: number;
+  recommendation: string;
+} {
+  const state = loadState();
+
+  let recommendation: string;
+  switch (state.bracket) {
+    case 'FRESH':
+      recommendation = 'Trabalhar normalmente. Carregar Hot + Warm.';
+      break;
+    case 'MODERATE':
+      recommendation = 'Seletivo com carregamento. Evitar arquivos grandes.';
+      break;
+    case 'DEPLETED':
+      recommendation = '/compact recomendado. Apenas Hot files.';
+      break;
+    case 'CRITICAL':
+      recommendation = '/compact URGENTE. Qualidade em risco.';
+      break;
+  }
+
+  return {
+    bracket: state.bracket,
+    pct: state.estimated_pct,
+    tool_calls: state.tool_calls,
+    tokens: state.estimated_tokens,
+    recommendation,
+  };
+}

package/framework/.aios-core/copy-chief/copy/copy-versioning.js

@@ -0,0 +1,131 @@
+#!/usr/bin/env node
+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 copy_versioning_exports = {};
+__export(copy_versioning_exports, {
+  backupVersion: () => backupVersion,
+  getBestVersion: () => getBestVersion,
+  getNextVersion: () => getNextVersion,
+  getVersions: () => getVersions,
+  getVersionsDir: () => getVersionsDir,
+  simpleDiff: () => simpleDiff
+});
+module.exports = __toCommonJS(copy_versioning_exports);
+var import_fs = require("fs");
+var import_path = require("path");
+const MAX_VERSIONS = 5;
+function getVersionsDir(filePath) {
+  const dir = (0, import_path.dirname)(filePath);
+  return (0, import_path.join)(dir, ".versions");
+}
+function getVersions(filePath) {
+  const versionsDir = getVersionsDir(filePath);
+  if (!(0, import_fs.existsSync)(versionsDir)) return [];
+  const name = (0, import_path.basename)(filePath, (0, import_path.extname)(filePath));
+  const ext = (0, import_path.extname)(filePath);
+  const prefix = `${name}.v`;
+  const versions = [];
+  try {
+    for (const file of (0, import_fs.readdirSync)(versionsDir)) {
+      if (!file.startsWith(prefix) || !file.endsWith(ext)) continue;
+      const versionStr = file.slice(prefix.length, file.length - ext.length);
+      const vNum = parseInt(versionStr);
+      if (isNaN(vNum)) continue;
+      const vPath = (0, import_path.join)(versionsDir, file);
+      const content = (0, import_fs.readFileSync)(vPath, "utf-8");
+      let score;
+      const scoreMatch = content.match(/(?:score|Score|BLACK)\s*:\s*(\d+(?:\.\d+)?)/i);
+      if (scoreMatch) score = parseFloat(scoreMatch[1]);
+      const stat = (0, import_fs.statSync)(vPath);
+      versions.push({
+        path: vPath,
+        meta: {
+          version: vNum,
+          timestamp: stat.mtime.toISOString(),
+          score,
+          source_file: filePath,
+          size_bytes: stat.size
+        }
+      });
+    }
+  } catch {
+  }
+  return versions.sort((a, b) => b.meta.version - a.meta.version);
+}
+function getNextVersion(filePath) {
+  const versions = getVersions(filePath);
+  if (versions.length === 0) return 1;
+  return versions[0].meta.version + 1;
+}
+function backupVersion(filePath) {
+  if (!(0, import_fs.existsSync)(filePath)) return null;
+  const versionsDir = getVersionsDir(filePath);
+  if (!(0, import_fs.existsSync)(versionsDir)) (0, import_fs.mkdirSync)(versionsDir, { recursive: true });
+  const name = (0, import_path.basename)(filePath, (0, import_path.extname)(filePath));
+  const ext = (0, import_path.extname)(filePath);
+  const vNum = getNextVersion(filePath);
+  const versionPath = (0, import_path.join)(versionsDir, `${name}.v${vNum}${ext}`);
+  const content = (0, import_fs.readFileSync)(filePath, "utf-8");
+  const header = `<!-- Version: ${vNum} | Backed up: ${(/* @__PURE__ */ new Date()).toISOString()} -->
+`;
+  (0, import_fs.writeFileSync)(versionPath, header + content);
+  cleanupVersions(filePath);
+  return versionPath;
+}
+function cleanupVersions(filePath) {
+  const versions = getVersions(filePath);
+  if (versions.length <= MAX_VERSIONS) return;
+  const toDelete = versions.slice(MAX_VERSIONS);
+  for (const v of toDelete) {
+    try {
+      (0, import_fs.unlinkSync)(v.path);
+    } catch {
+    }
+  }
+}
+function getBestVersion(filePath) {
+  const versions = getVersions(filePath);
+  if (versions.length === 0) return null;
+  const scored = versions.filter((v) => v.meta.score !== void 0);
+  if (scored.length === 0) return versions[0];
+  return scored.sort((a, b) => (b.meta.score || 0) - (a.meta.score || 0))[0];
+}
+function simpleDiff(oldText, newText) {
+  const oldWords = new Set(oldText.split(/\s+/).filter((w) => w.length > 3));
+  const newWords = new Set(newText.split(/\s+/).filter((w) => w.length > 3));
+  const added = [];
+  const removed = [];
+  let unchanged = 0;
+  for (const w of newWords) {
+    if (oldWords.has(w)) unchanged++;
+    else added.push(w);
+  }
+  for (const w of oldWords) {
+    if (!newWords.has(w)) removed.push(w);
+  }
+  return { added, removed, unchanged };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  backupVersion,
+  getBestVersion,
+  getNextVersion,
+  getVersions,
+  getVersionsDir,
+  simpleDiff
+});

package/framework/.aios-core/copy-chief/copy/copy-versioning.ts

@@ -0,0 +1,162 @@
+#!/usr/bin/env bun
+/**
+ * Copy Versioning Library v1.0
+ * Auto-backs up production copy before overwriting.
+ * Enables A/B comparison between versions.
+ *
+ * Source: AIOS Pro "status-based branching" concept.
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, unlinkSync, statSync } from 'fs';
+import { join, dirname, basename, extname } from 'path';
+
+const MAX_VERSIONS = 5;
+
+export interface VersionMeta {
+  version: number;
+  timestamp: string;
+  score?: number;
+  iteration?: number;
+  source_file: string;
+  size_bytes: number;
+}
+
+/**
+ * Get the .versions/ directory for a given production file
+ */
+export function getVersionsDir(filePath: string): string {
+  const dir = dirname(filePath);
+  return join(dir, '.versions');
+}
+
+/**
+ * Get all versions of a file, sorted by version number (desc)
+ */
+export function getVersions(filePath: string): { path: string; meta: VersionMeta }[] {
+  const versionsDir = getVersionsDir(filePath);
+  if (!existsSync(versionsDir)) return [];
+
+  const name = basename(filePath, extname(filePath));
+  const ext = extname(filePath);
+  const prefix = `${name}.v`;
+
+  const versions: { path: string; meta: VersionMeta }[] = [];
+
+  try {
+    for (const file of readdirSync(versionsDir)) {
+      if (!file.startsWith(prefix) || !file.endsWith(ext)) continue;
+
+      const versionStr = file.slice(prefix.length, file.length - ext.length);
+      const vNum = parseInt(versionStr);
+      if (isNaN(vNum)) continue;
+
+      const vPath = join(versionsDir, file);
+      const content = readFileSync(vPath, 'utf-8');
+
+      // Try to extract score from content header
+      let score: number | undefined;
+      const scoreMatch = content.match(/(?:score|Score|BLACK)\s*:\s*(\d+(?:\.\d+)?)/i);
+      if (scoreMatch) score = parseFloat(scoreMatch[1]);
+
+      const stat = statSync(vPath);
+      versions.push({
+        path: vPath,
+        meta: {
+          version: vNum,
+          timestamp: stat.mtime.toISOString(),
+          score,
+          source_file: filePath,
+          size_bytes: stat.size,
+        },
+      });
+    }
+  } catch { /* ignore */ }
+
+  return versions.sort((a, b) => b.meta.version - a.meta.version);
+}
+
+/**
+ * Get the next version number for a file
+ */
+export function getNextVersion(filePath: string): number {
+  const versions = getVersions(filePath);
+  if (versions.length === 0) return 1;
+  return versions[0].meta.version + 1;
+}
+
+/**
+ * Save a backup version of a file before overwriting
+ * Returns the version path if saved, null if file didn't exist
+ */
+export function backupVersion(filePath: string): string | null {
+  if (!existsSync(filePath)) return null;
+
+  const versionsDir = getVersionsDir(filePath);
+  if (!existsSync(versionsDir)) mkdirSync(versionsDir, { recursive: true });
+
+  const name = basename(filePath, extname(filePath));
+  const ext = extname(filePath);
+  const vNum = getNextVersion(filePath);
+  const versionPath = join(versionsDir, `${name}.v${vNum}${ext}`);
+
+  // Copy current file to version
+  const content = readFileSync(filePath, 'utf-8');
+
+  // Add version header
+  const header = `<!-- Version: ${vNum} | Backed up: ${new Date().toISOString()} -->\n`;
+  writeFileSync(versionPath, header + content);
+
+  // Cleanup old versions (keep MAX_VERSIONS)
+  cleanupVersions(filePath);
+
+  return versionPath;
+}
+
+/**
+ * Remove oldest versions beyond MAX_VERSIONS
+ */
+function cleanupVersions(filePath: string): void {
+  const versions = getVersions(filePath);
+  if (versions.length <= MAX_VERSIONS) return;
+
+  const toDelete = versions.slice(MAX_VERSIONS);
+  for (const v of toDelete) {
+    try { unlinkSync(v.path); } catch { /* ignore */ }
+  }
+}
+
+/**
+ * Get best version (highest score) of a file
+ */
+export function getBestVersion(filePath: string): { path: string; meta: VersionMeta } | null {
+  const versions = getVersions(filePath);
+  if (versions.length === 0) return null;
+
+  const scored = versions.filter(v => v.meta.score !== undefined);
+  if (scored.length === 0) return versions[0]; // Return latest if no scores
+
+  return scored.sort((a, b) => (b.meta.score || 0) - (a.meta.score || 0))[0];
+}
+
+/**
+ * Simple word-level diff between two texts
+ * Returns { added: string[], removed: string[], unchanged: number }
+ */
+export function simpleDiff(oldText: string, newText: string): { added: string[]; removed: string[]; unchanged: number } {
+  const oldWords = new Set(oldText.split(/\s+/).filter(w => w.length > 3));
+  const newWords = new Set(newText.split(/\s+/).filter(w => w.length > 3));
+
+  const added: string[] = [];
+  const removed: string[] = [];
+  let unchanged = 0;
+
+  for (const w of newWords) {
+    if (oldWords.has(w)) unchanged++;
+    else added.push(w);
+  }
+  for (const w of oldWords) {
+    if (!newWords.has(w)) removed.push(w);
+  }
+
+  return { added, removed, unchanged };
+}