agent-enderun 0.8.8 → 0.9.1

package/framework-mcp/src/tools/pipeline.ts

@@ -1,353 +0,0 @@
-import { Tool } from "@modelcontextprotocol/sdk/types.js";
-import { promises as fs } from "fs";
-import path from "path";
-
-// ─── Types ─────────────────────────────────────────────────────────────────────
-
-type PipelineStage = {
-  id: string;
-  name: string;
-  agent: string;
-  status: "PENDING" | "RUNNING" | "COMPLETED" | "FAILED" | "SKIPPED";
-  dependsOn: string[];
-  startedAt?: string;
-  completedAt?: string;
-  output?: string;
-};
-
-type Pipeline = {
-  id: string;
-  traceId: string;
-  name: string;
-  description: string;
-  createdAt: string;
-  updatedAt: string;
-  status: "PENDING" | "RUNNING" | "COMPLETED" | "FAILED" | "ROLLED_BACK";
-  currentStageId?: string;
-  stages: PipelineStage[];
-  rollbackStages?: PipelineStage[];
-};
-
-// ─── Tool Definitions ─────────────────────────────────────────────────────────
-
-export const pipelineTools: Tool[] = [
-  {
-    name: "create_execution_pipeline",
-    description:
-      "Creates a multi-stage execution pipeline for complex workflows (e.g., build → test → security audit → deploy). Each stage is assigned to a specific agent and has defined dependencies. The pipeline is persisted and can be advanced or rolled back.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        traceId: { type: "string", description: "Active Trace ID from @manager briefing" },
-        name: { type: "string", description: "Pipeline name (e.g. 'Production Deploy v1.2.0')" },
-        description: { type: "string", description: "What this pipeline accomplishes" },
-        stages: {
-          type: "array",
-          description: "Ordered pipeline stages",
-          items: {
-            type: "object",
-            required: ["id", "name", "agent"],
-            properties: {
-              id: { type: "string" },
-              name: { type: "string" },
-              agent: { type: "string" },
-              dependsOn: { type: "array", items: { type: "string" } },
-            },
-          },
-        },
-        rollbackStages: {
-          type: "array",
-          description: "Optional rollback stages executed in reverse order on pipeline failure",
-          items: {
-            type: "object",
-            required: ["id", "name", "agent"],
-            properties: {
-              id: { type: "string" },
-              name: { type: "string" },
-              agent: { type: "string" },
-              dependsOn: { type: "array", items: { type: "string" } },
-            },
-          },
-        },
-      },
-      required: ["traceId", "name", "stages"],
-    },
-  },
-  {
-    name: "advance_pipeline_stage",
-    description:
-      "Advances a pipeline to the next eligible stage. Marks the current stage as COMPLETED and activates all dependent stages that now have their dependencies satisfied. Returns the new pipeline state.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        pipelineId: { type: "string", description: "Pipeline ID" },
-        completedStageId: { type: "string", description: "The stage that just completed successfully" },
-        stageOutput: { type: "string", description: "Optional output/result from the completed stage" },
-      },
-      required: ["pipelineId", "completedStageId"],
-    },
-  },
-  {
-    name: "rollback_pipeline",
-    description:
-      "Rolls back a pipeline to the last stable state by executing the defined rollback stages in reverse order. Updates the pipeline status to ROLLED_BACK.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        pipelineId: { type: "string", description: "Pipeline ID to roll back" },
-        reason: { type: "string", description: "Reason for the rollback (mandatory for audit)" },
-      },
-      required: ["pipelineId", "reason"],
-    },
-  },
-  {
-    name: "get_pipeline_status",
-    description:
-      "Returns the full current status of a pipeline including all stage states, progress percentage, blocking stages, and estimated completion.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        pipelineId: { type: "string", description: "Pipeline ID" },
-      },
-      required: ["pipelineId"],
-    },
-  },
-];
-
-// ─── Handlers ─────────────────────────────────────────────────────────────────
-
-export const pipelineHandlers: Record<
-  string,
-  (args: unknown, projectRoot: string) => Promise<{ content: Array<{ type: string; text: string }> }>
-> = {
-  async create_execution_pipeline(args, projectRoot) {
-    const { traceId, name, description, stages, rollbackStages } = args as {
-      traceId: string;
-      name: string;
-      description?: string;
-      stages: Omit<PipelineStage, "status" | "startedAt" | "completedAt" | "output">[];
-      rollbackStages?: Omit<PipelineStage, "status" | "startedAt" | "completedAt" | "output">[];
-    };
-
-    const pipelineId = `PIPE-${traceId}-${Date.now()}`;
-    const now = new Date().toISOString();
-
-    const pipeline: Pipeline = {
-      id: pipelineId,
-      traceId,
-      name,
-      description: description ?? "",
-      createdAt: now,
-      updatedAt: now,
-      status: "PENDING",
-      stages: stages.map((s) => ({
-        ...s,
-        dependsOn: s.dependsOn ?? [],
-        status: "PENDING" as const,
-      })),
-      rollbackStages: rollbackStages?.map((s) => ({
-        ...s,
-        dependsOn: s.dependsOn ?? [],
-        status: "PENDING" as const,
-      })),
-    };
-
-    // Activate stages with no dependencies
-    for (const stage of pipeline.stages) {
-      if (stage.dependsOn.length === 0) {
-        stage.status = "RUNNING";
-        stage.startedAt = now;
-      }
-    }
-    pipeline.status = "RUNNING";
-
-    // Persist pipeline
-    const pipelineDir = path.join(projectRoot, ".enderun", "queue", "pipelines");
-    await fs.mkdir(pipelineDir, { recursive: true });
-    await fs.writeFile(
-      path.join(pipelineDir, `${pipelineId}.json`),
-      JSON.stringify(pipeline, null, 2),
-      "utf-8"
-    );
-
-    return { content: [{ type: "text", text: JSON.stringify(pipeline, null, 2) }] };
-  },
-
-  async advance_pipeline_stage(args, projectRoot) {
-    const { pipelineId, completedStageId, stageOutput } = args as {
-      pipelineId: string;
-      completedStageId: string;
-      stageOutput?: string;
-    };
-
-    const pipelineDir = path.join(projectRoot, ".enderun", "queue", "pipelines");
-    const pipelinePath = path.join(pipelineDir, `${pipelineId}.json`);
-
-    let pipeline: Pipeline;
-    try {
-      const content = await fs.readFile(pipelinePath, "utf-8");
-      pipeline = JSON.parse(content) as Pipeline;
-    } catch {
-      return {
-        content: [
-          { type: "text", text: JSON.stringify({ error: "PIPELINE_NOT_FOUND", pipelineId }) },
-        ],
-      };
-    }
-
-    const now = new Date().toISOString();
-
-    // Mark completed stage
-    const completedStage = pipeline.stages.find((s) => s.id === completedStageId);
-    if (!completedStage) {
-      return {
-        content: [
-          { type: "text", text: JSON.stringify({ error: "STAGE_NOT_FOUND", completedStageId }) },
-        ],
-      };
-    }
-    completedStage.status = "COMPLETED";
-    completedStage.completedAt = now;
-    if (stageOutput) completedStage.output = stageOutput;
-
-    // Activate newly unblocked stages
-    const completedIds = new Set(pipeline.stages.filter((s) => s.status === "COMPLETED").map((s) => s.id));
-    const newlyActivated: string[] = [];
-
-    for (const stage of pipeline.stages) {
-      if (stage.status === "PENDING" && stage.dependsOn.every((dep) => completedIds.has(dep))) {
-        stage.status = "RUNNING";
-        stage.startedAt = now;
-        newlyActivated.push(stage.id);
-      }
-    }
-
-    // Check if pipeline is complete
-    const allDone = pipeline.stages.every((s) => s.status === "COMPLETED");
-    if (allDone) {
-      pipeline.status = "COMPLETED";
-    }
-
-    pipeline.updatedAt = now;
-    await fs.writeFile(pipelinePath, JSON.stringify(pipeline, null, 2), "utf-8");
-
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({ pipeline, newlyActivatedStages: newlyActivated }, null, 2),
-        },
-      ],
-    };
-  },
-
-  async rollback_pipeline(args, projectRoot) {
-    const { pipelineId, reason } = args as { pipelineId: string; reason: string };
-
-    const pipelineDir = path.join(projectRoot, ".enderun", "queue", "pipelines");
-    const pipelinePath = path.join(pipelineDir, `${pipelineId}.json`);
-
-    let pipeline: Pipeline;
-    try {
-      const content = await fs.readFile(pipelinePath, "utf-8");
-      pipeline = JSON.parse(content) as Pipeline;
-    } catch {
-      return {
-        content: [
-          { type: "text", text: JSON.stringify({ error: "PIPELINE_NOT_FOUND", pipelineId }) },
-        ],
-      };
-    }
-
-    const now = new Date().toISOString();
-    pipeline.status = "ROLLED_BACK";
-    pipeline.updatedAt = now;
-
-    // Mark all non-completed stages as SKIPPED
-    for (const stage of pipeline.stages) {
-      if (stage.status === "RUNNING" || stage.status === "PENDING") {
-        stage.status = "SKIPPED";
-      }
-    }
-
-    // Activate rollback stages if defined
-    if (pipeline.rollbackStages) {
-      for (const stage of pipeline.rollbackStages) {
-        stage.status = "RUNNING";
-        stage.startedAt = now;
-      }
-    }
-
-    await fs.writeFile(pipelinePath, JSON.stringify(pipeline, null, 2), "utf-8");
-
-    // Write rollback event to devops log
-    const devopsLogPath = path.join(projectRoot, ".enderun", "logs", "devops.json");
-    let devopsLog: { rollbacks: unknown[] } = { rollbacks: [] };
-    try {
-      const existing = await fs.readFile(devopsLogPath, "utf-8");
-      devopsLog = JSON.parse(existing) as typeof devopsLog;
-      if (!devopsLog.rollbacks) devopsLog.rollbacks = [];
-    } catch {
-      // Start fresh
-    }
-    devopsLog.rollbacks.push({ pipelineId, reason, timestamp: now });
-    await fs.mkdir(path.dirname(devopsLogPath), { recursive: true });
-    await fs.writeFile(devopsLogPath, JSON.stringify(devopsLog, null, 2), "utf-8");
-
-    return { content: [{ type: "text", text: JSON.stringify({ pipeline, rollbackReason: reason }, null, 2) }] };
-  },
-
-  async get_pipeline_status(args, projectRoot) {
-    const { pipelineId } = args as { pipelineId: string };
-    const pipelinePath = path.join(
-      projectRoot,
-      ".enderun",
-      "queue",
-      "pipelines",
-      `${pipelineId}.json`
-    );
-
-    try {
-      const content = await fs.readFile(pipelinePath, "utf-8");
-      const pipeline = JSON.parse(content) as Pipeline;
-
-      const total = pipeline.stages.length;
-      const completed = pipeline.stages.filter((s) => s.status === "COMPLETED").length;
-      const running = pipeline.stages.filter((s) => s.status === "RUNNING").map((s) => s.id);
-      const blocked = pipeline.stages.filter(
-        (s) => s.status === "PENDING" && s.dependsOn.some((dep) => {
-          const depStage = pipeline.stages.find((st) => st.id === dep);
-          return depStage && depStage.status !== "COMPLETED";
-        })
-      ).map((s) => s.id);
-
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(
-              {
-                pipelineId,
-                name: pipeline.name,
-                status: pipeline.status,
-                progress: `${completed}/${total} stages (${Math.round((completed / total) * 100)}%)`,
-                currentlyRunning: running,
-                waitingOn: blocked,
-                createdAt: pipeline.createdAt,
-                updatedAt: pipeline.updatedAt,
-              },
-              null,
-              2
-            ),
-          },
-        ],
-      };
-    } catch {
-      return {
-        content: [
-          { type: "text", text: JSON.stringify({ error: "PIPELINE_NOT_FOUND", pipelineId }) },
-        ],
-      };
-    }
-  },
-};

