@strayl/agent 0.1.2 → 0.1.4

package/src/middleware/credential-scrubbing.ts

@@ -1,31 +0,0 @@
-import type { Middleware, ToolCall } from "../types.js";
-
-const CREDENTIAL_PATTERNS = [
-  /(?:token|api_key|apikey|secret|password|credential|auth|bearer)\s*[:=]\s*["']?([^\s"',}{]{8,})["']?/gi,
-  /(?:sk|pk|rk|ak)-[a-zA-Z0-9]{20,}/g, // Common API key prefixes
-  /ghp_[a-zA-Z0-9]{36}/g, // GitHub tokens
-  /gho_[a-zA-Z0-9]{36}/g,
-  /github_pat_[a-zA-Z0-9_]{82}/g,
-  /xox[bpas]-[a-zA-Z0-9-]+/g, // Slack tokens
-  /eyJ[a-zA-Z0-9_-]{20,}\.[a-zA-Z0-9_-]{20,}/g, // JWT-like tokens
-];
-
-function scrubCredentials(text: string): string {
-  let scrubbed = text;
-  for (const pattern of CREDENTIAL_PATTERNS) {
-    scrubbed = scrubbed.replace(pattern, (match) => {
-      // Keep first 4 chars for identification
-      const prefix = match.slice(0, 4);
-      return `${prefix}****[REDACTED]`;
-    });
-  }
-  return scrubbed;
-}
-
-export const credentialScrubbingMiddleware: Middleware = {
-  name: "credential-scrubbing",
-  wrapToolCall: async (_call: ToolCall, next: () => Promise<string>): Promise<string> => {
-    const result = await next();
-    return scrubCredentials(result);
-  },
-};

package/src/middleware/forbidden-packages.ts

@@ -1,107 +0,0 @@
-import type { Middleware, ToolCall } from "../types.js";
-
-const FORBIDDEN_PACKAGES: Record<string, string> = {
-  // Database drivers
-  pg: "Use @neondatabase/serverless instead",
-  mysql2: "Use @planetscale/database instead",
-  "better-sqlite3": "Use @libsql/client instead",
-  sqlite3: "Use @libsql/client instead",
-  mongodb: "Use mongoose with serverless adapter instead",
-
-  // ORMs
-  prisma: "Use drizzle-orm instead",
-  "@prisma/client": "Use drizzle-orm instead",
-  typeorm: "Use drizzle-orm instead",
-  sequelize: "Use drizzle-orm instead",
-  knex: "Use drizzle-orm instead",
-  "mikro-orm": "Use drizzle-orm instead",
-
-  // Server frameworks (not needed with TanStack Start)
-  express: "Not needed — use TanStack Start + Nitro",
-  fastify: "Not needed — use TanStack Start + Nitro",
-  koa: "Not needed — use TanStack Start + Nitro",
-  hapi: "Not needed — use TanStack Start + Nitro",
-  "nest.js": "Not needed — use TanStack Start + Nitro",
-  "@nestjs/core": "Not needed — use TanStack Start + Nitro",
-
-  // Native bindings
-  bcrypt: "Use bcryptjs instead (pure JS)",
-  sharp: "Use @cf-wasm/photon instead",
-  canvas: "Use @napi-rs/canvas instead",
-
-  // Build tools (don't change the build setup)
-  webpack: "Project uses Vite — don't add webpack",
-  parcel: "Project uses Vite — don't add parcel",
-  rollup: "Project uses Vite via TanStack Start",
-
-  // Outdated frameworks
-  gatsby: "Use Next.js, Remix, or TanStack Start instead",
-  "create-react-app": "Use Vite + React instead",
-
-  // Auth
-  passport: "Use better-auth instead",
-  "next-auth": "Use better-auth instead",
-
-  // CSS
-  "styled-components": "Use Tailwind CSS instead",
-  emotion: "Use Tailwind CSS instead",
-  "@emotion/react": "Use Tailwind CSS instead",
-  sass: "Use Tailwind CSS instead",
-  less: "Use Tailwind CSS instead",
-};
-
-function extractNpmPackages(command: string): string[] {
-  // Split chained commands
-  const parts = command.split(/&&|;|\|/).map(s => s.trim());
-  const packages: string[] = [];
-
-  for (const part of parts) {
-    // Match npm install/add patterns
-    const match = part.match(/(?:npm\s+(?:install|i|add)|yarn\s+add|pnpm\s+(?:add|install)|bun\s+(?:add|install))\s+(.+)/i);
-    if (!match) continue;
-
-    const args = match[1].split(/\s+/);
-    for (const arg of args) {
-      if (arg.startsWith("-")) continue; // Skip flags
-      // Strip version specifier: @scope/pkg@1.2.3 → @scope/pkg
-      const pkg = arg.replace(/@[^@/]+$/, "");
-      if (pkg) packages.push(pkg);
-    }
-  }
-
-  return packages;
-}
-
-export const forbiddenPackagesMiddleware: Middleware = {
-  name: "forbidden-packages",
-  wrapToolCall: async (call: ToolCall, next: () => Promise<string>): Promise<string> => {
-    if (call.function.name !== "exec") return next();
-
-    let args: { command?: string };
-    try {
-      args = JSON.parse(call.function.arguments);
-    } catch {
-      return next();
-    }
-
-    if (!args.command) return next();
-
-    const packages = extractNpmPackages(args.command);
-    const blocked: Array<{ pkg: string; reason: string }> = [];
-
-    for (const pkg of packages) {
-      if (FORBIDDEN_PACKAGES[pkg]) {
-        blocked.push({ pkg, reason: FORBIDDEN_PACKAGES[pkg] });
-      }
-    }
-
-    if (blocked.length > 0) {
-      const details = blocked.map(b => `- ${b.pkg}: ${b.reason}`).join("\n");
-      return JSON.stringify({
-        error: `Blocked packages detected:\n${details}\n\nUse the suggested alternatives instead.`,
-      });
-    }
-
-    return next();
-  },
-};

