@ryodeushii/ai-product-team-agents 0.0.6 → 0.0.7

package/README.md

@@ -132,71 +132,69 @@ Models are defined in `models.yml`. Three tiers:
 - **executing** — roles that search and run tasks (Haiku)
 - **creative** — roles that write copy and design UI (Sonnet, swap to Gemini etc.)
 
+### Presets
+
+Switch all tiers at once with a named preset:
+
+```yaml
+preset: google   # gemini 2.5 pro for thinking/creative, flash for executing
+```
+
+| Preset | thinking | executing | creative |
+|---|---|---|---|
+| `balanced` | claude-sonnet-4-6 | claude-haiku-4-5 | claude-sonnet-4-6 |
+| `fast` | claude-haiku-4-5 | claude-haiku-4-5 | claude-haiku-4-5 |
+| `google` | gemini-2.5-pro | gemini-2.5-flash | gemini-2.5-pro |
+| `openai` | gpt-4.1 | gpt-4.1-mini | gpt-4.1 |
+
 ### Per-project overrides
 
-In your project's `.agents.yml`, override any tier or individual role:
+Mix a preset with per-role overrides:
+
+```yaml
+preset: google
+models:
+  roles:
+    explorer: local/qwen2.5-coder   # override one role on top of preset
+```
+
+Or override individual tiers without a preset:
 
 ```yaml
 models:
   defaults:
-    thinking:  anthropic/claude-sonnet-4-6          # all thinking-tier roles
-    executing: anthropic/claude-haiku-4-5-20251001  # all executing-tier roles
-    creative:  google/gemini-2.5-pro                # all creative-tier roles
+    creative: google/gemini-2.5-pro  # swap just the creative tier
   roles:
-    architect: openai/gpt-4.1          # one specific role
-    explorer:  local/qwen2.5-coder     # local model via OpenCode
+    architect: openai/gpt-4.1        # one specific role
 ```
 
 Resolution order (highest to lowest priority):
 1. Project role override
 2. Project tier default
-3. Framework role default
-4. Framework tier default
-
-Models are resolved **dynamically** — changes to `models.yml` or `.agents.yml` take effect immediately without re-running setup.
+3. Preset tier
+4. Framework role default
+5. Framework tier default
 
-### MCP server
+### Auto-update on startup (Claude Code)
 
-The framework ships an MCP server that exposes a `resolve_model(role, project_root)` tool for dynamic model resolution.
+The setup script writes a `SessionStart` hook into `.claude/settings.json` that re-runs `--update` every time a Claude Code session starts. This means changes to `.agents.yml` (preset, model overrides) take effect automatically the next time you open Claude Code — no manual `--update` needed.
 
-Add to your Claude Code MCP config (`~/.claude/mcp.json` or project-level `.mcp.json`):
+The hook looks like this in `.claude/settings.json`:
 
 ```json
 {
-  "mcpServers": {
-    "agents-framework": {
-      "command": "bunx",
-      "args": ["--package=@ryodeushii/ai-product-team-agents", "agents-mcp"]
-    }
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "startup",
+        "hooks": [{ "type": "command", "command": "bunx --bun @ryodeushii/ai-product-team-agents --update 2>/dev/null; true" }]
+      }
+    ]
   }
 }
 ```
 
-Or with npx:
-
-```json
-{
-  "mcpServers": {
-    "agents-framework": {
-      "command": "npx",
-      "args": ["-y", "-p", "@ryodeushii/ai-product-team-agents", "agents-mcp"]
-    }
-  }
-}
-```
-
-**OpenCode** — add to `opencode.json` (project root or `~/.config/opencode/opencode.json`):
-
-```json
-{
-  "mcp": {
-    "agents-framework": {
-      "type": "local",
-      "command": ["npx", "-y", "-p", "@ryodeushii/ai-product-team-agents", "agents-mcp"]
-    }
-  }
-}
-```
+**OpenCode** uses a local plugin instead. The setup script writes `.opencode/plugins/agents-auto-update.ts`, which hooks into `session.created` and runs `--update` automatically at the start of every OpenCode session.
 
 ---
 

package/models.yml

