agent-enderun 1.1.8 → 1.1.10

package/src/cli/commands/orchestrate.ts

@@ -1,17 +1,18 @@
 import fs from "fs";
 import path from "path";
 import chalk from "chalk";
-import { getFrameworkDir } from "../utils/memory.js";
+import { getFrameworkDir, updateDocumentStore, readStatus } from "../utils/memory.js";
 import { UI } from "../utils/ui.js";
 import { z } from "zod";
 import { logger } from "../../shared/logger.js";
+import { TaskRequestSchema } from "../../contracts/tasks.js";
 
 export const HermesMessageSchema = z.object({
     timestamp: z.string(),
     from: z.string(),
     to: z.string(),
     category: z.enum(["ACTION", "DELEGATION", "SUBTASK", "REPLY", "ALERT"]),
-    content: z.string(),
+    content: z.string(), // This is the payload to be validated
     traceId: z.string(),
     parentId: z.string().optional(),
     status: z.enum(["PENDING", "PROCESSED", "WAITING", "APPROVED"]),
@@ -26,51 +27,25 @@ export async function orchestrateCommand() {
     const messagesDir = path.join(frameworkDir, "messages");
 
     // Check for agent timeouts (e.g. 30 minutes in EXECUTING state)
-    const statusPath = path.join(frameworkDir, "STATUS.md");
-    if (fs.existsSync(statusPath)) {
-        try {
-            const content = fs.readFileSync(statusPath, "utf8");
-            const lines = content.split("\n");
-            let updatedStatus = false;
-            const newLines = lines.map(line => {
-                if (line.includes("| @") && line.includes("| EXECUTING |")) {
-                    const parts = line.split("|");
-                    if (parts.length >= 7) {
-                        const lastUpdatedStr = parts[4].trim();
-                        if (lastUpdatedStr && lastUpdatedStr !== "-") {
-                            const lastUpdatedTime = Date.parse(lastUpdatedStr);
-                            if (!isNaN(lastUpdatedTime) && Date.now() - lastUpdatedTime > 30 * 60 * 1000) {
-                                const agentName = parts[1].trim();
-                                UI.error(`⚠️  Agent ${agentName} has TIMED OUT (in EXECUTING state for >30m). Transitioning to BLOCKED.`);
-                                parts[2] = " BLOCKED ";
-                                parts[3] = " Timeout occurred ";
-                                parts[4] = ` ${new Date().toISOString()} `;
-                                updatedStatus = true;
-                                
-                                // Log to audit log
-                                const auditPath = path.join(frameworkDir, "observability/audit_log.md");
-                                if (fs.existsSync(auditPath)) {
-                                    const logEntry = `\n- **[${new Date().toISOString()}]** ${agentName} status auto-escalated to BLOCKED due to 30m execution timeout.`;
-                                    fs.appendFileSync(auditPath, logEntry);
-                                }
-                                return parts.join("|");
-                            }
-                        }
-                    }
-                }
-                return line;
-            });
-            if (updatedStatus) {
-                fs.writeFileSync(statusPath, newLines.join("\n"));
+    const agentStatuses = readStatus();
+    let updatedStatus = false;
+    for (const [agentName, info] of Object.entries(agentStatuses)) {
+        const { state, lastUpdated } = info as { state: string; task: string; lastUpdated?: string };
+        if (state === "EXECUTING" && lastUpdated) {
+            const lastUpdatedTime = Date.parse(lastUpdated);
+            if (!isNaN(lastUpdatedTime) && Date.now() - lastUpdatedTime > 30 * 60 * 1000) {
+                UI.error(`⚠️  Agent ${agentName} has TIMED OUT (in EXECUTING state for >30m). Transitioning to BLOCKED.`);
+                agentStatuses[agentName] = { state: "BLOCKED", task: "Timeout occurred", lastUpdated: new Date().toISOString() };
+                updatedStatus = true;
             }
-        } catch (err) {
-            UI.error("Ajan zaman aşımı kontrolü sırasında hata oluştu.");
-            logger.debug("Agent timeout check failed", err);
         }
     }
+    if (updatedStatus) {
+        updateDocumentStore("status", agentStatuses);
+    }
 
     if (!fs.existsSync(messagesDir)) {
-        UI.success("Henüz işlenecek bir mesaj yok.");
+        UI.success("No messages to process yet.");
         return;
     }
 
@@ -90,23 +65,35 @@ export async function orchestrateCommand() {
                 try {
                     const parsed = JSON.parse(line);
                     const msg = HermesMessageSchema.parse(parsed);
+
+                    // Contract Validation
+                    if (msg.category === "ACTION" || msg.category === "DELEGATION") {
+                        try {
+                            const payload = JSON.parse(msg.content);
+                            TaskRequestSchema.parse(payload);
+                        } catch (e) {
+                            UI.error(`Invalid task contract payload: ${(e as Error).message}`);
+                            return; // Skip invalid message
+                        }
+                    }
+
                     if (msg.status === "PENDING") {
                         pendingMessages.push(msg);
                     }
                     allMsgs.push(msg);
                 } catch (e) {
-                    UI.error(`Geçersiz Hermes mesaj formatı atlandı: ${(e as Error).message}`);
+                    UI.error(`Skipping invalid Hermes message format: ${(e as Error).message}`);
                 }
             });
             fileMessagesMap[file] = allMsgs;
         } catch (err) {
-            UI.error(`${file} mesajı okunurken hata oluştu.`);
+            UI.error(`Error occurred while reading ${file}.`);
             logger.debug(`Failed to read message file ${file}`, err);
         }
     }
 
     if (pendingMessages.length === 0) {
-        UI.success("Tüm mesajlar işlenmiş, bekleyen görev yok.");
+        UI.success("All messages processed, no pending tasks.");
         return;
     }
 
@@ -119,7 +106,9 @@ export async function orchestrateCommand() {
         return Date.parse(a.timestamp) - Date.parse(b.timestamp);
     });
 
-    UI.intent("Multi-Agent Orkestrasyonu", `${pendingMessages.length} adet bekleyen görev ve işbirliği mesajı bulundu.`);
+    UI.intent("Multi-Agent Orchestration", `${pendingMessages.length} pending tasks and collaboration messages found.`);
+
+    const statusChanges: Record<string, { state: string; task: string }> = {};
 
     for (const msg of pendingMessages) {
         const { from, to, content, traceId, category, parentId } = msg;
@@ -133,24 +122,37 @@ export async function orchestrateCommand() {
         let targetState = "EXECUTING";
         if (category === "DELEGATION" || category === "SUBTASK") targetState = "BRIEFED";
 
-        transitionAgentState(to, targetState, content);
+        let taskDescription = content;
+        if (category === "DELEGATION" || category === "ACTION") {
+            try {
+                const payload = JSON.parse(content);
+                taskDescription = payload.task || content;
+            } catch {
+                // Ignore
+            }
+        }
+
+        statusChanges[to] = { state: targetState, task: taskDescription };
 
         if (targetState === "BRIEFED") {
-            UI.success(`${to} bilgilendirildi ve görevi devraldı.`);
-            transitionAgentState(to, "EXECUTING", content);
+            UI.success(`${to} informed and took over the task.`);
+            statusChanges[to] = { state: "EXECUTING", task: taskDescription };
         }
 
         if (isSubtask) {
-            UI.success(`Alt görev bağlantısı kuruldu (Parent: ${parentId || "Unknown"}).`);
+            UI.success(`Sub-task connection established (Parent: ${parentId || "Unknown"}).`);
         }
 
-        UI.success(`İşbirliği başlatıldı: ${from} -> ${to}`);
-        console.warn(chalk.gray(`  👉 Talimatlar: ${frameworkDir}/agents/${to.replace("@", "")}.md`));
+        UI.success(`Collaboration initiated: ${from} -> ${to}`);
+        console.warn(chalk.gray(`  👉 Instructions: ${frameworkDir}/agents/${to.replace("@", "")}.md`));
 
         // Mark message as processed
         msg.status = "PROCESSED";
     }
 
+    // Apply batch status updates
+    applyBatchStatusUpdates(statusChanges);
+
     // Write back updated message statuses to files and archive processed messages
     const archiveDir = path.join(messagesDir, "archive");
     
@@ -185,7 +187,7 @@ export async function orchestrateCommand() {
                 UI.success(`Archived ${processedMsgs.length} messages for @${agentName}`);
             }
         } catch (err) {
-            UI.error(`${file} mesaj dosyası güncellenirken ve arşivlenirken hata oluştu.`);
+            UI.error(`Error occurred while updating and archiving the message file ${file}.`);
             logger.debug(`Failed to update and archive message file ${file}`, err);
         }
     }
@@ -237,14 +239,14 @@ export async function sendMessage(args: {
                     await new Promise((resolve) => setTimeout(resolve, 500));
                 }
             } else {
-                UI.error(`Kilit alınırken beklenmedik hata oluştu: ${error.message || String(err)}`);
+                UI.error(`Unexpected error occurred while acquiring the lock: ${error.message || String(err)}`);
                 break;
             }
         }
     }
 
     if (!acquired) {
-        UI.error(`Mesaj iletilemedi: Hermes kilidi meşgul. (${args.from} -> ${args.to})`);
+        UI.error(`Message could not be delivered: Hermes lock is busy. (${args.from} -> ${args.to})`);
         return;
     }
 
