@poetic-ai/poetic 1.42.0

package/dist/chunk-NSHASMZZ.js

@@ -0,0 +1,71 @@
+import {
+  parsePorcelainEntriesZ
+} from "./chunk-23A26CSN.js";
+import {
+  mkPoeticTempDir
+} from "./chunk-C57KJOUQ.js";
+import {
+  execGit
+} from "./chunk-KNDYMVWN.js";
+import {
+  safeRmDir
+} from "./chunk-G4THLFV3.js";
+
+// src/core/git/workspace-tree-identity.ts
+import { tmpdir } from "os";
+import { join } from "path";
+async function captureWorkspaceTreeIdentity(input) {
+  const scratch = await mkPoeticTempDir("workspace-tree-identity");
+  const indexPath = join(scratch, "index");
+  const env = { GIT_INDEX_FILE: indexPath };
+  try {
+    const readTree = await execGit(["read-tree", input.headSha], {
+      cwd: input.worktreePath,
+      env
+    });
+    if (readTree.exitCode !== 0) {
+      throw new Error(readTree.stderr || "could not seed workspace identity index");
+    }
+    if (input.changedPaths.length > 0) {
+      const add = await execGit(
+        ["--literal-pathspecs", "add", "-A", "--pathspec-from-file=-", "--pathspec-file-nul"],
+        {
+          cwd: input.worktreePath,
+          env,
+          input: `${input.changedPaths.join("\0")}\0`
+        }
+      );
+      if (add.exitCode !== 0) {
+        throw new Error(add.stderr || "could not capture workspace identity contents");
+      }
+    }
+    const tree = await execGit(["write-tree"], { cwd: input.worktreePath, env });
+    if (tree.exitCode !== 0 || !tree.stdout.trim()) {
+      throw new Error(tree.stderr || "could not write workspace identity tree");
+    }
+    return tree.stdout.trim();
+  } finally {
+    await safeRmDir(scratch, {
+      protectedPaths: [tmpdir()],
+      managedRoots: [tmpdir()]
+    });
+  }
+}
+async function captureCurrentWorkspaceTreeIdentity(worktreePath) {
+  const [head, status] = await Promise.all([
+    execGit(["rev-parse", "HEAD"], { cwd: worktreePath }),
+    execGit(["status", "--porcelain=v1", "--untracked-files=all", "-z"], { cwd: worktreePath })
+  ]);
+  const headSha = head.stdout.trim();
+  if (head.exitCode !== 0 || !headSha || status.exitCode !== 0) {
+    throw new Error(head.stderr || status.stderr || "workspace identity inputs unavailable");
+  }
+  const changedPaths = parsePorcelainEntriesZ(status.stdout).map((entry) => entry.path);
+  return await captureWorkspaceTreeIdentity({ worktreePath, headSha, changedPaths });
+}
+
+export {
+  captureWorkspaceTreeIdentity,
+  captureCurrentWorkspaceTreeIdentity
+};
+//# sourceMappingURL=chunk-NSHASMZZ.js.map

package/dist/chunk-NWOYOA6H.js