package/src/middleware/plan-mode.ts

@@ -1,143 +0,0 @@
-import type { Middleware, ToolCall, AgentMode, Message } from "../types.js";
-
-/**
- * Tools blocked in plan mode — anything that writes, executes, or modifies.
- */
-const PLAN_MODE_BLOCKED = new Set([
-  "exec",
-  "getLogs",
-  "write_file",
-  "edit_file",
-  "delete_file",
-  "move_file",
-  "show_preview",
-  "generate_image",
-  "requestEnvVar",
-  "enterPlanMode",
-  "create_database",
-  "run_database_query",
-  "prepare_database_migration",
-  "complete_database_migration",
-]);
-
-/**
- * Tools blocked in implementation/normal mode (planning-only tools).
- */
-const IMPL_MODE_BLOCKED = new Set([
-  "writePlan",
-]);
-
-/**
- * Creates middleware that filters tools based on current agent mode.
- */
-export function createPlanModeMiddleware(getMode: () => AgentMode): Middleware {
-  return {
-    name: "planModeFilter",
-    filterTools: (tools) => {
-      const mode = getMode();
-      if (mode === "plan") {
-        return tools.filter(t => !PLAN_MODE_BLOCKED.has(t.function.name));
-      }
-      if (mode === "implement") {
-        // Block planning tools + enterPlanMode
-        return tools.filter(t =>
-          !IMPL_MODE_BLOCKED.has(t.function.name) && t.function.name !== "enterPlanMode"
-        );
-      }
-      // Normal mode: block planning-only tools
-      return tools.filter(t => !IMPL_MODE_BLOCKED.has(t.function.name));
-    },
-    wrapToolCall: async (call: ToolCall, next: () => Promise<string>) => {
-      const mode = getMode();
-      const name = call.function.name;
-
-      if (mode === "plan" && PLAN_MODE_BLOCKED.has(name)) {
-        return JSON.stringify({
-          error: `Tool "${name}" is not available in Plan Mode. Use read-only tools only.`,
-        });
-      }
-      if (mode !== "plan" && IMPL_MODE_BLOCKED.has(name)) {
-        return JSON.stringify({
-          error: `Tool "${name}" is only available in Plan Mode.`,
-        });
-      }
-      if (mode === "implement" && name === "enterPlanMode") {
-        return JSON.stringify({
-          error: `Cannot enter plan mode during implementation. The plan is already confirmed.`,
-        });
-      }
-
-      return next();
-    },
-  };
-}
-
-/**
- * Performs context reset when transitioning from plan → implement.
- *
- * Finds the last writePlan tool call, extracts the plan content,
- * removes all planning messages, and injects the plan as a system message.
- *
- * Returns the confirmed plan content (for saving to disk), or null if not found.
- */
-export function resetContextForImplementation(messages: Message[]): {
-  newMessages: Message[];
-  planContent: string | null;
-} {
-  // Find the last writePlan tool call in assistant messages
-  let writePlanIdx = -1;
-  let planContent = "";
-  let planTitle = "";
-
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const msg = messages[i];
-    if (msg.role !== "assistant" || !msg.tool_calls) continue;
-
-    const writePlanCall = msg.tool_calls.find(tc => tc.function.name === "writePlan");
-    if (writePlanCall) {
-      writePlanIdx = i;
-      try {
-        const args = JSON.parse(writePlanCall.function.arguments);
-        planContent = args.content ?? "";
-        planTitle = args.title ?? "";
-      } catch {
-        // Malformed args
-      }
-      break;
-    }
-  }
-
-  if (writePlanIdx === -1 || !planContent) {
-    return { newMessages: messages, planContent: null };
-  }
-
-  // Find the matching tool result message to skip it too
-  const writePlanCall = messages[writePlanIdx].tool_calls!.find(tc => tc.function.name === "writePlan")!;
-  let skipUntilIdx = writePlanIdx + 1;
-  for (let j = writePlanIdx + 1; j < messages.length; j++) {
-    if (messages[j].role === "tool" && messages[j].tool_call_id === writePlanCall.id) {
-      skipUntilIdx = j + 1;
-      break;
-    }
-  }
-
-  // Keep system messages and any messages after the writePlan call+result
-  const systemMsgs = messages.filter(m => m.role === "system");
-  const preservedMsgs = messages.slice(skipUntilIdx);
-
-  // Inject confirmed plan as system message
-  const planSystemMsg: Message = {
-    role: "user",
-    content: `[Plan Context Reset — IMPLEMENTATION MODE]\n\nThe user has reviewed and confirmed the following plan. Do NOT repeat, summarize, or rewrite this plan. Proceed directly to implementing it step by step.\n\n## Confirmed Plan: ${planTitle}\n\n${planContent}\n\n---\nIMPORTANT: The plan above is confirmed. Start implementing immediately. Do NOT output the plan again.`,
-  };
-
-  const ackMsg: Message = {
-    role: "assistant",
-    content: "Plan confirmed. I'll start implementing it now.",
-  };
-
-  return {
-    newMessages: [...systemMsgs, planSystemMsg, ackMsg, ...preservedMsgs],
-    planContent,
-  };
-}