package/framework-mcp/src/tools/security.ts

@@ -1,143 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { Project, SyntaxKind } from "ts-morph";
-import { 
-    collectFilesRecursively, 
-    resolveSafePath, 
-    buildLineMatches 
-} from "../utils.js";
-import { 
-    SECURITY_AUDIT_ARGS_SCHEMA, 
-    ANALYZE_CONSTITUTION_COMPLIANCE_ARGS_SCHEMA 
-} from "../schemas.js";
-
-export const securityTools = [
-    {
-        name: "security_audit_scan",
-        description: "Scans the codebase for security vulnerabilities like hardcoded secrets, raw SQL, and unsafe async patterns.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                path: {
-                    type: "string",
-                    description: "Path to scan (relative to project root)",
-                    default: ".",
-                },
-            },
-        },
-    },
-    {
-        name: "analyze_constitution_compliance",
-        description: "Scans a file or directory for violations of the project's ENDERUN.md rules (e.g. Zero UI Library, Branded Types).",
-        inputSchema: {
-            type: "object",
-            properties: {
-                path: {
-                    type: "string",
-                    description: "Path to scan (relative to project root)",
-                },
-            },
-            required: ["path"],
-        },
-    },
-];
-
-export const securityHandlers = {
-    security_audit_scan: async (args: unknown, projectRoot: string) => {
-        const parsed = SECURITY_AUDIT_ARGS_SCHEMA.safeParse(args ?? {});
-        if (!parsed.success) return { content: [{ type: "text", text: "Invalid path argument." }] };
-        const vulnerabilities: string[] = [];
-        const scanRules = [
-            { pattern: /sql`/, message: "Potential Raw SQL usage detected (check Kysely usage)", severity: "HIGH" },
-            { pattern: /(?<!\/\/\s*)console\.log/, message: "console.log found in production code", severity: "LOW" },
-            { pattern: /(password|secret|api_?key)\s*[:=]\s*['"][^'"]+['"]/i, message: "Potential hardcoded secret/password detected", severity: "CRITICAL" },
-            { pattern: /:\s*any(?!\w)/, message: "Usage of 'any' type detected", severity: "MEDIUM" },
-            { pattern: /(?<!\w)eval\s*\(/, message: "Dangerous 'eval()' usage detected", severity: "HIGH" },
-            { pattern: /\.innerHTML\s*=/, message: "Unsafe innerHTML assignment detected (XSS risk)", severity: "MEDIUM" },
-            { pattern: /dangerouslySetInnerHTML/, message: "React dangerouslySetInnerHTML detected", severity: "MEDIUM" },
-            { pattern: /TODO:/, message: "Outstanding TODO item found", severity: "LOW" },
-        ];
-        try {
-            const safeTargetPath = resolveSafePath(projectRoot, parsed.data.path);
-            if (!fs.existsSync(safeTargetPath)) return { content: [{ type: "text", text: "Target path not found." }] };
-            const files = collectFilesRecursively(safeTargetPath, new Set(["ts", "tsx"]));
-            for (const rule of scanRules) {
-                const ruleMatches = buildLineMatches(files, (line) => typeof rule.pattern === "string" ? line.includes(rule.pattern) : rule.pattern.test(line), 5, projectRoot);
-                if (ruleMatches.length > 0) vulnerabilities.push(`[${rule.severity}] ${rule.message}:\n${ruleMatches.join("\n")}`);
-            }
-            const tsProject = new Project({ compilerOptions: { allowJs: true } });
-            tsProject.addSourceFilesAtPaths(path.join(safeTargetPath, "**/*.{ts,tsx}"));
-            for (const sourceFile of tsProject.getSourceFiles()) {
-                const relativePath = path.relative(projectRoot, sourceFile.getFilePath());
-                sourceFile.forEachDescendant((node) => {
-                    if (node.getKindName() === "AnyKeyword") {
-                        vulnerabilities.push(`[MEDIUM] Precise 'any' type detected in AST at ${relativePath}:${node.getStartLineNumber()}`);
-                    }
-                    if (node.getKind() === SyntaxKind.CallExpression) {
-                        const callExp = node.asKind(SyntaxKind.CallExpression);
-                        if (callExp?.getExpression().getText() === "console.log") {
-                            vulnerabilities.push(`[LOW] Production 'console.log' detected in AST at ${relativePath}:${node.getStartLineNumber()}`);
-                        }
-                    }
-                });
-            }
-            return { content: [{ type: "text", text: vulnerabilities.length > 0 ? `### ADVANCED SECURITY AUDIT RESULTS\n\n${Array.from(new Set(vulnerabilities)).join("\n\n")}` : "No security patterns or rule violations detected (Regex & AST verified)." }] };
-        } catch {
-            return { content: [{ type: "text", text: "Security audit failed." }] };
-        }
-    },
-    analyze_constitution_compliance: async (args: unknown, projectRoot: string) => {
-        const parsed = ANALYZE_CONSTITUTION_COMPLIANCE_ARGS_SCHEMA.safeParse(args ?? {});
-        if (!parsed.success) return { content: [{ type: "text", text: "Invalid path argument." }] };
-        try {
-            const safePath = resolveSafePath(projectRoot, parsed.data.path);
-            const violations: string[] = [];
-            const forbiddenLibraries = ["@shadcn", "mui", "@chakra-ui", "antd", "bootstrap", "tailwindcss"];
-
-            if (fs.existsSync(safePath) && fs.lstatSync(safePath).isDirectory()) {
-                const tsProject = new Project({ compilerOptions: { allowJs: true } });
-                tsProject.addSourceFilesAtPaths(path.join(safePath, "**/*.{ts,tsx,js,jsx}"));
-                
-                for (const sourceFile of tsProject.getSourceFiles()) {
-                    const relativePath = path.relative(projectRoot, sourceFile.getFilePath());
-                    if (relativePath.includes("node_modules") || relativePath.includes("dist")) continue;
-                    
-                    // AST-based Import Check for Zero UI Policy
-                    sourceFile.getImportDeclarations().forEach(imp => {
-                        const moduleValue = imp.getModuleSpecifierValue();
-                        if (forbiddenLibraries.some(lib => moduleValue.includes(lib))) {
-                            violations.push(`${relativePath}: AST Violation - Zero UI Library Policy (imported '${moduleValue}')`);
-                        }
-                    });
-
-                    // AST-based String ID Check for Branded Types Law
-                    sourceFile.getInterfaces().forEach(iface => {
-                        const idProp = iface.getProperty("id");
-                        if (idProp && idProp.getType().isString() && !idProp.getType().getText().includes("Brand")) {
-                            violations.push(`${relativePath}: AST Violation - Branded Types Law (interface '${iface.getName()}' uses plain string for ID)`);
-                        }
-                    });
-                    
-                    const content = sourceFile.getFullText();
-                    if (content.includes("console.log") && !relativePath.includes("cli.js")) {
-                        violations.push(`${relativePath}: Text Violation - Logging Policy (found 'console.log')`);
-                    }
-                    if (content.includes("sql`")) {
-                        violations.push(`${relativePath}: Text Violation - Potential Kysely Standards (found raw 'sql' tag)`);
-                    }
-                }
-            } else if (fs.existsSync(safePath)) {
-                // Fallback for single files
-                const content = fs.readFileSync(safePath, "utf-8");
-                const relativePath = path.relative(projectRoot, safePath);
-                for (const lib of forbiddenLibraries) {
-                    if (content.includes(lib)) violations.push(`${relativePath}: Violation of Zero UI Library Policy (found '${lib}')`);
-                }
-            }
-
-            return { content: [{ type: "text", text: `### CONSTITUTION COMPLIANCE REPORT\n\n` + (violations.length > 0 ? `⚠️ **VIOLATIONS FOUND:**\n${violations.map(v => `- ${v}`).join("\n")}` : "✅ **ALL SYSTEMS COMPLIANT:** AST and Regex scans passed. No rule violations detected.") }] };
-        } catch {
-            return { content: [{ type: "text", text: "Constitution compliance check failed." }] };
-        }
-    },
-};

package/framework-mcp/src/utils.ts

@@ -1,130 +0,0 @@
-import path from "path";
-import fs from "fs";
-import { fileURLToPath } from "url";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-const getPackageVersion = (): string => {
-    try {
-        const pkgPath = path.join(__dirname, "../package.json");
-        if (fs.existsSync(pkgPath)) {
-            const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-            return pkg.version || "0.8.8";
-        }
-    } catch {
-        // fallback
-    }
-    return "0.8.8";
-};
-
-export const FRAMEWORK_VERSION = getPackageVersion();
-
-/**
- * Dynamically detects the framework directory for the current project.
- * Checks in priority order: .enderun → .gemini → .cursor → fallback .gemini
- * This resolves the adapter mismatch bug (KRITIK-1 in v0.7.5 analysis).
- */
-export function getFrameworkDir(projectRoot: string): string {
-    const candidates = [".enderun", ".gemini", ".cursor"];
-    for (const dir of candidates) {
-        const dirPath = path.join(projectRoot, dir);
-        if (fs.existsSync(dirPath) && fs.statSync(dirPath).isDirectory()) {
-            // Verify it looks like a framework dir (has PROJECT_MEMORY.md or agents/ dir)
-            const hasMemory = fs.existsSync(path.join(dirPath, "PROJECT_MEMORY.md"));
-            const hasAgents = fs.existsSync(path.join(dirPath, "agents"));
-            if (hasMemory || hasAgents) {
-                return dir;
-            }
-        }
-    }
-    // Ultimate fallback — return first existing dir or .gemini
-    for (const dir of candidates) {
-        if (fs.existsSync(path.join(projectRoot, dir))) return dir;
-    }
-    return ".gemini";
-}
-
-export function resolveSafePath(projectRoot: string, targetPath: string): string {
-    const resolved = path.resolve(projectRoot, targetPath);
-    const relative = path.relative(projectRoot, resolved);
-    if (relative.startsWith("..") || path.isAbsolute(relative)) {
-        throw new Error("Path escapes project root.");
-    }
-    return resolved;
-}
-
-export function collectFilesRecursively(targetPath: string, extensions: Set<string>): string[] {
-    const results: string[] = [];
-    const entries = fs.readdirSync(targetPath, { withFileTypes: true });
-    for (const entry of entries) {
-        const fullPath = path.join(targetPath, entry.name);
-        if (entry.isDirectory()) {
-            if (entry.name === "node_modules" || entry.name === ".git")
-                continue;
-            results.push(...collectFilesRecursively(fullPath, extensions));
-            continue;
-        }
-        const ext = path.extname(entry.name).slice(1).toLowerCase();
-        if (extensions.has(ext))
-            results.push(fullPath);
-    }
-    return results;
-}
-
-export function buildLineMatches(files: string[], matcher: (line: string) => boolean, maxResults: number, projectRoot: string): string[] {
-    const matches: string[] = [];
-    for (const filePath of files) {
-        if (matches.length >= maxResults)
-            break;
-        const content = fs.readFileSync(filePath, "utf-8");
-        const lines = content.split("\n");
-        for (let i = 0; i < lines.length; i++) {
-            if (matches.length >= maxResults)
-                break;
-            const line = lines[i];
-            if (!matcher(line))
-                continue;
-            const relativePath = path.relative(projectRoot, filePath);
-            matches.push(`${relativePath}:${i + 1}:${line}`);
-        }
-    }
-    return matches;
-}
-
-export function collectMarkdownArtifacts(projectRoot: string): string[] {
-    const frameworkDir = getFrameworkDir(projectRoot);
-    const searchPaths = [
-        path.join(projectRoot, "docs"),
-        path.join(projectRoot, frameworkDir, "docs")
-    ];
-    
-    const results: string[] = [];
-    for (const docsRoot of searchPaths) {
-        if (fs.existsSync(docsRoot)) {
-            results.push(...collectFilesRecursively(docsRoot, new Set(["md"])).map((filePath) => path.relative(projectRoot, filePath)));
-        }
-    }
-    return Array.from(new Set(results));
-}
-
-export function replaceSectionContent(markdown: string, sectionTitle: string, newBody: string): string {
-    const escaped = sectionTitle.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const sectionRegex = new RegExp(`## ${escaped}[\\s\\S]*?(?=\\n## |$)`);
-    if (!sectionRegex.test(markdown)) {
-        throw new Error(`Section not found: ${sectionTitle}`);
-    }
-    return markdown.replace(sectionRegex, `## ${sectionTitle}\n\n${newBody.trim()}\n`);
-}
-
-export function prependToSection(markdown: string, sectionTitle: string, contentToPrepend: string): string {
-    const escaped = sectionTitle.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const sectionRegex = new RegExp(`(## ${escaped}\\n)([\\s\\S]*?)(?=\\n## |$)`);
-    const match = markdown.match(sectionRegex);
-    if (!match) {
-        throw new Error(`Section not found: ${sectionTitle}`);
-    }
-    const currentBody = match[2].trimStart();
-    const updatedBody = `${contentToPrepend.trim()}\n\n${currentBody}`.trim();
-    return markdown.replace(sectionRegex, `$1\n${updatedBody}\n`);
-}