@@ -16,3 +16,28 @@ roles:
   seo: anthropic/claude-haiku-4-5-20251001
   designer: anthropic/claude-sonnet-4-6
   marketing: anthropic/claude-sonnet-4-6
+
+presets:
+  # Anthropic — balanced quality/cost (framework default)
+  balanced:
+    thinking: anthropic/claude-sonnet-4-6
+    executing: anthropic/claude-haiku-4-5-20251001
+    creative: anthropic/claude-sonnet-4-6
+
+  # Anthropic — all fast/cheap
+  fast:
+    thinking: anthropic/claude-haiku-4-5-20251001
+    executing: anthropic/claude-haiku-4-5-20251001
+    creative: anthropic/claude-haiku-4-5-20251001
+
+  # Google Gemini
+  google:
+    thinking: google/gemini-2.5-pro
+    executing: google/gemini-2.5-flash
+    creative: google/gemini-2.5-pro
+
+  # OpenAI
+  openai:
+    thinking: openai/gpt-4.1
+    executing: openai/gpt-4.1-mini
+    creative: openai/gpt-4.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@ryodeushii/ai-product-team-agents",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "repository": {
     "url": "https://github.com/ryodeushii/ai-product-team-agents"
   },
@@ -16,13 +16,11 @@
     "src/config/schema.ts",
     "src/models/resolver.ts",
     "src/models/types.ts",
-    "src/mcp/server.ts",
     "src/setup/index.ts"
   ],
   "bin": {
     "ai-product-team-agents": "./src/setup/index.ts",
-    "agents-setup": "./src/setup/index.ts",
-    "agents-mcp": "./src/mcp/server.ts"
+    "agents-setup": "./src/setup/index.ts"
   },
   "scripts": {
     "build": "tsc",
@@ -38,7 +36,6 @@
     "typescript": "^5.9.3"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.27.1",
     "js-yaml": "^4.1.1",
     "zod": "^4.3.6"
   }

package/src/config/schema.ts

@@ -14,6 +14,7 @@ export const frameworkConfigSchema = z.object({
     creative: z.string(),
   }),
   roles: z.record(z.string(), z.string()).default({}),