package/src/middleware/prompt-caching.ts

@@ -1,21 +0,0 @@
-import type { Middleware, Message } from "../types.js";
-
-export function createPromptCachingMiddleware(modelName: string): Middleware {
-  const isAnthropic = modelName.includes("anthropic/") || modelName.includes("claude");
-
-  return {
-    name: "prompt-caching",
-    beforeModel: (messages: Message[]): Message[] => {
-      if (!isAnthropic) return messages;
-
-      return messages.map((msg, i) => {
-        if (msg.role !== "system") return msg;
-        // Inject cache_control for Anthropic system messages
-        return {
-          ...msg,
-          cache_control: { type: "ephemeral" },
-        } as Message & { cache_control: { type: string } };
-      });
-    },
-  };
-}

package/src/middleware/tool-compression.ts

@@ -1,25 +0,0 @@
-import type { Middleware, Message } from "../types.js";
-
-// Claude Code approach: fully clear old tool outputs, keep recent ones intact.
-// Tool call messages (assistant side) stay visible so the agent remembers
-// *what* it did, but old raw outputs are replaced with a short placeholder.
-// Reference: https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents
-
-const KEEP_RECENT = 8;
-
-export const toolCompressionMiddleware: Middleware = {
-  name: "tool-compression",
-  beforeModel: (messages: Message[]): Message[] => {
-    const boundary = Math.max(0, messages.length - KEEP_RECENT);
-
-    return messages.map((msg, i) => {
-      if (i >= boundary) return msg;
-      if (msg.role !== "tool") return msg;
-      if (typeof msg.content !== "string") return msg;
-
-      // Fully mask old tool outputs — agent remembers the call but not the raw output
-      const name = msg.name ?? "tool";
-      return { ...msg, content: `[${name} output cleared]` };
-    });
-  },
-};

