@rmrdeveloper/sideroom-pi 5.0.0

package/dist/pi-extension.js

@@ -0,0 +1,1175 @@
+// src/core/catalog.ts
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+var agents = /* @__PURE__ */ new Map();
+var guidelines = /* @__PURE__ */ new Map();
+var skills = /* @__PURE__ */ new Map();
+var sharedGuidelines;
+function getPackageRoot() {
+  let directory = path.dirname(fileURLToPath(import.meta.url));
+  while (!existsSync(path.join(directory, "package.json"))) {
+    const parent = path.dirname(directory);
+    if (parent === directory) throw new Error("cannot locate Sideroom assets");
+    directory = parent;
+  }
+  return directory;
+}
+function assetsDir() {
+  return path.join(getPackageRoot(), "src", "assets");
+}
+function getAgentDefinition(id) {
+  const cached = agents.get(id);
+  if (cached !== void 0) return cached;
+  const file = path.join(assetsDir(), "agents", `${id}.md`);
+  const definition = parseAgentDefinition(id, readFileSync(file, "utf8"), file);
+  agents.set(id, definition);
+  return definition;
+}
+function getLanguageGuidelines(language) {
+  const cached = guidelines.get(language);
+  if (cached !== void 0) return cached;
+  const file = path.join(
+    assetsDir(),
+    "artifacts",
+    "guidelines",
+    `${language}.md`
+  );
+  const source = readFileSync(file, "utf8").trim();
+  if (source.length === 0)
+    throw new Error(`coding guidelines are empty: ${language}`);
+  guidelines.set(language, source);
+  return source;
+}
+function getSharedGuidelines() {
+  if (sharedGuidelines !== void 0) return sharedGuidelines;
+  const file = path.join(assetsDir(), "artifacts", "GUIDELINES_TEMPLATE.md");
+  const source = readFileSync(file, "utf8").trim();
+  if (source.length === 0) throw new Error("guidelines template is empty");
+  sharedGuidelines = source;
+  return source;
+}
+function getPackagedSkill(skill) {
+  const cached = skills.get(skill);
+  if (cached !== void 0) return cached;
+  const file = path.join(getPackageRoot(), "skills", skill, "SKILL.md");
+  const source = readFileSync(file, "utf8").trim();
+  if (source.length === 0) throw new Error(`packaged skill is empty: ${skill}`);
+  skills.set(skill, source);
+  return source;
+}
+function buildSystemPrompt(id, language) {
+  return [
+    getAgentDefinition(id).instructions,
+    "## Shared engineering policy",
+    getSharedGuidelines(),
+    "## Language policy",
+    getLanguageGuidelines(language),
+    "The language policy overrides conflicting language-specific examples or commands above."
+  ].join("\n\n");
+}
+function parseAgentDefinition(id, source, file) {
+  const match = /^---\n([\s\S]*?)\n---\n?([\s\S]*)$/.exec(
+    source.replaceAll("\r\n", "\n")
+  );
+  if (match === null)
+    throw new Error(`agent definition must start with frontmatter: ${file}`);
+  const [, header, body] = match;
+  if (header === void 0 || body === void 0)
+    throw new Error(`invalid agent definition: ${file}`);
+  const metadata = /* @__PURE__ */ new Map();
+  for (const line of header.split("\n")) {
+    const separator = line.indexOf(":");
+    if (separator > 0)
+      metadata.set(
+        line.slice(0, separator).trim(),
+        line.slice(separator + 1).trim()
+      );
+  }
+  if (metadata.get("name") !== id)
+    throw new Error(`agent name mismatch in ${file}`);
+  const description = metadata.get("description");
+  if (description === void 0 || description.length === 0) {
+    throw new Error(`agent description is missing in ${file}`);
+  }
+  const instructions = body.trim();
+  if (instructions.length === 0)
+    throw new Error(`agent instructions are empty in ${file}`);
+  return {
+    id,
+    description,
+    readonly: metadata.get("readonly") === "true",
+    instructions
+  };
+}
+
+// src/core/findings.ts
+var FINDING = /^FINDING (\d+) \| (Critical|High|Medium|Low) \| ([^|]+) \| ([^|]+) \| (.+)$/;
+var FINDING_SEVERITIES = ["Critical", "High", "Medium", "Low"];
+function parseFindings(source, stage = "finding report") {
+  const trimmed = source.trim();
+  if (trimmed.length === 0 || trimmed === "No findings") return [];
+  const parsed = trimmed.split("\n").map((line, index) => {
+    const match = FINDING.exec(line.trim());
+    if (match === null) {
+      throw new Error(`${stage} finding ${String(index + 1)} is malformed`);
+    }
+    const [, number, severity, fileLine, rule, description] = match;
+    if (number === void 0 || severity === void 0 || fileLine === void 0 || rule === void 0 || description === void 0) {
+      throw new Error(`${stage} finding ${String(index + 1)} is malformed`);
+    }
+    return {
+      number: Number(number),
+      severity,
+      fileLine: fileLine.trim(),
+      rule: rule.trim(),
+      description: description.trim()
+    };
+  });
+  return validateFindings(parsed, stage);
+}
+function validateFindings(value, stage) {
+  if (!Array.isArray(value)) {
+    throw new Error(`${stage} findings must be an array`);
+  }
+  return value.map((finding, index) => validateFinding(finding, index, stage));
+}
+function validateFinding(value, index, stage) {
+  const number = index + 1;
+  const record = recordOf(value, `${stage} finding ${String(number)}`);
+  if (record.number !== number) {
+    throw new Error(
+      `${stage} finding ${String(number)} field "number" must be ${String(number)}`
+    );
+  }
+  if (!isFindingSeverity(record.severity)) {
+    throw new Error(
+      `${stage} finding ${String(number)} field "severity" is invalid`
+    );
+  }
+  const fileLine = textField(record.fileLine, "fileLine", number, stage);
+  const rule = textField(record.rule, "rule", number, stage);
+  const description = textField(
+    record.description,
+    "description",
+    number,
+    stage
+  );
+  return { number, severity: record.severity, fileLine, rule, description };
+}
+function recordOf(value, label) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error(`${label} must be an object`);
+  }
+  return value;
+}
+function textField(value, field, number, stage) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(
+      `${stage} finding ${String(number)} field "${field}" must be non-empty text`
+    );
+  }
+  return value.trim();
+}
+function isFindingSeverity(value) {
+  return typeof value === "string" && FINDING_SEVERITIES.includes(value);
+}
+
+// src/core/types.ts
+var LANGUAGES = [
+  "typescript",
+  "javascript",
+  "php-laravel",
+  "python",
+  "java"
+];
+function hasBlockingFindings(findings) {
+  return findings.some((finding) => finding.severity !== "Low");
+}
+
+// src/core/agents.ts
+function createPlanner(model) {
+  return {
+    id: "sideroom-planner",
+    async run(input) {
+      requireText(input.request, "planner needs a request");
+      const value = await model.generate({
+        agent: "sideroom-planner",
+        input,
+        schema: "{ summary: string, tasks: [{ id: string, title: string }], verification: string[] }"
+      });
+      return parsePlan(value);
+    }
+  };
+}
+function createImplementer(model) {
+  return {
+    id: "sideroom-implementer",
+    async run(input) {
+      requireText(input.task.id, "implementer needs a task id");
+      const value = await model.generate({
+        agent: "sideroom-implementer",
+        input,
+        schema: "{ filesChanged: string[], summary: string }"
+      });
+      const record = recordOf2(
+        value,
+        "implementer returned a non-object response"
+      );
+      if (!Array.isArray(record.filesChanged) || !record.filesChanged.every(isText)) {
+        throw new Error("implementer returned malformed filesChanged");
+      }
+      if (!isText(record.summary))
+        throw new Error("implementer returned no summary");
+      return {
+        taskId: input.task.id,
+        filesChanged: record.filesChanged,
+        summary: record.summary
+      };
+    }
+  };
+}
+function createReviewer(model) {
+  return {
+    id: "sideroom-code-reviewer",
+    async run(input) {
+      const value = await model.generate({
+        agent: "sideroom-code-reviewer",
+        input,
+        schema: 'a JSON string containing FINDING lines, or the JSON string "No findings"'
+      });
+      if (!isText(value))
+        throw new Error("reviewer returned a non-string response");
+      return parseFindings(value, "reviewer");
+    }
+  };
+}
+function createVerifier(model) {
+  return {
+    id: "sideroom-verifier",
+    async run(input) {
+      const value = await model.generate({
+        agent: "sideroom-verifier",
+        input,
+        schema: "{ findings: string, summary: string }"
+      });
+      const record = recordOf2(value, "verifier output must be an object");
+      const findings = findingReport(record.findings, "verifier");
+      requireText(
+        record.summary,
+        "verifier output.summary must be non-empty text"
+      );
+      return findings;
+    }
+  };
+}
+function createFixer(model) {
+  return {
+    id: "sideroom-fixer",
+    async run(input) {
+      if (!hasBlockingFindings(input.findings))
+        return "No blocking findings to fix.";
+      const value = await model.generate({
+        agent: "sideroom-fixer",
+        input,
+        schema: "{ summary: string }"
+      });
+      const record = recordOf2(value, "fixer returned a non-object response");
+      if (!isText(record.summary)) throw new Error("fixer returned no summary");
+      return record.summary;
+    }
+  };
+}
+function parsePlan(value) {
+  const record = recordOf2(value, "planner returned a non-object response");
+  if (!isText(record.summary)) throw new Error("planner returned no summary");
+  if (!Array.isArray(record.tasks) || !record.tasks.every(isPlanTask)) {
+    throw new Error("planner returned malformed tasks");
+  }
+  if (!Array.isArray(record.verification) || !record.verification.every(isText)) {
+    throw new Error("planner returned malformed verification commands");
+  }
+  if (record.tasks.length === 0) throw new Error("planner returned no tasks");
+  return {
+    summary: record.summary,
+    tasks: record.tasks,
+    verification: record.verification
+  };
+}
+function isPlanTask(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const record = value;
+  return isText(record.id) && isText(record.title) && (record.description === void 0 || isText(record.description)) && (record.files === void 0 || Array.isArray(record.files) && record.files.every(isText)) && (record.acceptance === void 0 || Array.isArray(record.acceptance) && record.acceptance.every(isText));
+}
+function recordOf2(value, message) {
+  if (typeof value !== "object" || value === null) throw new Error(message);
+  return value;
+}
+function isText(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function requireText(value, message) {
+  if (!isText(value)) throw new Error(message);
+}
+function findingReport(value, stage) {
+  if (!isText(value)) {
+    throw new Error(`${stage} output.findings must be non-empty text`);
+  }
+  return parseFindings(value, stage);
+}
+
+// src/core/grilling.ts
+function createGriller(model) {
+  return {
+    async run(input) {
+      const value = await model.generate({
+        agent: "sideroom-planner",
+        skill: "sideroom-grilling",
+        input,
+        schema: '{ status: "questions", questions: [{ id: string, title: string, question: string, recommendation: string }] } | { status: "settled", summary: string }'
+      });
+      return parseGrillingResult(value);
+    }
+  };
+}
+function parseGrillingResult(value) {
+  const record = recordOf3(value);
+  if (record.status === "settled") {
+    if (!isText2(record.summary))
+      throw new Error("grilling returned no settled summary");
+    return { status: "settled", summary: record.summary };
+  }
+  if (record.status !== "questions" || !Array.isArray(record.questions)) {
+    throw new Error("grilling returned an unknown status");
+  }
+  if (record.questions.length === 0 || record.questions.length > 3) {
+    throw new Error("grilling must ask between one and three questions");
+  }
+  const questions = record.questions.map(parseQuestion);
+  if (new Set(questions.map((question) => question.id)).size !== questions.length) {
+    throw new Error("grilling returned duplicate question ids");
+  }
+  return { status: "questions", questions };
+}
+function parseQuestion(value) {
+  const record = recordOf3(value);
+  if (!isText2(record.id) || !isText2(record.title) || !isText2(record.question) || !isText2(record.recommendation)) {
+    throw new Error("grilling returned a malformed question");
+  }
+  return {
+    id: record.id,
+    title: record.title,
+    question: record.question,
+    recommendation: record.recommendation
+  };
+}
+function recordOf3(value) {
+  if (typeof value !== "object" || value === null) {
+    throw new Error("grilling returned a non-object response");
+  }
+  return value;
+}
+function isText2(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+
+// src/core/orchestrator.ts
+var SideroomOrchestrator = class {
+  options;
+  constructor(options) {
+    const maxFixPasses = options.maxFixPasses ?? 2;
+    if (!Number.isInteger(maxFixPasses) || maxFixPasses < 1) {
+      throw new Error("maxFixPasses must be an integer of at least 1");
+    }
+    const maxGrillingRounds = options.maxGrillingRounds ?? 8;
+    if (!Number.isInteger(maxGrillingRounds) || maxGrillingRounds < 1) {
+      throw new Error("maxGrillingRounds must be an integer of at least 1");
+    }
+    this.options = { ...options, maxFixPasses, maxGrillingRounds };
+  }
+  /** Plan, implement, review, verify, and repair in the caller's project directory. */
+  async run(request, answerQuestions2) {
+    let implementations = [];
+    let plan;
+    let findings = [];
+    try {
+      const settledRequest = await this.settleRequest(request, answerQuestions2);
+      this.report({ phase: "planner", status: "started" });
+      plan = await this.options.planner.run({ request: settledRequest });
+      this.report({ phase: "planner", status: "completed" });
+      for (const task of plan.tasks) {
+        this.report({
+          phase: "implementer",
+          status: "started",
+          taskId: task.id
+        });
+        const implementation = await this.options.implementer.run({
+          task,
+          plan: plan.summary
+        });
+        this.report({
+          phase: "implementer",
+          status: "completed",
+          taskId: task.id
+        });
+        implementations = [...implementations, implementation];
+      }
+      const combined = combineImplementation(implementations);
+      for (let pass = 0; pass <= this.options.maxFixPasses; pass += 1) {
+        const qualityInput = { implementation: combined, plan: plan.summary };
+        this.report({ phase: "reviewer", status: "started" });
+        this.report({ phase: "verifier", status: "started" });
+        const [review, verification] = await Promise.all([
+          this.options.reviewer.run(qualityInput),
+          this.options.verifier.run(qualityInput)
+        ]);
+        this.report({ phase: "reviewer", status: "completed" });
+        this.report({ phase: "verifier", status: "completed" });
+        findings = validateFindings(
+          mergeFindings(
+            validateFindings(review, "reviewer stage"),
+            validateFindings(verification, "verifier stage")
+          ),
+          "quality gate"
+        );
+        if (!hasBlockingFindings(findings)) {
+          return {
+            status: "completed",
+            plan,
+            implementations,
+            findings,
+            summary: "Completed with no blocking findings."
+          };
+        }
+        if (pass === this.options.maxFixPasses) break;
+        this.report({ phase: "fixer", status: "started" });
+        await this.options.fixer.run({
+          implementation: combined,
+          findings: validateFindings(findings, "fixer input")
+        });
+        this.report({ phase: "fixer", status: "completed" });
+      }
+      return {
+        status: "failed",
+        plan,
+        implementations,
+        findings,
+        summary: "Blocking findings remain after the configured fixer passes."
+      };
+    } catch (error) {
+      this.report({ phase: "pipeline", status: "failed" });
+      return {
+        status: "failed",
+        ...plan === void 0 ? {} : { plan },
+        implementations,
+        findings,
+        summary: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /** Collect user-owned design decisions without writing a project-local run file. */
+  async settleRequest(request, answerQuestions2) {
+    const griller = this.options.griller;
+    if (griller === void 0) return request;
+    let answers = [];
+    for (let round = 0; round < this.options.maxGrillingRounds; round += 1) {
+      const roundNumber = round + 1;
+      this.report({
+        phase: "grilling",
+        status: "started",
+        round: roundNumber
+      });
+      const result = await griller.run({ request, answers });
+      if (result.status === "settled") {
+        this.report({
+          phase: "grilling",
+          status: "completed",
+          round: roundNumber
+        });
+        return `${request}
+
+## Settled understanding
+${result.summary}`;
+      }
+      this.report({
+        phase: "grilling",
+        status: "awaiting-input",
+        round: roundNumber
+      });
+      if (answerQuestions2 === void 0) {
+        throw new Error(
+          "Grilling needs user decisions; run sideroom in an interactive terminal."
+        );
+      }
+      const roundAnswers = await answerQuestions2(result.questions);
+      if (roundAnswers === void 0) {
+        throw new Error(
+          "Grilling was cancelled before the design was settled."
+        );
+      }
+      assertAnswersCoverQuestions(result.questions, roundAnswers);
+      answers = [...answers, ...roundAnswers];
+    }
+    throw new Error(
+      "Grilling exceeded the configured maximum number of rounds."
+    );
+  }
+  report(event) {
+    this.options.onStage?.(event);
+  }
+};
+function assertAnswersCoverQuestions(questions, answers) {
+  const expected = new Set(questions.map((question) => question.id));
+  if (answers.length !== questions.length || answers.some(
+    (answer) => !expected.delete(answer.id) || answer.answer.trim().length === 0
+  ) || expected.size !== 0) {
+    throw new Error(
+      "Grilling answers must cover each current question exactly once."
+    );
+  }
+}
+function combineImplementation(implementations) {
+  return {
+    taskId: "all",
+    filesChanged: [
+      ...new Set(implementations.flatMap((result) => result.filesChanged))
+    ],
+    summary: implementations.map((result) => `${result.taskId}: ${result.summary}`).join("\n")
+  };
+}
+function mergeFindings(review, verification) {
+  const unique = /* @__PURE__ */ new Map();
+  for (const finding of [...review, ...verification]) {
+    unique.set(
+      `${finding.fileLine}|${finding.rule}|${finding.description}`,
+      finding
+    );
+  }
+  return [...unique.values()].map((finding, index) => ({
+    ...finding,
+    number: index + 1
+  }));
+}
+
+// src/runtimes/pi.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, statSync } from "node:fs";
+import path2 from "node:path";
+import {
+  createAgentSession,
+  DefaultResourceLoader,
+  ModelRuntime,
+  resolveCliModel,
+  SessionManager,
+  SettingsManager
+} from "@earendil-works/pi-coding-agent";
+var READONLY_TOOLS = ["read", "grep", "find", "ls"];
+var DEFAULT_TIMEOUT_MS = 10 * 60 * 1e3;
+function piToolsFor(role, allowWrite, platform = process.platform) {
+  if (role.readonly || !allowWrite) return READONLY_TOOLS;
+  return [
+    "read",
+    platform === "win32" ? "powershell" : "bash",
+    "edit",
+    "write",
+    "grep",
+    "find",
+    "ls"
+  ];
+}
+function createPiModelProvider(options) {
+  assertTargetDirectory(options.dir);
+  let runtimePromise;
+  const runtime = () => {
+    if (options.modelRuntime !== void 0)
+      return Promise.resolve(options.modelRuntime);
+    runtimePromise ??= ModelRuntime.create();
+    return runtimePromise;
+  };
+  const createSession = options.createSession ?? ((sessionOptions) => createSdkSession(sessionOptions, runtime()));
+  return {
+    async generate(request) {
+      const role = getAgentDefinition(request.agent);
+      const session = await createSession({
+        cwd: options.dir,
+        ...options.model === void 0 ? {} : { model: options.model },
+        tools: piToolsFor(role, options.allowWrite !== false),
+        systemPrompt: systemPromptFor(
+          request.agent,
+          role,
+          options.language,
+          options.allowWrite !== false,
+          options.dir,
+          request.skill
+        )
+      });
+      const timeout = setTimeout(() => {
+        void session.abort().catch(reportAbortFailure);
+      }, options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+      try {
+        await session.prompt(buildTaskPrompt(request));
+        return parseJsonResponse(finalPiText(session.messages));
+      } finally {
+        clearTimeout(timeout);
+        session.dispose();
+      }
+    }
+  };
+}
+function assertTargetDirectory(directory) {
+  if (directory.trim().length === 0) {
+    throw new Error("Pi needs a target directory");
+  }
+  try {
+    if (!statSync(directory).isDirectory()) {
+      throw new Error("path is not a directory");
+    }
+  } catch (error) {
+    throw new Error(`Pi target directory is unavailable: ${directory}`, {
+      cause: error
+    });
+  }
+}
+function systemPromptFor(agent, role, language, allowWrite, directory, skill) {
+  const sections = [buildSystemPrompt(agent, language)];
+  if (skill !== void 0) {
+    sections.push(`## Packaged skill: ${skill}`, getPackagedSkill(skill));
+  }
+  const projectInstructions = loadTargetProjectInstructions(directory);
+  if (projectInstructions.length > 0) {
+    sections.push("## Target repository instructions", projectInstructions);
+  }
+  if (!role.readonly && allowWrite) {
+    sections.push(
+      "## Mandatory write-gate enforcement",
+      "The shared template and selected language guidelines above are mandatory. Before every code-writing tool call (edit, write, or a shell command that changes source), read the relevant guideline sections first. Do not write code and review its guidelines afterwards."
+    );
+  }
+  sections.push(
+    "## Sideroom execution boundary",
+    "Run only this Sideroom role through the Pi SDK. Do not delegate work to another agent, harness, task runner, or skill with a similar name. Never use or claim a fallback agent. The only valid pipeline roles are sideroom-planner, sideroom-implementer, sideroom-code-reviewer, sideroom-verifier, and sideroom-fixer."
+  );
+  return sections.join("\n\n");
+}
+async function createSdkSession(options, modelRuntime) {
+  const resolvedRuntime = await modelRuntime;
+  const resolved = resolveModel(options.model, resolvedRuntime);
+  const settingsManager = createIsolatedSettings(options.cwd);
+  const loader = createIsolatedResourceLoader({ ...options, settingsManager });
+  await loader.reload();
+  const { session } = await createAgentSession({
+    cwd: options.cwd,
+    modelRuntime: resolvedRuntime,
+    ...resolved.model === void 0 ? {} : { model: resolved.model },
+    ...resolved.thinkingLevel === void 0 ? {} : { thinkingLevel: resolved.thinkingLevel },
+    tools: [...options.tools],
+    resourceLoader: loader,
+    settingsManager,
+    sessionManager: SessionManager.inMemory(options.cwd)
+  });
+  return session;
+}
+function createIsolatedResourceLoader(options) {
+  return new DefaultResourceLoader({
+    cwd: options.cwd,
+    // This avoids Pi's global agent directory; noContextFiles prevents target
+    // context from being loaded implicitly, too.
+    agentDir: options.cwd,
+    settingsManager: options.settingsManager ?? SettingsManager.inMemory(),
+    noExtensions: true,
+    noSkills: true,
+    noPromptTemplates: true,
+    noContextFiles: true,
+    additionalSkillPaths: [path2.join(getPackageRoot(), "skills")],
+    systemPromptOverride: () => options.systemPrompt,
+    appendSystemPromptOverride: () => []
+  });
+}
+function createIsolatedSettings(directory) {
+  const global = SettingsManager.create(directory);
+  return SettingsManager.inMemory({
+    ...global.getDefaultProvider() === void 0 ? {} : { defaultProvider: global.getDefaultProvider() },
+    ...global.getDefaultModel() === void 0 ? {} : { defaultModel: global.getDefaultModel() },
+    ...global.getDefaultThinkingLevel() === void 0 ? {} : { defaultThinkingLevel: global.getDefaultThinkingLevel() },
+    modelThinkingLevels: global.getAllModelThinkingLevels()
+  });
+}
+function resolveModel(model, runtime) {
+  if (model === void 0)
+    return { model: void 0, thinkingLevel: void 0 };
+  const resolved = resolveCliModel({ cliModel: model, modelRuntime: runtime });
+  if (resolved.error !== void 0)
+    throw new Error(`Pi model ${model}: ${resolved.error}`);
+  return resolved;
+}
+function finalPiText(messages) {
+  let lastError;
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (!isRecord(message) || message.role !== "assistant" || !Array.isArray(message.content))
+      continue;
+    if (typeof message.errorMessage === "string")
+      lastError = message.errorMessage;
+    const text = message.content.flatMap(
+      (part) => isRecord(part) && part.type === "text" && typeof part.text === "string" ? [part.text] : []
+    );
+    if (text.length > 0) return text.join("");
+  }
+  if (lastError !== void 0)
+    throw new Error(`Pi assistant failed: ${lastError}`);
+  throw new Error("Pi returned no final assistant text");
+}
+function buildTaskPrompt(request) {
+  const task = [
+    "Task context (JSON):",
+    JSON.stringify(request.input),
+    "",
+    "Return only one JSON value matching this schema:",
+    request.schema
+  ].join("\n");
+  return task;
+}
+function loadTargetProjectInstructions(directory) {
+  const root = findProjectRoot(directory);
+  const paths = directoriesFrom(root, path2.resolve(directory));
+  const files = paths.flatMap(readInstructionFile);
+  return files.map(({ file, content }) => `### ${file}
+${content}`).join("\n\n");
+}
+function findProjectRoot(directory) {
+  let current = path2.resolve(directory);
+  while (true) {
+    if (existsSync2(path2.join(current, ".git"))) return current;
+    const parent = path2.dirname(current);
+    if (parent === current) return path2.resolve(directory);
+    current = parent;
+  }
+}
+function directoriesFrom(root, directory) {
+  const result = [];
+  let current = directory;
+  while (true) {
+    result.unshift(current);
+    if (current === root) return result;
+    const parent = path2.dirname(current);
+    if (parent === current) return [directory];
+    current = parent;
+  }
+}
+function readInstructionFile(directory) {
+  for (const name of [
+    "AGENTS.override.md",
+    "AGENTS.md",
+    "AGENTS.MD",
+    "CLAUDE.md",
+    "CLAUDE.MD"
+  ]) {
+    const file = path2.join(directory, name);
+    if (!existsSync2(file)) continue;
+    try {
+      if (!statSync(file).isFile()) continue;
+      return [{ file, content: readFileSync2(file, "utf8") }];
+    } catch {
+      return [];
+    }
+  }
+  return [];
+}
+function parseJsonResponse(text) {
+  const trimmed = text.trim();
+  try {
+    return JSON.parse(trimmed);
+  } catch (initialError) {
+    const fenced = /```(?:json)?\s*([\s\S]*?)```/g;
+    let match = fenced.exec(trimmed);
+    let candidate;
+    while (match !== null) {
+      candidate = match[1]?.trim();
+      match = fenced.exec(trimmed);
+    }
+    if (candidate !== void 0) {
+      try {
+        return JSON.parse(candidate);
+      } catch (fencedError) {
+        throw new Error("Pi response was not valid JSON", {
+          cause: fencedError
+        });
+      }
+    }
+    throw new Error("Pi response was not valid JSON", { cause: initialError });
+  }
+}
+function reportAbortFailure(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  process.stderr.write(
+    `Sideroom could not abort a timed-out Pi session: ${message}
+`
+  );
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/app.ts
+function createPipeline(options) {
+  const model = createPiModelProvider({
+    dir: options.dir,
+    language: options.language,
+    ...options.model === void 0 ? {} : { model: options.model },
+    allowWrite: options.allowWrite
+  });
+  return new SideroomOrchestrator({
+    planner: createPlanner(model),
+    implementer: createImplementer(model),
+    reviewer: createReviewer(model),
+    verifier: createVerifier(model),
+    fixer: createFixer(model),
+    griller: createGriller(model),
+    maxFixPasses: options.maxFixPasses,
+    onStage: options.onStage
+  });
+}
+
+// src/pi-command.ts
+function parsePiCommand(args) {
+  const tokenResult = splitArguments(args);
+  if (typeof tokenResult === "string")
+    return { kind: "error", message: tokenResult };
+  let language = "typescript";
+  let maxFixPasses;
+  let allowWrite = true;
+  const requestParts = [];
+  for (let index = 0; index < tokenResult.length; index += 1) {
+    const token = tokenResult[index];
+    if (token === void 0) continue;
+    if (token === "--help" || token === "-h") return { kind: "help" };
+    if (token === "--read-only") {
+      allowWrite = false;
+      continue;
+    }
+    if (token === "--language" || token === "--max-fix-passes") {
+      const value = tokenResult[index + 1];
+      if (value === void 0 || value.startsWith("-") || value.length === 0) {
+        return { kind: "error", message: `${token} requires a value` };
+      }
+      index += 1;
+      if (token === "--language") {
+        if (!LANGUAGES.includes(value)) {
+          return {
+            kind: "error",
+            message: `--language must be one of: ${LANGUAGES.join(", ")}`
+          };
+        }
+        language = value;
+      } else {
+        const count = Number(value);
+        if (!Number.isInteger(count) || count < 1) {
+          return {
+            kind: "error",
+            message: "--max-fix-passes must be an integer of at least 1"
+          };
+        }
+        maxFixPasses = count;
+      }
+      continue;
+    }
+    if (token.startsWith("-")) {
+      return { kind: "error", message: `unknown option: ${token}` };
+    }
+    requestParts.push(token);
+  }
+  return {
+    kind: "run",
+    language,
+    ...requestParts.length === 0 ? {} : { request: requestParts.join(" ") },
+    ...maxFixPasses === void 0 ? {} : { maxFixPasses },
+    allowWrite
+  };
+}
+function formatPiCommandHelp() {
+  return `Usage: /sideroom [request] [options]
+
+Options:
+  --language <name>            typescript | javascript | php-laravel | python | java
+  --max-fix-passes <number>    Maximum repair passes (default: 2)
+  --read-only                  Do not grant write-capable tools
+  -h, --help                   Show this help
+
+Run Pi from the repository you want to change. Sideroom creates no project-local state.`;
+}
+function splitArguments(source) {
+  const tokens = [];
+  let current = "";
+  let quote;
+  let escaping = false;
+  for (const character of source.trim()) {
+    if (escaping) {
+      current += character;
+      escaping = false;
+      continue;
+    }
+    if (character === "\\") {
+      escaping = true;
+      continue;
+    }
+    if (quote !== void 0) {
+      if (character === quote) quote = void 0;
+      else current += character;
+      continue;
+    }
+    if (character === '"' || character === "'") {
+      quote = character;
+      continue;
+    }
+    if (/\s/.test(character)) {
+      if (current.length > 0) {
+        tokens.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += character;
+  }
+  if (escaping) return "command arguments cannot end with an escape character";
+  if (quote !== void 0)
+    return "command arguments contain an unterminated quote";
+  if (current.length > 0) tokens.push(current);
+  return tokens;
+}
+
+// src/pi-extension.ts
+var VERSION = "5.0.0";
+var TRACE_TYPE = "sideroom:run";
+var STATUS_KEY = "sideroom";
+var PROGRESS_WIDGET_KEY = "sideroom-progress";
+var RECOMMENDATION_PREFIX = "Use recommendation: ";
+var CUSTOM_ANSWER = "Write a different answer\u2026";
+var PIPELINE_PHASES = [
+  "grilling",
+  "planner",
+  "implementer",
+  "reviewer",
+  "verifier",
+  "fixer"
+];
+var PHASE_LABELS = {
+  grilling: "Grilling",
+  planner: "Planner",
+  implementer: "Implementer",
+  reviewer: "Reviewer",
+  verifier: "Verifier",
+  fixer: "Fixer",
+  pipeline: "Pipeline"
+};
+function registerSideroom(pi) {
+  pi.registerCommand("sideroom", {
+    description: "Run the isolated Sideroom coding pipeline in this Pi project",
+    handler: async (args, context) => {
+      const command = parsePiCommand(args);
+      if (command.kind === "help") {
+        context.ui.notify(formatPiCommandHelp(), "info");
+        return;
+      }
+      if (command.kind === "error") {
+        context.ui.notify(`Sideroom: ${command.message}`, "error");
+        return;
+      }
+      const request = await requestFor(command.request, context);
+      if (request === void 0) return;
+      const trace = [];
+      const progress = new PipelineProgress(context);
+      const observe = createObserver(trace, progress);
+      progress.start();
+      try {
+        const result = await createPipeline({
+          dir: context.cwd,
+          language: command.language,
+          ...modelReference(context) === void 0 ? {} : { model: modelReference(context) },
+          ...command.maxFixPasses === void 0 ? {} : { maxFixPasses: command.maxFixPasses },
+          allowWrite: command.allowWrite,
+          onStage: observe
+        }).run(
+          request,
+          (questions) => answerQuestions(questions, context, progress)
+        );
+        recordRun(pi, context, command.language, result, trace);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const result = {
+          status: "failed",
+          implementations: [],
+          findings: [],
+          summary: message
+        };
+        recordRun(pi, context, command.language, result, [
+          ...trace,
+          { phase: "pipeline", status: "failed" }
+        ]);
+      } finally {
+        progress.clear();
+        context.ui.setStatus(STATUS_KEY, void 0);
+      }
+    }
+  });
+}
+async function requestFor(request, context) {
+  if (request !== void 0 && request.trim().length > 0) return request;
+  if (!context.hasUI) {
+    context.ui.notify("Sideroom needs a request after /sideroom.", "error");
+    return void 0;
+  }
+  const response = await context.ui.input(
+    "What should Sideroom build?",
+    "Describe the change"
+  );
+  return response === void 0 || response.trim().length === 0 ? void 0 : response;
+}
+async function answerQuestions(questions, context, progress) {
+  if (!context.hasUI) return void 0;
+  const answers = [];
+  for (const [index, question] of questions.entries()) {
+    const questionNumber = index + 1;
+    progress.awaitDecision(questionNumber, questions.length);
+    const answer = await answerQuestion(
+      question,
+      questionNumber,
+      questions.length,
+      context
+    );
+    if (answer === void 0) return void 0;
+    answers.push({
+      id: question.id,
+      answer
+    });
+  }
+  return answers;
+}
+async function answerQuestion(question, questionNumber, totalQuestions, context) {
+  const recommendationChoice = `${RECOMMENDATION_PREFIX}${question.recommendation}`;
+  const choice = await context.ui.select(
+    formatQuestionPrompt(question, questionNumber, totalQuestions),
+    [recommendationChoice, CUSTOM_ANSWER]
+  );
+  if (choice === void 0) return void 0;
+  if (choice === recommendationChoice) return question.recommendation;
+  const answer = await context.ui.input(
+    `${formatQuestionPrompt(question, questionNumber, totalQuestions)}
+
+Custom answer`,
+    "Type your answer"
+  );
+  return answer === void 0 || answer.trim().length === 0 ? void 0 : answer;
+}
+function formatQuestionPrompt(question, questionNumber, totalQuestions) {
+  return [
+    `Sideroom \xB7 Grilling question ${questionNumber}/${totalQuestions}`,
+    question.title,
+    question.question,
+    `Recommended answer: ${question.recommendation}`
+  ].join("\n\n");
+}
+function createObserver(trace, progress) {
+  return (event) => {
+    trace.push(event);
+    progress.report(event);
+  };
+}
+function modelReference(context) {
+  const model = context.model;
+  return model === void 0 ? void 0 : `${model.provider}/${model.id}`;
+}
+function recordRun(pi, context, language, result, trace) {
+  const details = {
+    version: VERSION,
+    source: "sideroom-pi-extension",
+    cwd: context.cwd,
+    language,
+    model: modelReference(context),
+    status: result.status,
+    trace
+  };
+  pi.appendEntry(TRACE_TYPE, details);
+  pi.sendMessage(
+    {
+      customType: TRACE_TYPE,
+      display: true,
+      content: formatRun(result, trace),
+      details
+    },
+    { triggerTurn: false }
+  );
+}
+function formatRun(result, trace) {
+  const phases = trace.filter((event) => event.status === "completed").map((event) => event.phase).filter((phase, index, values) => values.indexOf(phase) === index);
+  const files = [
+    ...new Set(result.implementations.flatMap((item) => item.filesChanged))
+  ];
+  return [
+    `Sideroom ${result.status === "completed" ? "completed" : "failed"}`,
+    "Provenance: sideroom Pi extension \u2192 isolated Pi SDK role sessions.",
+    `Roles completed: ${phases.length === 0 ? "-" : phases.join(", ")}`,
+    `Files changed: ${files.length === 0 ? "-" : files.join(", ")}`,
+    `Findings: ${String(result.findings.length)}`,
+    result.summary
+  ].join("\n");
+}
+var PipelineProgress = class {
+  constructor(context) {
+    this.context = context;
+  }
+  activePhase;
+  awaitingDecision = false;
+  message = "starting isolated Pi SDK role sessions";
+  completed = /* @__PURE__ */ new Set();
+  start() {
+    this.render();
+  }
+  report(event) {
+    const label = PHASE_LABELS[event.phase];
+    const task = event.taskId === void 0 ? "" : ` ${event.taskId}`;
+    const round = event.round === void 0 ? "" : ` (round ${event.round})`;
+    this.activePhase = event.phase;
+    this.awaitingDecision = event.status === "awaiting-input";
+    if (event.status === "completed") this.completed.add(event.phase);
+    this.message = stageMessage(event.status, `${label}${task}${round}`);
+    this.render();
+  }
+  awaitDecision(questionNumber, totalQuestions) {
+    this.activePhase = "grilling";
+    this.awaitingDecision = true;
+    this.message = `awaiting your decision (question ${questionNumber}/${totalQuestions})`;
+    this.render();
+  }
+  clear() {
+    this.context.ui.setWidget(PROGRESS_WIDGET_KEY, void 0);
+  }
+  render() {
+    this.context.ui.setStatus(STATUS_KEY, `Sideroom: ${this.message}`);
+    this.context.ui.setWidget(
+      PROGRESS_WIDGET_KEY,
+      [
+        "Sideroom pipeline",
+        `Status: ${this.message}`,
+        "Runtime: direct Pi SDK sessions \xB7 isolated roles \xB7 no fallback agents",
+        "",
+        ...PIPELINE_PHASES.map((phase) => this.renderPhase(phase))
+      ],
+      { placement: "aboveEditor" }
+    );
+  }
+  renderPhase(phase) {
+    if (this.completed.has(phase)) return `\u2713 ${PHASE_LABELS[phase]}`;
+    if (this.activePhase === phase) {
+      return this.awaitingDecision && phase === "grilling" ? `\u25CF ${PHASE_LABELS[phase]} \u2014 awaiting your decision` : `\u25CF ${PHASE_LABELS[phase]} \u2014 running`;
+    }
+    return `\u25CB ${PHASE_LABELS[phase]}`;
+  }
+};
+function stageMessage(status, subject) {
+  if (status === "awaiting-input") return `${subject}: awaiting your decisions`;
+  if (status === "completed") return `${subject}: completed`;
+  if (status === "failed") return `${subject}: failed`;
+  return `${subject}: running`;
+}
+export {
+  registerSideroom as default
+};