@@ -0,0 +1,378 @@
+import {
+  getProjectReferencePathExtensions
+} from "./chunk-UDMS5AD3.js";
+import {
+  resolvePoeticDirFromContext
+} from "./chunk-UI2F6DJ5.js";
+
+// src/prompts/pattern-bank.ts
+import crypto from "crypto";
+import fs from "fs";
+import path from "path";
+import Database from "better-sqlite3";
+var FILE_TARGETING_EXTENSION_ALTERNATION = [...getProjectReferencePathExtensions(), "css", "html"].map((ext) => ext.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+var FILE_TARGETING_EXTENSION_PATTERN = new RegExp(
+  String.raw`\.(?:${FILE_TARGETING_EXTENSION_ALTERNATION})(?![\w-])`
+);
+var PatternBank = class {
+  db;
+  poeticDir;
+  maxExemplars;
+  constructor(options = {}) {
+    this.poeticDir = resolvePoeticDirFromContext(options.poeticDir);
+    this.maxExemplars = options.maxExemplarsPerPattern ?? 3;
+    const dbDir = path.join(this.poeticDir, "prompts", "db");
+    if (!fs.existsSync(dbDir)) {
+      fs.mkdirSync(dbDir, { recursive: true });
+    }
+    this.db = new Database(path.join(dbDir, "pattern-bank.db"));
+    this.initSchema();
+  }
+  initSchema() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS prompt_patterns (
+        pattern_id TEXT PRIMARY KEY,
+        task_type TEXT NOT NULL,
+        file_targeting TEXT NOT NULL,
+        structure_type TEXT NOT NULL,
+        context_level TEXT NOT NULL,
+        has_examples INTEGER NOT NULL,
+        has_constraints INTEGER NOT NULL,
+        prompt_length TEXT NOT NULL,
+
+        -- Pareto tracking
+        total_wins INTEGER DEFAULT 0,
+        total_competitions INTEGER DEFAULT 0,
+        win_rate REAL DEFAULT 0,
+        avg_score REAL DEFAULT 0,
+        score_sum REAL DEFAULT 0,
+        providers TEXT DEFAULT '[]',
+
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS pattern_exemplars (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        pattern_id TEXT NOT NULL,
+        prompt_text TEXT NOT NULL,
+        task_description TEXT,
+        score REAL NOT NULL,
+        provider TEXT NOT NULL,
+        recorded_at TEXT NOT NULL,
+        FOREIGN KEY (pattern_id) REFERENCES prompt_patterns(pattern_id)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_patterns_task_type ON prompt_patterns(task_type);
+      CREATE INDEX IF NOT EXISTS idx_patterns_win_rate ON prompt_patterns(win_rate DESC);
+      CREATE INDEX IF NOT EXISTS idx_exemplars_pattern ON pattern_exemplars(pattern_id);
+    `);
+  }
+  /**
+   * Extract pattern characteristics from a prompt
+   */
+  extractPattern(prompt, taskType) {
+    const words = prompt.split(/\s+/).length;
+    return {
+      taskType: taskType || this.inferTaskType(prompt),
+      fileTargeting: this.detectFileTargeting(prompt),
+      structureType: this.detectStructureType(prompt),
+      contextLevel: this.detectContextLevel(prompt),
+      hasExamples: this.hasExamples(prompt),
+      hasConstraints: this.hasConstraints(prompt),
+      promptLength: words < 100 ? "short" : words < 500 ? "medium" : "long"
+    };
+  }
+  /**
+   * Generate a pattern ID from characteristics (for deduplication)
+   */
+  generatePatternId(pattern) {
+    const key = [
+      pattern.taskType,
+      pattern.fileTargeting,
+      pattern.structureType,
+      pattern.contextLevel,
+      pattern.hasExamples ? "ex" : "no-ex",
+      pattern.hasConstraints ? "con" : "no-con",
+      pattern.promptLength
+    ].join(":");
+    return crypto.createHash("sha256").update(key).digest("hex").slice(0, 16);
+  }
+  /**
+   * Record a competition result and update pattern statistics
+   */
+  async recordCompetitionResult(prompt, result, isWinner, taskType) {
+    const characteristics = this.extractPattern(prompt, taskType);
+    const patternId = this.generatePatternId(characteristics);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const existing = this.db.prepare("SELECT * FROM prompt_patterns WHERE pattern_id = ?").get(patternId);
+    if (existing) {
+      const newTotalWins = existing.total_wins + (isWinner ? 1 : 0);
+      const newTotalCompetitions = existing.total_competitions + 1;
+      const newScoreSum = existing.score_sum + (result.completeness || 0);
+      const providers = JSON.parse(existing.providers);
+      if (!providers.includes(result.provider)) {
+        providers.push(result.provider);
+      }
+      this.db.prepare(`
+        UPDATE prompt_patterns SET
+          total_wins = ?,
+          total_competitions = ?,
+          win_rate = ?,
+          score_sum = ?,
+          avg_score = ?,
+          providers = ?,
+          updated_at = ?
+        WHERE pattern_id = ?
+      `).run(
+        newTotalWins,
+        newTotalCompetitions,
+        newTotalWins / newTotalCompetitions,
+        newScoreSum,
+        newScoreSum / newTotalCompetitions,
+        JSON.stringify(providers),
+        now,
+        patternId
+      );
+    } else {
+      this.db.prepare(`
+        INSERT INTO prompt_patterns (
+          pattern_id, task_type, file_targeting, structure_type, context_level,
+          has_examples, has_constraints, prompt_length,
+          total_wins, total_competitions, win_rate, score_sum, avg_score, providers,
+          created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(
+        patternId,
+        characteristics.taskType,
+        characteristics.fileTargeting,
+        characteristics.structureType,
+        characteristics.contextLevel,
+        characteristics.hasExamples ? 1 : 0,
+        characteristics.hasConstraints ? 1 : 0,
+        characteristics.promptLength,
+        isWinner ? 1 : 0,
+        1,
+        isWinner ? 1 : 0,
+        result.completeness || 0,
+        result.completeness || 0,
+        JSON.stringify([result.provider]),
+        now,
+        now
+      );
+    }
+    if (isWinner) {
+      const exemplarCount = this.db.prepare("SELECT COUNT(*) as count FROM pattern_exemplars WHERE pattern_id = ?").get(patternId);
+      if (exemplarCount.count < this.maxExemplars) {
+        this.db.prepare(`
+          INSERT INTO pattern_exemplars (pattern_id, prompt_text, task_description, score, provider, recorded_at)
+          VALUES (?, ?, ?, ?, ?, ?)
+        `).run(
+          patternId,
+          prompt.slice(0, 2e3),
+          // Limit stored prompt length
+          (prompt.split("\n")[0] ?? "").slice(0, 500),
+          // First line as description (task_description field)
+          result.completeness || 0,
+          result.provider,
+          now
+        );
+      }
+    }
+    return patternId;
+  }
+  /**
+   * Get recommended patterns for a task type
+   */
+  getRecommendations(taskType, limit = 3) {
+    const patterns = this.db.prepare(`
+      SELECT * FROM prompt_patterns
+      WHERE task_type = ? AND total_competitions >= 3
+      ORDER BY win_rate DESC, avg_score DESC
+      LIMIT ?
+    `).all(taskType, limit);
+    return patterns.map((row) => {
+      const exemplars = this.db.prepare("SELECT * FROM pattern_exemplars WHERE pattern_id = ? ORDER BY score DESC LIMIT 3").all(row.pattern_id);
+      const pattern = {
+        patternId: row.pattern_id,
+        taskType: row.task_type,
+        fileTargeting: row.file_targeting,
+        structureType: row.structure_type,
+        contextLevel: row.context_level,
+        hasExamples: row.has_examples === 1,
+        hasConstraints: row.has_constraints === 1,
+        promptLength: row.prompt_length,
+        winRate: row.win_rate,
+        avgScore: row.avg_score,
+        sampleSize: row.total_competitions,
+        providers: JSON.parse(row.providers),
+        exemplars: exemplars.map((e) => ({
+          promptText: e.prompt_text,
+          taskDescription: e.task_description,
+          score: e.score,
+          provider: e.provider,
+          recordedAt: e.recorded_at
+        })),
+        createdAt: row.created_at,
+        updatedAt: row.updated_at
+      };
+      return {
+        pattern,
+        confidence: Math.min(0.9, row.win_rate * (1 - 1 / (row.total_competitions + 1))),
+        rationale: this.generateRationale(pattern),
+        suggestedStructure: this.generateSuggestedStructure(pattern)
+      };
+    });
+  }
+  /**
+   * Get top patterns across all task types (Pareto frontier)
+   */
+  getParetoFrontier(limit = 10) {
+    const rows = this.db.prepare(`
+      SELECT * FROM prompt_patterns
+      WHERE total_competitions >= 5
+      ORDER BY win_rate DESC, avg_score DESC
+      LIMIT ?
+    `).all(limit);
+    return rows.map((row) => ({
+      patternId: row.pattern_id,
+      taskType: row.task_type,
+      fileTargeting: row.file_targeting,
+      structureType: row.structure_type,
+      contextLevel: row.context_level,
+      hasExamples: row.has_examples === 1,
+      hasConstraints: row.has_constraints === 1,
+      promptLength: row.prompt_length,
+      winRate: row.win_rate,
+      avgScore: row.avg_score,
+      sampleSize: row.total_competitions,
+      providers: JSON.parse(row.providers),
+      exemplars: [],
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    }));
+  }
+  /**
+   * Get statistics for pattern bank
+   */
+  getStats() {
+    const totals = this.db.prepare(`
+      SELECT
+        COUNT(*) as total_patterns,
+        SUM(total_competitions) as total_competitions,
+        AVG(win_rate) as avg_win_rate
+      FROM prompt_patterns
+    `).get();
+    const topTaskTypes = this.db.prepare(`
+      SELECT
+        task_type,
+        COUNT(*) as count,
+        AVG(win_rate) as avg_win_rate
+      FROM prompt_patterns
+      GROUP BY task_type
+      ORDER BY count DESC
+      LIMIT 5
+    `).all();
+    return {
+      totalPatterns: totals.total_patterns || 0,
+      totalCompetitions: totals.total_competitions || 0,
+      avgWinRate: totals.avg_win_rate || 0,
+      topTaskTypes: topTaskTypes.map((t) => ({
+        taskType: t.task_type,
+        count: t.count,
+        avgWinRate: t.avg_win_rate
+      }))
+    };
+  }
+  // Pattern detection helpers
+  inferTaskType(prompt) {
+    const lower = prompt.toLowerCase();
+    if (/\b(fix|bug|error|crash|issue|broken)\b/.test(lower)) return "bug-fix";
+    if (/\b(add|implement|create|new|feature)\b/.test(lower)) return "feature";
+    if (/\b(refactor|clean|improve|restructure)\b/.test(lower)) return "refactor";
+    if (/\b(test|spec|coverage|unittest)\b/.test(lower)) return "test";
+    if (/\b(document|readme|comment|explain)\b/.test(lower)) return "documentation";
+    if (/\b(analyze|review|audit|investigate)\b/.test(lower)) return "analysis";
+    if (/\b(optimize|performance|speed|memory)\b/.test(lower)) return "optimization";
+    if (/\b(security|vulnerability|auth|permission)\b/.test(lower)) return "security";
+    return "unknown";
+  }
+  detectFileTargeting(prompt) {
+    if (/FILE:|FILES:|file:\s|files:\s/i.test(prompt)) return "explicit";
+    if (FILE_TARGETING_EXTENSION_PATTERN.test(prompt)) return "inferred";
+    if (/src\/|lib\/|test\/|\.\//.test(prompt)) return "inferred";
+    return "none";
+  }
+  detectStructureType(prompt) {
+    if (/^(1\.|step 1|first,)/im.test(prompt)) return "step-by-step";
+    if (/^(example|for example|e\.g\.|like this)/im.test(prompt)) return "examples-first";
+    if (/^(must|should|requirement|constraint)/im.test(prompt)) return "constraints-first";
+    return "freeform";
+  }
+  detectContextLevel(prompt) {
+    const words = prompt.split(/\s+/).length;
+    const hasBackground = /background|context|currently|existing/.test(prompt.toLowerCase());
+    const hasRequirements = /requirement|must|should|need/.test(prompt.toLowerCase());
+    if (words > 300 && hasBackground && hasRequirements) return "comprehensive";
+    if (words > 100 || hasBackground || hasRequirements) return "moderate";
+    return "minimal";
+  }
+  hasExamples(prompt) {
+    return /example|e\.g\.|for instance|like this|such as|```/.test(prompt.toLowerCase());
+  }
+  hasConstraints(prompt) {
+    return /must|should|don't|do not|avoid|never|always|requirement/.test(prompt.toLowerCase());
+  }
+  generateRationale(pattern) {
+    const parts = [];
+    parts.push(
+      `${(pattern.winRate * 100).toFixed(0)}% win rate over ${pattern.sampleSize} competitions`
+    );
+    if (pattern.fileTargeting === "explicit") {
+      parts.push("explicit FILE: targeting increases precision");
+    }
+    if (pattern.structureType === "step-by-step") {
+      parts.push("step-by-step structure guides execution");
+    }
+    if (pattern.hasExamples) {
+      parts.push("examples clarify expected output");
+    }
+    return parts.join("; ");
+  }
+  generateSuggestedStructure(pattern) {
+    const lines = [];
+    if (pattern.fileTargeting === "explicit") {
+      lines.push("FILE: <target-file>");
+      lines.push("");
+    }
+    if (pattern.structureType === "step-by-step") {
+      lines.push("1. [First step]");
+      lines.push("2. [Second step]");
+      lines.push("3. [Third step]");
+    } else if (pattern.structureType === "constraints-first") {
+      lines.push("Requirements:");
+      lines.push("- [Constraint 1]");
+      lines.push("- [Constraint 2]");
+      lines.push("");
+      lines.push("[Task description]");
+    } else {
+      lines.push("[Task description]");
+    }
+    if (pattern.hasExamples) {
+      lines.push("");
+      lines.push("Example:");
+      lines.push("```");
+      lines.push("[example code or output]");
+      lines.push("```");
+    }
+    return lines.join("\n");
+  }
+  close() {
+    this.db.close();
+  }
+};
+
+export {
+  PatternBank
+};
+//# sourceMappingURL=chunk-NWOYOA6H.js.map