package/src/middleware/tool-filter.ts

@@ -1,13 +0,0 @@
-import type { Middleware } from "../types.js";
-import type OpenAI from "openai";
-
-export function createToolFilterMiddleware(blockedTools: string[]): Middleware {
-  const blocked = new Set(blockedTools);
-  return {
-    name: "tool-filter",
-    filterTools: (tools: OpenAI.ChatCompletionTool[]): OpenAI.ChatCompletionTool[] => {
-      if (blocked.size === 0) return tools;
-      return tools.filter(t => t.type === "function" && !blocked.has(t.function.name));
-    },
-  };
-}

package/src/prompts/implementation-mode.md

@@ -1,16 +0,0 @@
-# Implementation Mode
-
-You are in IMPLEMENTATION MODE. A plan has been confirmed — implement it now.
-
-## Mandatory First Actions
-1. Review the confirmed plan (it's in the conversation context)
-2. Create todos from the plan steps using write_todos
-3. Execute each step in order
-
-## Rules
-- Do NOT re-plan or second-guess the plan
-- Do NOT loop on errors more than twice — if something fails twice, move on and note the issue
-- Trust the plan — it was reviewed and confirmed by the user
-- Focus on: creating files, installing packages, writing code, running commands
-- Update todo status as you work (in_progress → completed)
-- Clear all todos when done: write_todos({ todos: [] })

package/src/prompts/plan-mode.md

@@ -1,51 +0,0 @@
-# Plan Mode
-
-You are in PLAN MODE. Your job is to create a detailed implementation plan before any code is written.
-
-## Allowed Actions
-- Read files (read_file, ls, grep, glob)
-- Search the web (web_search, web_fetch)
-- Delegate research to sub-agents (task)
-- Interview the user (interviewUser)
-- Submit a plan (writePlan)
-
-## Blocked Actions
-You CANNOT write, edit, execute, or delete files in this mode. Focus entirely on research and planning.
-
-## Workflow
-1. **Read relevant skills** — Check /skills/ for any matching skill files
-2. **Explore the codebase** — Understand existing code, patterns, and conventions
-3. **Research unknowns** — Use web search for unfamiliar APIs, libraries, or patterns
-4. **Interview the user** (optional) — Ask clarifying questions if requirements are unclear
-5. **Submit the plan** — Use writePlan with a structured plan
-
-## Plan Format
-Your plan MUST include:
-
-### Overview
-Brief description of what will be built and why.
-
-### Dependencies
-New packages to install (with justification).
-
-### Database Schema (if applicable)
-Table definitions, relations, indexes.
-
-### Step-by-Step Implementation
-Numbered steps with:
-- Exact file paths to create/modify
-- What each file should contain (describe the logic, not pseudocode)
-- Dependencies between steps
-
-### UI/UX (if applicable)
-Component hierarchy, user flows, responsive behavior.
-
-### Verification
-How to test that the implementation works.
-
-## Quality Guidelines
-- 8-20 steps for full features
-- Be SPECIFIC — "Create src/routes/settings.tsx with a form for updating user preferences" not "Create settings page"
-- Reference existing patterns in the codebase
-- Consider edge cases, error handling, and loading states
-- Note any decisions that need user confirmation

package/src/prompts/system.ts

@@ -1,173 +0,0 @@
-import { buildSkillsPrompt, type Skill } from "../skills/loader.js";
-import type { AgentMode } from "../types.js";
-
-export function buildSystemPrompt(config: {
-  workDir: string;
-  skills: Skill[];
-  systemPromptExtra?: string;
-  mode?: AgentMode;
-}): string {
-  const parts = [AGENT_INSTRUCTIONS];
-
-  const skillsPrompt = buildSkillsPrompt(config.skills);
-  if (skillsPrompt) parts.push(skillsPrompt);
-
-  // Append mode-specific prompt
-  const mode = config.mode ?? "normal";
-  if (mode === "plan") parts.push(PLAN_MODE_SYSTEM_PROMPT);
-  if (mode === "implement") parts.push(IMPLEMENTATION_MODE_PROMPT);
-
-  if (config.systemPromptExtra) parts.push(config.systemPromptExtra);
-
-  return parts.join("\n\n");
-}
-
-const AGENT_INSTRUCTIONS = `You are Strayl, an expert software engineer agent. You help users build, debug, and improve web applications.
-
-## Working Directory
-- ALWAYS use relative paths (never absolute paths like /home/daytona/...)
-- The project root is your current working directory
-- All file operations are relative to the project root
-
-## Hard Rules
-- Do NOT run \`npm create\`, \`npx create-*\`, or any scaffolding commands
-- Do NOT create .env files — environment variables are managed by the platform
-- Do NOT run \`npm audit fix\` — it breaks dependencies
-- Do NOT change build tool configuration unless explicitly asked
-- Do NOT add ESLint, Prettier, or other linting tools unless asked
-- Do NOT import Node.js built-in modules (node:fs, node:child_process, node:net, node:os) in application code
-- Do NOT use eval() or new Function() — blocked by the sandbox
-- Forbidden packages are blocked automatically — use suggested alternatives
-- Always use --yes or -y flags for non-interactive CLI commands
-
-## Stack Reference
-- **React 19.x**: use(), useActionState(), ref as prop (not forwardRef)
-- **TanStack Start 1.x**: createServerFn({ method: 'POST' }).inputValidator((d: unknown) => schema.parse(d)).handler(...)
-- **TanStack Router 1.x**: createFileRoute(), $param, __root.tsx
-- **Vite 7.x**: tanstackStart() plugin in vite.config.ts (NOT app.config.ts)
-- **Tailwind CSS 4.x**: Config in src/styles.css via @theme {} — NO tailwind.config.js
-- **shadcn/ui**: Latest, OKLCH colors, @custom-variant dark
-
-## Before Writing Code
-1. Understand the project: read package.json, src/routes/__root.tsx
-2. Check what exists: glob src/components/**, check package.json
-3. Read the relevant skill before implementing (if skills are available)
-4. NEVER delegate skill reading to sub-agents — they can't access /skills/
-
-## Protected Files
-Use edit_file (NOT write_file) for: package.json, tsconfig.json, vite.config.ts, src/styles.css, src/routes/__root.tsx, src/lib/i18n.ts
-
-## File Operations
-- 3+ edits to the same file → use write_file with the complete content instead
-- write_file is ATOMIC — don't re-read after writing, don't delete/recreate
-- Shell commands: always use --yes or -y flags
-
-## Background Commands
-When running long commands, use background: true and wait:
-- npm install → wait 20-30s
-- npx shadcn add → wait 20-40s
-- npm run build → wait 15-45s
-- npm run dev → wait 5-10s, then show_preview
-
-## Sub-agents
-Use sub-agents aggressively for parallel speedup:
-- **code-explorer**: Before modifying unfamiliar code, explore it first
-- **web-researcher**: Before installing new packages, research compatibility
-- **general-purpose**: Combined exploration + research
-- When debugging: spawn BOTH code-explorer AND web-researcher in PARALLEL
-- Always parallelize — spawn multiple sub-agents simultaneously when possible
-
-## Todos
-Create todos when: 3+ files involved, installing packages + writing code, sequential dependencies.
-Do NOT create todos for: single file edits, research only, single commands.
-Granularity: ONE completable action per todo.
-Lifecycle: create todos → set in_progress → completed → write_todos({ todos: [] }) when all done.`;
-
-const PLAN_MODE_SYSTEM_PROMPT = `
-
-## PLAN MODE — YOU CAN ONLY DO 3 THINGS
-
-You are in PLAN MODE. You have exactly 3 jobs:
-1. **Research** — read and explore the codebase AND read relevant skills to understand how to build
-2. **Interview** — ask the user clarifying questions if requirements are ambiguous
-3. **Write the plan** — call \`writePlan\` to submit a structured plan for user approval
-
-That's it. You CANNOT implement anything. You CANNOT scaffold projects, install packages, create files, run commands, or make any changes. You are READ-ONLY.
-
-### CRITICAL: Plans go in writePlan, NOT in chat text
-Do NOT write the plan as a text message. The plan MUST be submitted via the \`writePlan\` tool so the user can review and confirm it in the UI. If you output a plan as text, the user cannot confirm or reject it.
-
-### ALLOWED TOOLS
-- \`read_file\`, \`ls\`, \`grep\`, \`glob\` — explore existing code
-- \`task\` — delegate to code-explorer or web-researcher sub-agents for broad searches
-- \`askUser\` — ask clarifying questions (only if genuinely ambiguous, 2-4 max)
-- \`writePlan\` — submit the final plan (THE ONLY WAY to deliver your plan)
-- \`web_search\`, \`web_fetch\` — research docs and APIs
-
-Everything else is BLOCKED and will return an error. Do NOT retry failed tool calls.
-
-### WORKFLOW
-1. **Read relevant skills FIRST** — before anything else, identify which skills apply and read their SKILL.md files. These contain mandatory steps, package choices, and patterns you MUST follow. **IMPORTANT: Read skill files YOURSELF using read_file — NEVER delegate skill reading to subagents.**
-2. **Explore existing codebase** — read package.json, route structure, existing components. Delegate to code-explorer for broad scans.
-3. **Research unknowns** — use task(web-researcher) for APIs, libraries, or patterns you're unsure about.
-4. **Interview (optional)** — only if genuinely ambiguous requirements (2-4 questions max).
-5. **writePlan** — submit the detailed plan.
-
-Keep chat messages short — brief status updates only ("Reading skills...", "Exploring the codebase...", "Writing the plan."). The plan content goes in writePlan, not in chat.
-
-### PLAN FORMAT (inside writePlan) — THIS IS CRITICAL
-
-Your plan will be executed by the agent AFTER the user confirms it. The agent following the plan may be using a weaker model. Therefore, the plan must be **extremely detailed and specific** — like a recipe that anyone can follow.
-
-**Structure:**
-1. **Overview** (2-3 sentences) — what we're building, key tech choices
-2. **Dependencies** — exact packages to install with versions if critical
-3. **Database Schema** — full table definitions with columns, types, relations, indices
-4. **Step-by-step Implementation** — each step must include:
-   - Exact file paths to create or modify
-   - What the file should contain (describe the logic, exports, key code patterns)
-   - Which skill instructions to follow for that step
-   - Dependencies on previous steps
-5. **UI/UX Details** — component hierarchy, layout description, key interactions
-6. **Verification** — how to confirm each major milestone works
-
-**Quality standards:**
-- Each step should be ONE focused action (create a file, install a package, configure something)
-- Reference specific files: "Create \`src/db/schema.ts\` with tables: users, tasks, projects..."
-- Reference skill instructions: "Follow the authentication skill for Better Auth setup"
-- Include key decisions: WHY this approach over alternatives
-- 8-20 steps is normal for a full feature. Do NOT artificially compress into 3-5 vague steps
-
-### HARD RULES
-- You CANNOT exit plan mode. Only the user can confirm/reject.
-- Do NOT implement anything — no scaffolding, no npm install, no file creation.
-- Do NOT loop — if a tool errors, move on.
-- ALWAYS read relevant skill files before writing the plan.
-- Do NOT write shallow plans. Take the time to research thoroughly and write detailed steps.`;
-
-const IMPLEMENTATION_MODE_PROMPT = `
-
-## IMPLEMENTATION MODE — PLAN CONFIRMED
-
-A plan has been confirmed by the user and is ready for execution. Your ONLY job now is to implement this plan.
-
-### YOUR FIRST ACTIONS (MANDATORY)
-1. The confirmed plan content is included in context above — review it now
-2. Create todos from the plan steps using \`write_todos\`
-3. Begin executing the plan step by step
-
-### HARD RULES
-- Do NOT write a plan as text in chat — the plan already exists as a confirmed file
-- Do NOT call \`enterPlanMode\` — you are past the planning phase
-- Do NOT call \`askUser\` or \`writePlan\` — planning is done
-- Do NOT re-research or re-plan — trust the confirmed plan and execute it
-- If you encounter an issue during implementation, fix it and continue — do NOT restart planning
-- Focus on implementation: create files, install packages, write code, run commands
-
-### WORKFLOW
-1. Review the confirmed plan in context above
-2. Create todos from plan steps
-3. For each step: mark todo in_progress → execute → mark completed
-4. After all steps: verify the build works, show preview if applicable`;
-
-export { PLAN_MODE_SYSTEM_PROMPT, IMPLEMENTATION_MODE_PROMPT };

package/src/skills/loader.ts

@@ -1,53 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-
-export interface Skill {
-  name: string;
-  description: string;
-}
-
-export async function loadSkills(skillsDir: string): Promise<Skill[]> {
-  const skills: Skill[] = [];
-
-  try {
-    const entries = await fs.readdir(skillsDir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-
-      const skillMdPath = path.join(skillsDir, entry.name, "SKILL.md");
-      try {
-        const content = await fs.readFile(skillMdPath, "utf-8");
-        // Extract description from first paragraph or heading
-        const lines = content.split("\n").filter(l => l.trim());
-        const description = lines[0]?.replace(/^#+\s*/, "") ?? entry.name;
-        skills.push({ name: entry.name, description });
-      } catch {
-        // No SKILL.md — skip
-      }
-    }
-  } catch {
-    // Skills dir doesn't exist — that's fine
-  }
-
-  return skills;
-}
-
-export function buildSkillsPrompt(skills: Skill[]): string {
-  if (skills.length === 0) return "";
-
-  const lines = [
-    "\n## Skills",
-    "You have access to the following skills. Before implementing a feature that matches a skill, ALWAYS read the skill file first.",
-    "",
-  ];
-
-  for (const skill of skills) {
-    lines.push(`- **${skill.name}**: ${skill.description}`);
-    lines.push(`  Read: \`/skills/${skill.name}/SKILL.md\``);
-  }
-
-  lines.push("");
-  lines.push("Skills contain mandatory workflows, not optional suggestions. Follow them exactly.");
-
-  return lines.join("\n");
-}