@@ -259,16 +261,9 @@ export async function sendMessage(args: {
         
         fs.appendFileSync(messagePath, JSON.stringify(message) + "\n");
         
-        // Log collaboration to audit log
-        const auditPath = path.join(frameworkDir, "observability/audit_log.md");
-        if (fs.existsSync(auditPath)) {
-            const logEntry = `\n- **[${message.timestamp}]** ${args.from} -> ${args.to} | ${args.category} | Priority: ${message.priority} | Trace: ${args.traceId}`;
-            fs.appendFileSync(auditPath, logEntry);
-        }
-        
         return message;
     } catch (err) {
-        UI.error(`Mesaj iletilemedi: ${args.from} -> ${args.to}`);
+        UI.error(`Message could not be delivered: ${args.from} -> ${args.to}`);
         logger.debug(`Hermes sendMessage failed (${args.from} -> ${args.to})`, err);
     } finally {
         if (acquired && fs.existsSync(lockPath)) {
@@ -281,29 +276,8 @@ export async function sendMessage(args: {
     }
 }
 
-function transitionAgentState(agent: string, state: string, task: string) {
-    const frameworkDir = getFrameworkDir();
-    const statusPath = path.join(frameworkDir, "STATUS.md");
-    if (!fs.existsSync(statusPath)) return;
-    try {
-        const content = fs.readFileSync(statusPath, "utf8");
-        const lines = content.split("\n");
-        const targetName = agent.startsWith("@") ? agent : `@${agent}`;
-        const newLines = lines.map(line => {
-            if (line.includes(`| ${targetName} |`)) {
-                const parts = line.split("|");
-                if (parts.length >= 7) {
-                    parts[2] = ` ${state} `;
-                    parts[3] = ` ${task.slice(0, 25)}... `;
-                    parts[4] = ` ${new Date().toISOString()} `;
-                    return parts.join("|");
-                }
-            }
-            return line;
-        });
-        fs.writeFileSync(statusPath, newLines.join("\n"));
-    } catch (err) {
-        UI.error("STATUS.md güncellenemedi.");
-        logger.debug(`Failed to transition agent state for ${agent}`, err);
-    }
+
+function applyBatchStatusUpdates(changes: Record<string, { state: string; task: string }>) {
+    // Write to Document Store
+    updateDocumentStore("status", changes);
 }

package/src/cli/commands/plan.ts

@@ -0,0 +1,47 @@
+import fs from "fs";
+import path from "path";
+import { updateDocumentStore } from "../utils/memory.js";
+import { generateULID } from "../utils/time.js";
+import { UI } from "../utils/ui.js";
+
+/**
+ * Parses docs/user/roadmap.md and injects tasks into the Document Store.
+ */
+export function planCommand() {
+    const projectRoot = process.cwd();
+    const roadmapPath = path.join(projectRoot, "docs/user/roadmap.md");
+
+    if (!fs.existsSync(roadmapPath)) {
+        UI.error("Roadmap file not found at docs/user/roadmap.md");
+        return;
+    }
+
+    const content = fs.readFileSync(roadmapPath, "utf8");
+    const taskRegex = /- \[ \] (.*) \| (.*) \| (.*)/g;
+    let match;
+    let count = 0;
+
+    UI.intent("Planning Engine", "Parsing roadmap.md and injecting tasks into Document Store...");
+
+    while ((match = taskRegex.exec(content)) !== null) {
+        const description = match[1];
+        const priority = match[2];
+        const agent = match[3];
+        const traceId = generateULID();
+        
+        const taskData = {
+            traceId,
+            description: description.trim(),
+            priority: priority.trim(),
+            agent: agent.trim().replace("@", ""),
+            status: "PENDING",
+            createdAt: new Date().toISOString()
+        };
+
+        updateDocumentStore("task", taskData, traceId);
+        UI.success(`Injected task: ${taskData.description} (Agent: ${taskData.agent})`);
+        count++;
+    }
+
+    UI.success(`Plan complete: ${count} tasks injected into Document Store.`);
+}

package/src/cli/commands/status.ts

@@ -1,93 +1,45 @@
-import fs from "fs";
-import path from "path";
 import chalk from "chalk";
 
-import { getMemoryPath, getFrameworkDir } from "../utils/memory.js";
-import { logger } from "../../shared/logger.js";
+import { listTasks, readState, readStatus } from "../utils/memory.js";
 
 /**
  * Print the current framework status.
  */
 export function statusCommand() {
-    const memoryPath = getMemoryPath();
-    const frameworkDir = getFrameworkDir();
-    if (!fs.existsSync(memoryPath)) {
-        console.error(`❌ Error: ${frameworkDir}/PROJECT_MEMORY.md not found. Please run 'init' first.`);
+    const state = readState();
+    const tasks = listTasks();
+    const agentStatuses = readStatus();
+
+    if (!state) {
+        console.error("❌ Error: Memory state not found. Please run 'init' first.");
         return;
     }
 
-    const content = fs.readFileSync(memoryPath, "utf8");
-    
-    // Format 1: Table Style (Original)
-    const tableMatch = content.match(
-        /\| Active Phase \| Profile \| Last Update \| Active Trace ID \| Blockers \|\n\| :----------- \| :------ \| :---------- \| :-------------- \| :------- \|\n\| (.*?) \| (.*?) \| (.*?) \| (.*?) \| (.*?) \|/,
-    );
-
-    // Format 2: List Style (New)
-    const phaseMatch = content.match(/- Phase: (.*)/);
-    const traceIdMatch = content.match(/- Trace ID: (.*)/);
-    const profileMatch = content.match(/- Profile: (.*)/);
-    const updateMatch = content.match(/- Last Update: (.*)/);
-    const blockersMatch = content.match(/- Blockers: (.*)/);
-
     console.warn("\n📊 --- PROJECT STATUS ---");
-    
-    if (tableMatch) {
-        console.warn(`🔹 Phase: ${tableMatch[1].trim()}`);
-        console.warn(`🧭 Profile: ${tableMatch[2].trim()}`);
-        console.warn(`📅 Update: ${tableMatch[3].trim()}`);
-        console.warn(`🆔 Trace ID: ${tableMatch[4].trim()}`);
-        console.warn(`⛔ Blockers: ${tableMatch[5].trim()}`);
-    } else if (phaseMatch || traceIdMatch) {
-        if (phaseMatch) console.warn(`🔹 Phase: ${phaseMatch[1].trim()}`);
-        if (profileMatch) console.warn(`🧭 Profile: ${profileMatch[1].trim()}`);
-        if (updateMatch) console.warn(`📅 Update: ${updateMatch[1].trim()}`);
-        if (traceIdMatch) console.warn(`🆔 Trace ID: ${traceIdMatch[1].trim()}`);
-        if (blockersMatch) console.warn(`⛔ Blockers: ${blockersMatch[1].trim()}`);
+    console.warn(`🔹 Phase: ${state.phase}`);
+    console.warn(`🆔 Trace ID: ${state.traceId}`);
+    console.warn(`🤖 Manager: ${state.managerState}`);
+
+    // Read Agent Status from Document Store
+    console.warn("\n🎖️  Enderun Army Status (Agent States):");
+    for (const [agentName, info] of Object.entries(agentStatuses)) {
+        const { state, task } = info as { state: string; task: string };
+        let coloredState = state;
+        if (state === "READY") coloredState = chalk.green(state);
+        else if (state === "EXECUTING") coloredState = chalk.yellow(state);
+        else if (state === "BLOCKED" || state === "TIMEOUT") coloredState = chalk.red(state);
+        else if (state === "WAITING") coloredState = chalk.cyan(state);
         
-        // Check for manager state in list style
-        const managerState = content.match(/- @manager state: (.*)/);
-        if (managerState) console.warn(`🤖 Manager: ${managerState[1].trim()}`);
-    } else {
-        console.warn("⚠️  Status data could not be parsed in standard formats.");
+        console.warn(`  ${chalk.bold(agentName.padEnd(12))} : [${coloredState}] - ${task}`);
     }
 
-    // Army status check
-    const statusPath = path.join(frameworkDir, "STATUS.md");
-    if (fs.existsSync(statusPath)) {
-        try {
-            const statusContent = fs.readFileSync(statusPath, "utf8");
-            const lines = statusContent.split("\n");
-            const agentRows = lines.filter(line => line.includes("| @") && line.includes("|"));
-            if (agentRows.length > 0) {
-                console.warn("\n🎖️  Enderun Army Status (Agent States):");
-                agentRows.forEach(row => {
-                    const parts = row.split("|");
-                    if (parts.length >= 4) {
-                        const agentName = parts[1].trim();
-                        const state = parts[2].trim();
-                        const activeTask = parts[3].trim();
-                        
-                        let coloredState = state;
-                        if (state === "READY") coloredState = chalk.green(state);
-                        else if (state === "EXECUTING") coloredState = chalk.yellow(state);
-                        else if (state === "BLOCKED" || state === "TIMEOUT") coloredState = chalk.red(state);
-                        else if (state === "WAITING") coloredState = chalk.cyan(state);
-                        
-                        console.warn(`  ${chalk.bold(agentName.padEnd(12))} : [${coloredState}] - ${activeTask}`);
-                    }
-                });
-            }
-        } catch (err) {
-            logger.debug("Failed to read army status file", err);
-        }
-    }
-
-    const tasksSection = content.match(/## ACTIVE TASKS\n\n([\s\S]*?)(?=\n##|$)/);
-    if (tasksSection) {
+    if (tasks.length > 0) {
         console.warn("\n📋 Active Tasks:");
-        console.warn(tasksSection[1].trim());
+        tasks.forEach((t: { priority: string; status: string; description: string; agent: string }) => {
+            console.warn(`  - [${t.priority}] ${t.status}: ${t.description} (@${t.agent})`);
+        });
     }
 
     console.warn("\n-----------------------\n");
 }
+

package/src/cli/commands/trace.ts

@@ -1,46 +1,31 @@
-import fs from "fs";
-
-import { getMemoryPath, acquireMemoryLock, releaseMemoryLock } from "../utils/memory.js";
-import { generateULID } from "../utils/time.js";
-import { sanitizeTableCell, normalizeAgentName, normalizePriority, insertTaskRow } from "../utils/string.js";
+import { updateDocumentStore, generateULID, getFrameworkDir } from "../utils/memory.js";
+import { sanitizeInput, normalizeAgentName, normalizePriority } from "../utils/string.js";
 
 /**
  * Generate a new Trace ID and add it to project memory.
  */
 export function traceNewCommand(description: string, agent = "manager", priority = "P2"): string | void {
-    const memoryPath = getMemoryPath();
-    if (!fs.existsSync(memoryPath)) {
-        console.error("❌ Error: PROJECT_MEMORY.md not found.");
-        return;
-    }
-
     const traceId = generateULID();
-    const safeDescription = sanitizeTableCell(description);
+    const safeDescription = sanitizeInput(description);
     const safeAgent = normalizeAgentName(agent);
     const safePriority = normalizePriority(priority);
-    const newTask = `| ${traceId} | ${safeDescription} | @${safeAgent} | ${safePriority} | IN_PROGRESS |`;
-    const lockPath = `${memoryPath}.lock`;
-
-    if (!acquireMemoryLock(lockPath)) {
-        console.error("❌ Error: Memory lock timeout (5 retries).");
-        return;
-    }
+    const frameworkDir = getFrameworkDir();
+    // ...
 
-    try {
-        const content = fs.readFileSync(memoryPath, "utf8");
-        const updated = insertTaskRow(content, newTask);
-        if (!updated) {
-            console.error("❌ Error: ACTIVE TASKS table not found, task could not be added.");
-            return;
-        }
+    // --- Document Store Write ---
+    updateDocumentStore("task", {
+        traceId,
+        description: safeDescription,
+        agent: safeAgent,
+        priority: safePriority,
+        status: "IN_PROGRESS",
+        createdAt: new Date().toISOString()
+    }, traceId, frameworkDir);
+    // ----------------------------
 
-        fs.writeFileSync(memoryPath, updated);
-        console.warn(`
+    console.warn(`
 ✅ New Trace ID created: ${traceId}`);
-        console.warn(`📝 Added to task list: ${description}
+    console.warn(`📝 Added to task list: ${description}
 `);
-        return traceId;
-    } finally {
-        releaseMemoryLock(lockPath);
-    }
+    return traceId;
 }

package/src/cli/index.ts

@@ -2,6 +2,7 @@
 import fs from "fs";
 import { getPackageVersion, getValidatorPath } from "./utils/pkg.js";
 import { getMemoryPath, readActiveTraceId } from "./utils/memory.js";
+import { planCommand } from "./commands/plan.js";
 import { initCommand } from "./commands/init.js";
 import { checkCommand } from "./commands/check.js";
 import { statusCommand } from "./commands/status.js";
@@ -73,6 +74,9 @@ async function main() {
             checkCommand();
             break;
 
+        case "plan":
+            planCommand();
+            break;
         case "status":
             statusCommand();
             break;
@@ -299,8 +303,8 @@ Natural Language:
   sent to the @manager for orchestration.
 
 Example:
-  agent-enderun "Projemi denetle"
-  agent-enderun @backend "Login sayfasını oluştur"
+  agent-enderun "Audit my project"
+  agent-enderun @backend "Create the login page"
     `);
 }
 

package/src/cli/utils/compliance.ts

@@ -0,0 +1,66 @@
+import fs from "fs";
+import path from "path";
+import { logger } from "../../shared/logger.js";
+
+interface ComplianceIssue {
+    file: string;
+    line: number;
+    rule: string;
+}
+
+export function scanProjectCompliance(): ComplianceIssue[] {
+    const issues: ComplianceIssue[] = [];
+    const files = getAllFiles("src");
+
+    for (const file of files) {
+        const content = fs.readFileSync(file, "utf8");
+        const lines = content.split("\n");
+
+        lines.forEach((line, index) => {
+            const lineNum = index + 1;
+            const trimmedLine = line.trim();
+
+            // Skip comments and common doc string patterns
+            if (trimmedLine.startsWith("//") || 
+                trimmedLine.startsWith("*") || 
+                trimmedLine.startsWith("-") ||
+                trimmedLine.startsWith('"') || // Ignore strings
+                trimmedLine.startsWith('`')) return; // Ignore template literals
+
+            // Only check if it's NOT inside a UI/console message
+            const isUIMessage = line.includes("console.warn") || line.includes("console.error") || line.includes("UI.");
+
+            // 1. Console.log check - only if it's actual code
+            if (line.includes("console.log") && !isUIMessage) {
+                issues.push({ file, line: lineNum, rule: "No console.log allowed" });
+            }
+
+            // 2. Secret check (Regex for simple API keys) - skip UI messages
+            if (/API_KEY|SECRET|PASSWORD/i.test(line) && !file.includes(".env") && !isUIMessage) {
+                issues.push({ file, line: lineNum, rule: "Potential hardcoded secret detected" });
+            }
+
+            // 3. 'Any' type check
+            if (/\bany\b/.test(line) && !line.includes('":')) {
+                issues.push({ file, line: lineNum, rule: "Usage of 'any' type is forbidden" });
+            }
+        });
+
+    }
+    return issues;
+}
+
+function getAllFiles(dirPath: string, arrayOfFiles: string[] = []): string[] {
+    const files = fs.readdirSync(dirPath);
+
+    files.forEach((file) => {
+        const fullPath = path.join(dirPath, file);
+        if (fs.statSync(fullPath).isDirectory()) {
+            arrayOfFiles = getAllFiles(fullPath, arrayOfFiles);
+        } else if (fullPath.endsWith(".ts")) {
+            arrayOfFiles.push(fullPath);
+        }
+    });
+
+    return arrayOfFiles;
+}

package/src/cli/utils/fs.ts

@@ -2,8 +2,8 @@ import fs from "fs";
 import path from "path";
 import crypto from "crypto";
 
-import { remapFrameworkContent } from "../adapters.js"; // Import from the new adapters.js
-import type { AdapterId } from "../adapters.js";
+import { remapFrameworkContent } from "../adapters/index.js"; // Import from the new adapters.js
+import type { AdapterId } from "../adapters/index.js";
 import { ensureDir, writeTextFile, writeJsonFile } from "../../shared/fs.js";
 
 export { ensureDir, writeTextFile, writeJsonFile };