+  presets: z.record(z.string(), tierOverrideSchema).default({}),
 });
 
 export const projectConfigSchema = z.object({
@@ -25,6 +26,7 @@ export const projectConfigSchema = z.object({
     .enum(["supervised", "checkpoint", "autonomous"])
     .default("checkpoint"),
   deploy: z.string().optional(),
+  preset: z.string().optional(),
   models: z
     .object({
       defaults: tierOverrideSchema.optional(),

package/src/models/resolver.ts

@@ -7,6 +7,7 @@ export function resolveModel(
   role: Role,
   framework: ModelsConfig,
   project: ProjectModelsOverride = {},
+  preset?: string,
 ): string {
   // 1. project role override
   if (project.roles?.[role] !== undefined) return project.roles[role]!;
@@ -15,10 +16,18 @@ export function resolveModel(
   const tier = ROLE_TIERS[role];
   if (project.defaults?.[tier] !== undefined) return project.defaults[tier]!;
 
-  // 3. framework role default
+  // 3. preset tier
+  if (preset !== undefined) {
+    const presetConfig = framework.presets[preset];
+    if (presetConfig === undefined)
+      throw new Error(`Unknown preset "${preset}"`);
+    if (presetConfig[tier] !== undefined) return presetConfig[tier]!;
+  }
+
+  // 4. framework role default
   if (framework.roles[role] !== undefined) return framework.roles[role]!;
 
-  // 4. framework tier default
+  // 5. framework tier default
   const result = framework.defaults[tier];
   if (result === undefined)
     throw new Error(`No model configured for tier "${tier}"`);

package/src/models/types.ts

@@ -36,6 +36,7 @@ export const ROLE_TIERS: Record<Role, Tier> = {
 export interface ModelsConfig {
   defaults: Record<Tier, string>;
   roles: Partial<Record<Role, string>>;
+  presets: Record<string, Partial<Record<Tier, string>>>;
 }
 
 export interface ProjectModelsOverride {

package/src/setup/index.ts

@@ -2,15 +2,18 @@
 // src/setup/index.ts
 
 import { fileURLToPath } from "node:url";
-import {
-  lstat,
-  mkdir,
-  readFile,
-  rm,
-  symlink,
-  writeFile,
-} from "fs/promises";
+import { lstat, mkdir, readFile, readdir, rm, writeFile } from "fs/promises";
 import { join } from "path";
+import { loadFrameworkConfig, loadProjectConfig } from "../config/loader";
+import { resolveModel } from "../models/resolver";
+import { ROLES } from "../models/types";
+import type { Role } from "../models/types";
+
+// The SessionStart hook command written into .claude/settings.json.
+// Runs --update on every Claude Code session start so model overrides
+// from .agents.yml are always applied without manual intervention.
+const HOOK_COMMAND =
+  "bunx --bun @ryodeushii/ai-product-team-agents --update 2>/dev/null; true";
 
 interface SetupOptions {
   projectName: string;
@@ -40,20 +43,23 @@ export async function setupProject(
     await writeFile(dest, content, "utf-8");
   };
 
-  const link = async (target: string, linkPath: string) => {
-    try {
-      await lstat(linkPath);
-      if (!overwrite) return;
-      await rm(linkPath, { recursive: true, force: true });
-    } catch (err) {
-      if ((err as NodeJS.ErrnoException).code !== "ENOENT") throw err;
-    }
-    await mkdir(join(linkPath, ".."), { recursive: true });
-    await symlink(target, linkPath);
-  };
-
-  // CLAUDE.md — one-liner import
-  await write(join(projectRoot, "CLAUDE.md"), "@./AGENTS.md\n");
+  // CLAUDE.md — append import if not already present
+  const claudeMdPath = join(projectRoot, "CLAUDE.md");
+  const claudeImport = "@./AGENTS.md";
+  const existingClaude = await readFile(claudeMdPath, "utf-8").catch(
+    (err: NodeJS.ErrnoException) =>
+      err.code === "ENOENT" ? null : Promise.reject(err),
+  );
+  if (existingClaude === null) {
+    await writeFile(claudeMdPath, `${claudeImport}\n`, "utf-8");
+  } else if (!existingClaude.includes(claudeImport)) {
+    const sep = existingClaude.endsWith("\n") ? "" : "\n";
+    await writeFile(
+      claudeMdPath,
+      `${existingClaude}${sep}${claudeImport}\n`,
+      "utf-8",
+    );
+  }
 
   // AGENTS.md — fill template
   let agentsTpl: string;
@@ -88,23 +94,161 @@ export async function setupProject(
   agentsYml = agentsYml.replaceAll("{{project_name}}", projectName);
   await write(join(projectRoot, ".agents.yml"), agentsYml);
 
-  // symlink roles into .claude/agents and .opencode/agents
+  // copy role files into .claude/agents and .opencode/agents,
+  // injecting resolved model: into frontmatter for each role
   const rolesPath = join(frameworkRoot, "roles");
-  await link(rolesPath, join(projectRoot, ".claude/agents"));
-  await link(rolesPath, join(projectRoot, ".opencode/agents"));
+  const [framework, project] = await Promise.all([
+    loadFrameworkConfig(frameworkRoot),
+    loadProjectConfig(projectRoot),
+  ]);
+
+  const roleFiles = (await readdir(rolesPath)).filter((f) => f.endsWith(".md"));
+  for (const dest of [
+    join(projectRoot, ".claude/agents"),
+    join(projectRoot, ".opencode/agents"),
+  ]) {
+    await mkdir(dest, { recursive: true });
+    for (const file of roleFiles) {
+      const destFile = join(dest, file);
+      const exists = await lstat(destFile).then(
+        () => true,
+        () => false,
+      );
+      if (exists && !overwrite) continue;
+
+      let content = await readFile(join(rolesPath, file), "utf-8");
+      const roleName = file.replace(/\.md$/, "") as Role;
+      if (ROLES.includes(roleName)) {
+        const model = resolveModel(
+          roleName,
+          framework,
+          project.models ?? {},
+          project.preset,
+        );
+        // inject or replace model: in frontmatter
+        if (content.startsWith("---")) {
+          content = content.replace(
+            /^(---\n)([\s\S]*?)(---)/,
+            (_, open, body, close) => {
+              const cleaned = body.replace(/^model:.*\n?/m, "");
+              return `${open}${cleaned}model: ${model}\n${close}`;
+            },
+          );
+        }
+      }
+      await writeFile(destFile, content, "utf-8");
+    }
+  }
+
+  // .claude/settings.json — add SessionStart hook for auto-update
+  await installClaudeHook(join(projectRoot, ".claude/settings.json"));
+
+  // .opencode/plugins/agents-auto-update.ts — OpenCode session.created hook
+  await installOpenCodePlugin(projectRoot, frameworkRoot);
+}
+
+async function installOpenCodePlugin(
+  projectRoot: string,
+  frameworkRoot: string,
+): Promise<void> {
+  const pluginDir = join(projectRoot, ".opencode/plugins");
+  const pluginDest = join(pluginDir, "agents-auto-update.ts");
+  await mkdir(pluginDir, { recursive: true });
+  const src = await readFile(
+    join(frameworkRoot, "templates/opencode-plugin.ts"),
+    "utf-8",
+  );
+  await writeFile(pluginDest, src, "utf-8");
+}
+
+async function installClaudeHook(settingsPath: string): Promise<void> {
+  const raw = await readFile(settingsPath, "utf-8").catch(
+    (err: NodeJS.ErrnoException) =>
+      err.code === "ENOENT" ? null : Promise.reject(err),
+  );
+  const settings = raw ? JSON.parse(raw) : {};
+
+  // idempotent: don't add duplicate hook
+  const existing: { matcher: string; hooks: { type: string; command: string }[] }[] =
+    settings.hooks?.SessionStart ?? [];
+  const alreadyInstalled = existing.some((entry) =>
+    entry.hooks?.some((h) => h.command === HOOK_COMMAND),
+  );
+  if (alreadyInstalled) return;
+
+  settings.hooks ??= {};
+  settings.hooks.SessionStart ??= [];
+  settings.hooks.SessionStart.push({
+    matcher: "startup",
+    hooks: [{ type: "command", command: HOOK_COMMAND }],
+  });
+
+  await mkdir(settingsPath.replace(/\/[^/]+$/, ""), { recursive: true });
+  await writeFile(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+}
+
+async function removeClaudeHook(settingsPath: string): Promise<void> {
+  const raw = await readFile(settingsPath, "utf-8").catch(
+    (err: NodeJS.ErrnoException) =>
+      err.code === "ENOENT" ? null : Promise.reject(err),
+  );
+  if (!raw) return;
+
+  const settings = JSON.parse(raw);
+  if (!settings.hooks?.SessionStart) return;
+
+  settings.hooks.SessionStart = settings.hooks.SessionStart.filter(
+    (entry: { hooks?: { command: string }[] }) =>
+      !entry.hooks?.some((h) => h.command === HOOK_COMMAND),
+  );
+  if (settings.hooks.SessionStart.length === 0) {
+    delete settings.hooks.SessionStart;
+  }
+  if (Object.keys(settings.hooks).length === 0) {
+    delete settings.hooks;
+  }
+
+  if (Object.keys(settings).length === 0) {
+    await rm(settingsPath, { force: true });
+  } else {
+    await writeFile(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+  }
 }
 
 export async function uninstallProject(projectRoot: string): Promise<void> {
-  const files = [
+  // Remove framework-owned files outright
+  for (const f of [
     join(projectRoot, "AGENTS.md"),
-    join(projectRoot, "CLAUDE.md"),
     join(projectRoot, ".agents.yml"),
     join(projectRoot, ".claude/agents"),
     join(projectRoot, ".opencode/agents"),
-  ];
-  for (const f of files) {
+    join(projectRoot, ".opencode/plugins/agents-auto-update.ts"),
+  ]) {
     await rm(f, { recursive: true, force: true });
   }
+
+  // CLAUDE.md — remove only the import line, keep the rest
+  const claudeMdPath = join(projectRoot, "CLAUDE.md");
+  const content = await readFile(claudeMdPath, "utf-8").catch(
+    (err: NodeJS.ErrnoException) =>
+      err.code === "ENOENT" ? null : Promise.reject(err),
+  );
+  if (content !== null) {
+    const updated = content
+      .split("\n")
+      .filter((l) => l.trim() !== "@./AGENTS.md")
+      .join("\n")
+      .replace(/\n{3,}/g, "\n\n")
+      .trim();
+    if (updated.length === 0) {
+      await rm(claudeMdPath, { force: true });
+    } else {
+      await writeFile(claudeMdPath, `${updated}\n`, "utf-8");
+    }
+  }
+
+  // .claude/settings.json — remove the SessionStart hook
+  await removeClaudeHook(join(projectRoot, ".claude/settings.json"));
 }
 
 // CLI entrypoint

package/templates/.agents.yml

@@ -24,8 +24,15 @@ autonomy: checkpoint  # supervised | checkpoint | autonomous
 # Resolution order (highest → lowest priority):
 #   1. models.roles.<role>      — this project, specific role
 #   2. models.defaults.<tier>   — this project, whole tier
-#   3. framework roles default  — models.yml roles section
-#   4. framework tier default   — models.yml defaults section
+#   3. preset.<tier>            — named preset from models.yml
+#   4. framework roles default  — models.yml roles section
+#   5. framework tier default   — models.yml defaults section
+#
+# Presets (switch all tiers at once):
+# preset: balanced   # default — anthropic sonnet/haiku
+# preset: fast       # all haiku — cheap and quick
+# preset: google     # gemini 2.5 pro/flash
+# preset: openai     # gpt-4.1/mini
 #
 # models:
 #   defaults:

package/templates/opencode-plugin.ts

@@ -0,0 +1,16 @@
+// Auto-generated by @ryodeushii/ai-product-team-agents
+// Runs --update on session start so model overrides in .agents.yml
+// are always applied without manual intervention.
+// To remove: bunx @ryodeushii/ai-product-team-agents --uninstall
+
+export const AgentsAutoUpdate = async ({
+  $,
+}: {
+  $: (strings: TemplateStringsArray, ...values: unknown[]) => Promise<unknown>;
+}) => {
+  return {
+    "session.created": async () => {
+      await ($ as any)`bunx --bun @ryodeushii/ai-product-team-agents --update`.quiet().nothrow();
+    },
+  };
+};

package/src/mcp/server.ts

@@ -1,60 +0,0 @@
-#!/usr/bin/env bun
-// src/mcp/server.ts
-
-import { fileURLToPath } from "node:url";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
-import { loadFrameworkConfig, loadProjectConfig } from "../config/loader";
-import { resolveModel } from "../models/resolver";
-import type { Role } from "../models/types";
-import { ROLES } from "../models/types";
-
-const FRAMEWORK_ROOT = fileURLToPath(new URL("../../", import.meta.url));
-
-export async function resolveModelForProject(
-  role: string,
-  projectRoot: string,
-  frameworkRoot = FRAMEWORK_ROOT,
-): Promise<string> {
-  if (!ROLES.includes(role as Role)) throw new Error(`Unknown role: ${role}`);
-  const [framework, project] = await Promise.all([
-    loadFrameworkConfig(frameworkRoot),
-    loadProjectConfig(projectRoot),
-  ]);
-  return resolveModel(role as Role, framework, project.models ?? {});
-}
-
-export function createMcpServer(): McpServer {
-  const server = new McpServer({
-    name: "agents-framework",
-    version: "0.1.0",
-  });
-
-  server.tool(
-    "resolve_model",
-    "Resolve the model for an agent role, applying project overrides",
-    {
-      role: z.string().describe("Agent role name"),
-      project_root: z.string().describe("Absolute path to target project root"),
-    },
-    async ({ role, project_root }) => {
-      try {
-        const model = await resolveModelForProject(role, project_root);
-        return { content: [{ type: "text", text: model }] };
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return { content: [{ type: "text", text: message }], isError: true };
-      }
-    },
-  );
-
-  return server;
-}
-
-// entrypoint when run directly
-if (import.meta.main) {
-  const server = createMcpServer();
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-}