takomi 2.0.6 → 2.1.0

package/.pi/extensions/takomi-runtime/profile.ts

@@ -0,0 +1,114 @@
+import { readFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import type {
+  TakomiDispatchDefaults,
+  TakomiProfile,
+  TakomiRole,
+  VibeLifecycleStage,
+} from "../../../src/pi-takomi-core";
+
+export const DEFAULT_TAKOMI_PROFILE: TakomiProfile = {
+  version: 1,
+  autoOrchestrate: true,
+  launchMode: "auto",
+  foreground: true,
+  background: true,
+  reviewAfterImplementation: true,
+  roles: {
+    orchestrator: { agent: "orchestrator", dispatchPolicy: "subagent" },
+    architect: { agent: "architect", dispatchPolicy: "subagent" },
+    design: { agent: "designer", dispatchPolicy: "subagent" },
+    code: { agent: "coder", dispatchPolicy: "subagent" },
+    review: { agent: "reviewer", dispatchPolicy: "review-first" },
+  },
+  stages: {
+    genesis: { agent: "architect", dispatchPolicy: "subagent" },
+    design: { agent: "designer", dispatchPolicy: "subagent" },
+    build: { agent: "orchestrator", dispatchPolicy: "subagent" },
+  },
+  review: {
+    enabled: true,
+    agent: "reviewer",
+    maxIterations: 2,
+    sameConversation: true,
+  },
+};
+
+function cleanStringArray(value: unknown): string[] | undefined {
+  if (!Array.isArray(value)) return undefined;
+  const parts = value.filter((item): item is string => typeof item === "string" && item.trim().length > 0);
+  return parts.length ? parts : undefined;
+}
+
+function mergeDefaults(
+  base?: TakomiDispatchDefaults,
+  next?: TakomiDispatchDefaults,
+): TakomiDispatchDefaults | undefined {
+  if (!base && !next) return undefined;
+  const fallbackModels = cleanStringArray(next?.fallbackModels) ?? cleanStringArray(base?.fallbackModels);
+  return {
+    ...base,
+    ...next,
+    fallbackModels,
+  };
+}
+
+function mergeProfile(base: TakomiProfile, next?: Partial<TakomiProfile>): TakomiProfile {
+  if (!next) return base;
+  const roles = { ...(base.roles ?? {}) };
+  for (const [role, defaults] of Object.entries(next.roles ?? {}) as Array<[TakomiRole, TakomiDispatchDefaults]>) {
+    roles[role] = mergeDefaults(roles[role], defaults);
+  }
+
+  const stages = { ...(base.stages ?? {}) };
+  for (const [stage, defaults] of Object.entries(next.stages ?? {}) as Array<[VibeLifecycleStage, TakomiDispatchDefaults]>) {
+    stages[stage] = mergeDefaults(stages[stage], defaults);
+  }
+
+  return {
+    ...base,
+    ...next,
+    version: 1,
+    autoOrchestrate: next.autoOrchestrate ?? base.autoOrchestrate,
+    launchMode: next.launchMode ?? base.launchMode ?? "auto",
+    foreground: next.foreground ?? base.foreground ?? true,
+    background: next.background ?? base.background ?? true,
+    reviewAfterImplementation: next.reviewAfterImplementation ?? base.reviewAfterImplementation ?? true,
+    roles,
+    stages,
+    review: {
+      ...base.review,
+      ...next.review,
+      enabled: next.review?.enabled ?? base.review?.enabled ?? true,
+      sameConversation: next.review?.sameConversation ?? base.review?.sameConversation ?? true,
+    },
+  };
+}
+
+async function readProfileFile(filePath: string): Promise<Partial<TakomiProfile> | undefined> {
+  try {
+    return JSON.parse(await readFile(filePath, "utf8")) as Partial<TakomiProfile>;
+  } catch {
+    return undefined;
+  }
+}
+
+export async function loadTakomiProfile(cwd: string): Promise<TakomiProfile> {
+  const projectProfilePath = path.join(cwd, ".pi", "takomi-profile.json");
+  const userProfilePath = path.join(os.homedir(), ".pi", "agent", "takomi", "profile.json");
+  const projectProfile = await readProfileFile(projectProfilePath);
+  const userProfile = await readProfileFile(userProfilePath);
+  return mergeProfile(mergeProfile(DEFAULT_TAKOMI_PROFILE, projectProfile), userProfile);
+}
+
+export function getProfileDefaults(
+  profile: TakomiProfile,
+  role: TakomiRole,
+  stage?: VibeLifecycleStage,
+): TakomiDispatchDefaults {
+  return {
+    ...(stage ? profile.stages?.[stage] : undefined),
+    ...profile.roles?.[role],
+  };
+}

package/.pi/extensions/takomi-runtime/routing-policy.ts

@@ -0,0 +1,105 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+export const TAKOMI_ROUTING_POLICY_RELATIVE = path.join(".pi", "takomi", "model-routing.md");
+
+export type RoutingPolicyInstallResult = {
+  policyPath: string;
+  settingsPath: string;
+  settingsUpdated: boolean;
+  detectedDefaults: string[];
+};
+
+type JsonObject = Record<string, unknown>;
+
+function asObject(value: unknown): JsonObject {
+  return value && typeof value === "object" && !Array.isArray(value) ? value as JsonObject : {};
+}
+
+async function readJsonObject(filePath: string): Promise<JsonObject> {
+  try {
+    return asObject(JSON.parse(await readFile(filePath, "utf8")));
+  } catch {
+    return {};
+  }
+}
+
+function extractQuotedPolicy(text: string): string {
+  const triple = text.match(/"""([\s\S]*?)"""|```(?:\w+)?\s*([\s\S]*?)```/);
+  const raw = (triple?.[1] ?? triple?.[2] ?? text).trim();
+  return raw.replace(/^update\s+(?:takomi\s+)?(?:model\s+)?routing\s+(?:logic|policy|philosophy)\s*:?/i, "").trim();
+}
+
+function deriveSubagentDefaults(policy: string): { overrides: JsonObject; detected: string[] } {
+  const lower = policy.toLowerCase();
+  const has55 = /gpt[- ]?5\.5/.test(lower);
+  const has54 = /gpt[- ]?5\.4(?!\s*mini)/.test(lower);
+  const hasMini = /gpt[- ]?5\.4\s*mini/.test(lower);
+  if (!has55 && !has54 && !hasMini) return { overrides: {}, detected: [] };
+
+  const model55 = "oauth-router/gpt-5.5";
+  const model54 = "oauth-router/gpt-5.4";
+  const modelMini = "oauth-router/gpt-5.4-mini";
+  const overrides: JsonObject = {};
+  const detected: string[] = [];
+
+  if (has55) {
+    overrides.oracle = { model: model55, thinking: "high" };
+    overrides.reviewer = { model: model55, thinking: "high" };
+    overrides.planner = { model: model55, thinking: "medium" };
+    detected.push("oracle/reviewer → GPT-5.5 high", "planner → GPT-5.5 medium");
+  }
+  if (has54) {
+    overrides.worker = { model: model54, thinking: "high", fallbackModels: has55 ? [`${model55}:low`] : undefined };
+    overrides.contextBuilder = { model: model54, thinking: "high" };
+    overrides["context-builder"] = { model: model54, thinking: "high" };
+    detected.push("worker/context-builder → GPT-5.4 high");
+  }
+  if (hasMini) {
+    overrides.scout = { model: modelMini, thinking: "high" };
+    overrides.delegate = { model: modelMini, thinking: "high" };
+    detected.push("scout/delegate → GPT-5.4 Mini high");
+  }
+  return { overrides, detected };
+}
+
+export async function installTakomiRoutingPolicy(cwd: string, input: string): Promise<RoutingPolicyInstallResult> {
+  const policy = extractQuotedPolicy(input);
+  if (!policy) throw new Error("No routing policy text found. Paste the policy after /takomi routing or inside triple quotes.");
+
+  const policyPath = path.join(cwd, TAKOMI_ROUTING_POLICY_RELATIVE);
+  const settingsPath = path.join(cwd, ".pi", "settings.json");
+  await mkdir(path.dirname(policyPath), { recursive: true });
+  await mkdir(path.dirname(settingsPath), { recursive: true });
+  await writeFile(policyPath, `# Takomi Model Routing Policy\n\n${policy}\n`, "utf8");
+
+  const settings = await readJsonObject(settingsPath);
+  const takomi = asObject(settings.takomi);
+  takomi.modelRoutingPolicyFile = TAKOMI_ROUTING_POLICY_RELATIVE.replaceAll(path.sep, "/");
+  settings.takomi = takomi;
+
+  const { overrides, detected } = deriveSubagentDefaults(policy);
+  if (Object.keys(overrides).length > 0) {
+    const subagents = asObject(settings.subagents);
+    const existingOverrides = asObject(subagents.agentOverrides);
+    subagents.agentOverrides = { ...existingOverrides, ...overrides };
+    settings.subagents = subagents;
+  }
+
+  await writeFile(settingsPath, `${JSON.stringify(settings, null, 2)}\n`, "utf8");
+  return { policyPath, settingsPath, settingsUpdated: true, detectedDefaults: detected };
+}
+
+export async function loadTakomiRoutingPolicy(cwd: string): Promise<string | undefined> {
+  const settingsPath = path.join(cwd, ".pi", "settings.json");
+  const settings = await readJsonObject(settingsPath);
+  const takomi = asObject(settings.takomi);
+  const configured = typeof takomi.modelRoutingPolicyFile === "string" ? takomi.modelRoutingPolicyFile : TAKOMI_ROUTING_POLICY_RELATIVE;
+  const policyPath = path.isAbsolute(configured) ? configured : path.join(cwd, configured);
+  try {
+    const text = (await readFile(policyPath, "utf8")).trim();
+    return text || undefined;
+  } catch {
+    return undefined;
+  }
+}