muonroi-cli 1.4.0 → 1.4.1

package/src/product-loop/discover.ts

@@ -1,159 +0,0 @@
-import { promises as fs } from "node:fs";
-import * as path from "node:path";
-
-/**
- * High-confidence project discovery for /ideal — runs before gather so the
- * loop does not ask the user about things the codebase already answers (stack,
- * test command). Soft dimensions like persona/core-features/cost-tolerance are
- * deliberately NOT auto-filled (low signal-to-noise from README scraping).
- */
-export interface DiscoveryResult {
-  hasProject: boolean;
-  /** Maps SEED_DIMENSIONS.id → confident answer. Only populated when evidence is unambiguous. */
-  prefilled: Map<string, string>;
-  /** Audit trail: which file proved each dimension. */
-  evidence: Array<{ dim: string; source: string; value: string }>;
-  /** Human-readable summary line per discovery (for the streamed chunk). */
-  notes: string[];
-}
-
-interface ManifestProbe {
-  filename: string;
-  language: string;
-  testHint?: string;
-}
-
-const MANIFESTS: ManifestProbe[] = [
-  { filename: "package.json", language: "TypeScript/JavaScript (Node.js)" },
-  { filename: "pyproject.toml", language: "Python", testHint: "pytest" },
-  { filename: "requirements.txt", language: "Python", testHint: "pytest" },
-  { filename: "Cargo.toml", language: "Rust", testHint: "cargo test" },
-  { filename: "go.mod", language: "Go", testHint: "go test ./..." },
-  { filename: "pom.xml", language: "Java (Maven)", testHint: "mvn test" },
-  { filename: "build.gradle", language: "Java/Kotlin (Gradle)", testHint: "gradle test" },
-  { filename: "Gemfile", language: "Ruby", testHint: "bundle exec rspec" },
-  { filename: "composer.json", language: "PHP", testHint: "composer test" },
-];
-
-export async function discoverProject(cwd: string | undefined): Promise<DiscoveryResult> {
-  const result: DiscoveryResult = {
-    hasProject: false,
-    prefilled: new Map(),
-    evidence: [],
-    notes: [],
-  };
-  if (!cwd) return result;
-
-  for (const probe of MANIFESTS) {
-    const found = await readIfExists(path.join(cwd, probe.filename));
-    if (!found) continue;
-    result.hasProject = true;
-
-    if (probe.filename === "package.json") {
-      await fillFromPackageJson(found, probe, result);
-    } else {
-      // Non-package.json manifests: language is enough for tech-constraints; test hint
-      // is best-effort (does not parse contents for fine-grained framework detection).
-      addPrefill(
-        result,
-        "tech-constraints",
-        probe.language,
-        probe.filename,
-        `Detected ${probe.language} from ${probe.filename}`,
-      );
-      if (probe.testHint) {
-        addPrefill(
-          result,
-          "success-metric",
-          `automated tests pass (${probe.testHint})`,
-          probe.filename,
-          `Test runner inferred: ${probe.testHint}`,
-        );
-      }
-    }
-    break;
-  }
-
-  return result;
-}
-
-async function fillFromPackageJson(content: string, probe: ManifestProbe, out: DiscoveryResult): Promise<void> {
-  let pkg: any = null;
-  try {
-    pkg = JSON.parse(content);
-  } catch {
-    addPrefill(
-      out,
-      "tech-constraints",
-      probe.language,
-      probe.filename,
-      `Detected ${probe.language} from package.json (unparseable, using default stack)`,
-    );
-    return;
-  }
-
-  const frameworks = detectNodeFrameworks(pkg);
-  const stack = frameworks.length > 0 ? `${probe.language} + ${frameworks.join(", ")}` : probe.language;
-  addPrefill(out, "tech-constraints", stack, probe.filename, `Stack: ${stack}`);
-
-  const testCmd: string | undefined = pkg?.scripts?.test;
-  if (testCmd && !/echo .*no test/i.test(testCmd)) {
-    addPrefill(
-      out,
-      "success-metric",
-      `automated tests pass via \`npm test\` (${testCmd.slice(0, 80)})`,
-      probe.filename,
-      `Test command: ${testCmd.slice(0, 80)}`,
-    );
-  }
-}
-
-function detectNodeFrameworks(pkg: any): string[] {
-  const out: string[] = [];
-  const deps: Record<string, string> = { ...(pkg?.dependencies ?? {}), ...(pkg?.devDependencies ?? {}) };
-  if (deps.react || deps.next) out.push("React/Next.js");
-  if (deps.vue || deps.nuxt) out.push("Vue/Nuxt");
-  if (deps["@angular/core"]) out.push("Angular");
-  if (deps.express || deps.fastify || deps.koa) out.push("Node.js HTTP");
-  if (deps.nestjs || deps["@nestjs/core"]) out.push("NestJS");
-  if (deps.vitest) out.push("Vitest");
-  else if (deps.jest) out.push("Jest");
-  return out;
-}
-
-function addPrefill(out: DiscoveryResult, dim: string, value: string, source: string, note: string): void {
-  if (out.prefilled.has(dim)) return;
-  out.prefilled.set(dim, value);
-  out.evidence.push({ dim, source, value });
-  out.notes.push(note);
-}
-
-async function readIfExists(p: string): Promise<string | null> {
-  try {
-    return await fs.readFile(p, "utf-8");
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Format DiscoveryResult into a single content chunk for the UI. Returns null
- * when nothing was detected (caller can skip the chunk).
- */
-export function formatDiscoverySummary(d: DiscoveryResult): string | null {
-  if (!d.hasProject) {
-    return "No existing project manifest detected — proceeding as greenfield.";
-  }
-  if (d.prefilled.size === 0) {
-    return "Existing project detected, but no high-confidence dimensions could be auto-filled.";
-  }
-  const lines = ["**Discovered from your project:**"];
-  for (const ev of d.evidence) {
-    lines.push(`- \`${ev.dim}\` ← ${ev.value} _(from ${ev.source})_`);
-  }
-  lines.push("");
-  lines.push(
-    `Skipping ${d.prefilled.size} clarification question${d.prefilled.size === 1 ? "" : "s"}; you'll only be asked the rest.`,
-  );
-  return lines.join("\n");
-}

package/src/product-loop/discovery-context-format.ts

@@ -1,56 +0,0 @@
-// src/product-loop/discovery-context-format.ts
-import type { ProjectContext } from "./types.js";
-
-/**
- * Format a ProjectContext for inclusion in leader/council prompts.
- *
- * `ProjectContext.context` is typed as fully-populated but at runtime it
- * is `Partial<DiscoveryContext>` (see buildProjectContextFromState — the
- * cast lies about coverage). Any field may be missing when:
- *   - the interview was aborted mid-way
- *   - a prefilled-flag-without-prefill-value combination shipped (was the
- *     case for backendStack pre-fix — see session e2660a052918 crash:
- *     "undefined is not an object (evaluating 'ctx.context.backendStack.language')")
- *   - a skipped non-required question
- *
- * Every nested access must be guarded so the formatter NEVER throws —
- * the result is consumed by leader prompts that fail-open on missing
- * details, but crash on missing properties.
- */
-export function formatProjectContextForPrompt(ctx: ProjectContext): string {
-  const c = ctx.context as Partial<ProjectContext["context"]>;
-  const lines: string[] = [];
-  lines.push(`Idea: ${ctx.idea}`);
-  if (c.productType) lines.push(`Product type: ${c.productType}`);
-  if (c.targetPlatform?.length) lines.push(`Platform: ${c.targetPlatform.join(", ")}`);
-  if (c.audience) {
-    lines.push(
-      `Audience: ${c.audience.persona ?? "(unknown)"} (scale ${c.audience.scale ?? "?"}, ${c.audience.geography ?? "?"})`,
-    );
-  }
-  if (c.backendArchitecture) lines.push(`Backend arch: ${c.backendArchitecture}`);
-  if (c.backendStack?.language || c.backendStack?.framework) {
-    const lang = c.backendStack.language ?? "(unspecified)";
-    const fw = c.backendStack.framework ?? "(unspecified)";
-    const runtime = c.backendStack.runtime ? ` on ${c.backendStack.runtime}` : "";
-    lines.push(`Backend stack: ${lang} / ${fw}${runtime}`);
-  }
-  if (c.dbStrategy) {
-    lines.push(`Database: ${c.dbStrategy.mode ?? "(unspecified)"} ${c.dbStrategy.engine ?? ""}`.trimEnd());
-  }
-  if (c.frontendApproach) {
-    const harness = c.frontendApproach.agentHarness
-      ? ` (harness: @muonroi/agent-harness-${c.frontendApproach.agentHarness})`
-      : "";
-    lines.push(
-      `Frontend: ${c.frontendApproach.library ?? "(none)"} + ${c.frontendApproach.framework ?? "(none)"}${harness}`,
-    );
-  }
-  if (c.deployment) {
-    const provider = c.deployment.provider ? ` on ${c.deployment.provider}` : "";
-    lines.push(`Deployment: ${c.deployment.target ?? "(unspecified)"}${provider}`);
-  }
-  const fePolicy = ctx.recommendations?.constraints?.fePolicy;
-  if (fePolicy) lines.push(`Constraints: fePolicy=${fePolicy}`);
-  return lines.join("\n");
-}

package/src/product-loop/discovery-council-runner.ts

@@ -1,78 +0,0 @@
-// src/product-loop/discovery-council-runner.ts
-import type { CouncilDebateRunner, DebateChunk } from "./discovery-recommender.js";
-
-// NOTE: DebatePlan + CouncilConfig shapes live in src/council/types.ts. We do not import them here
-// to keep the discovery module decoupled; we mirror the shape via plain objects passed to runDebate.
-
-export interface Big4PlanInput {
-  questionId: string;
-  contextSummary: string;
-}
-
-export function buildBig4DebatePlan(input: Big4PlanInput) {
-  return {
-    intentSummary: `Decide ${input.questionId}. Context: ${input.contextSummary}`,
-    stances: [
-      { name: "pragmatist", lens: "team skill, delivery speed, ecosystem maturity" },
-      { name: "scaler", lens: "audience scale, performance, future growth" },
-      { name: "cost-optimizer", lens: "infra cost, dev hours, total TCO" },
-    ],
-    outputShape: {
-      primary: "string",
-      alternatives: "string[]",
-      rationale: "string",
-    },
-    plannedRounds: 1,
-  };
-}
-
-export interface RealCouncilDeps {
-  runDebate: (spec: any, config: any, llm: any) => AsyncIterable<any>;
-  llm: any;
-  leaderModelId: string;
-  participants: any[];
-}
-
-export function buildDiscoveryDebateRunner(deps: RealCouncilDeps): CouncilDebateRunner {
-  return {
-    runDebate: ({ questionId, intentSummary, context }) => {
-      const plan = buildBig4DebatePlan({
-        questionId,
-        contextSummary: intentSummary,
-      });
-      const spec = { idea: intentSummary, clarifications: [] };
-      const config = {
-        topic: questionId,
-        conversationContext: JSON.stringify(context),
-        leaderModelId: deps.leaderModelId,
-        participants: deps.participants,
-        debatePlan: plan,
-        costAware: true,
-      };
-      return (async function* () {
-        for await (const chunk of deps.runDebate(spec, config, deps.llm)) {
-          // map StreamChunk → DebateChunk
-          const mapped = mapStreamChunkToDebateChunk(chunk);
-          if (mapped) yield mapped;
-        }
-      })();
-    },
-  };
-}
-
-function mapStreamChunkToDebateChunk(chunk: any): DebateChunk | null {
-  if (!chunk || typeof chunk !== "object") return null;
-  if (chunk.kind === "stance-output" && chunk.stance) {
-    return {
-      type: "stance",
-      name: chunk.stance,
-      value: chunk.primary ?? chunk.value,
-      rationale: chunk.rationale ?? "",
-      confidence: chunk.confidence,
-    };
-  }
-  if (chunk.kind === "cost" && typeof chunk.usd === "number") {
-    return { type: "cost", costUsd: chunk.usd };
-  }
-  return null;
-}

package/src/product-loop/discovery-detection.ts

@@ -1,161 +0,0 @@
-// src/product-loop/discovery-detection.ts
-import { promises as fs } from "node:fs";
-import * as path from "node:path";
-import type { ExistingProjectSignals, ManifestDetection } from "./types.js";
-
-const MANIFEST_PATTERNS: Array<{ name: string; type: ManifestDetection["type"]; lang: string }> = [
-  { name: "package.json", type: "package.json", lang: "TypeScript" },
-  { name: "Cargo.toml", type: "Cargo.toml", lang: "Rust" },
-  { name: "go.mod", type: "go.mod", lang: "Go" },
-  { name: "pyproject.toml", type: "pyproject.toml", lang: "Python" },
-  { name: "pom.xml", type: "pom.xml", lang: "Java" },
-  { name: "build.gradle", type: "build.gradle", lang: "Java" },
-];
-
-const SRC_EXT_TO_LANG: Record<string, string> = {
-  ".ts": "TypeScript",
-  ".tsx": "TypeScript",
-  ".js": "JavaScript",
-  ".jsx": "JavaScript",
-  ".mjs": "JavaScript",
-  ".rs": "Rust",
-  ".go": "Go",
-  ".py": "Python",
-  ".cs": "C#",
-  ".java": "Java",
-  ".kt": "Kotlin",
-};
-
-const _DOC_FILES = new Set(["README.md", "LICENSE", "LICENSE.md", "CONTRIBUTING.md", "CHANGELOG.md", ".gitignore"]);
-
-async function pathExists(p: string): Promise<boolean> {
-  try {
-    await fs.access(p);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-async function detectManifest(cwd: string, name: string): Promise<ManifestDetection | null> {
-  const file = path.join(cwd, name);
-  if (!(await pathExists(file))) return null;
-  const pattern = MANIFEST_PATTERNS.find((p) => p.name === name);
-  if (!pattern) return null;
-  let raw = "";
-  try {
-    raw = await fs.readFile(file, "utf8");
-  } catch {
-    return { file, type: pattern.type, weight: 0, inferredLang: pattern.lang, inferredFrameworks: [] };
-  }
-  const frameworks = inferFrameworks(raw, pattern.type);
-  const depCount = countDeps(raw, pattern.type);
-  const weight = Math.min(1, depCount / 5);
-  return { file, type: pattern.type, weight, inferredLang: pattern.lang, inferredFrameworks: frameworks };
-}
-
-function inferFrameworks(raw: string, type: ManifestDetection["type"]): string[] {
-  const fws: string[] = [];
-  const text = raw.toLowerCase();
-  if (type === "package.json") {
-    for (const fw of ["next", "react", "vue", "svelte", "nest", "express", "fastify", "vite"]) {
-      if (text.includes(`"${fw}`)) fws.push(fw);
-    }
-  } else if (type === "Cargo.toml") {
-    for (const fw of ["actix", "axum", "rocket", "tokio"]) {
-      if (text.includes(`${fw} =`) || text.includes(`${fw}=`)) fws.push(fw);
-    }
-  } else if (type === "go.mod") {
-    for (const fw of ["gin", "echo", "fiber", "chi"]) {
-      if (text.includes(`/${fw}`)) fws.push(fw);
-    }
-  } else if (type === "pyproject.toml") {
-    for (const fw of ["django", "fastapi", "flask", "pydantic"]) {
-      if (text.includes(fw)) fws.push(fw);
-    }
-  }
-  return Array.from(new Set(fws));
-}
-
-function countDeps(raw: string, type: ManifestDetection["type"]): number {
-  try {
-    if (type === "package.json") {
-      const pkg = JSON.parse(raw);
-      return Object.keys(pkg.dependencies ?? {}).length + Object.keys(pkg.devDependencies ?? {}).length;
-    }
-  } catch {
-    return 0;
-  }
-  // Heuristic for non-JSON manifests: count "=" lines
-  return raw.split(/\r?\n/).filter((l) => l.includes("=") && !l.trim().startsWith("#")).length;
-}
-
-const IGNORED_DIRS = new Set(["node_modules", ".git", "target", "dist", "build", ".next", "venv", "__pycache__"]);
-
-async function countSrcFiles(cwd: string): Promise<{ count: number; langs: Set<string> }> {
-  let count = 0;
-  const langs = new Set<string>();
-  async function walk(dir: string, depth: number): Promise<void> {
-    if (depth > 5) return;
-    let entries: { name: string; isDir: boolean }[] = [];
-    try {
-      const dirents = await fs.readdir(dir, { withFileTypes: true });
-      entries = dirents.map((d) => ({ name: d.name, isDir: d.isDirectory() }));
-    } catch {
-      return;
-    }
-    for (const e of entries) {
-      if (e.name.startsWith(".") && e.name !== ".git") continue;
-      if (IGNORED_DIRS.has(e.name)) continue;
-      const full = path.join(dir, e.name);
-      if (e.isDir) {
-        await walk(full, depth + 1);
-      } else {
-        const ext = path.extname(e.name);
-        const lang = SRC_EXT_TO_LANG[ext];
-        if (lang) {
-          count += 1;
-          langs.add(lang);
-        }
-      }
-    }
-  }
-  await walk(cwd, 0);
-  return { count, langs };
-}
-
-export async function detectExistingProject(cwd: string): Promise<ExistingProjectSignals> {
-  const isGitRepo = await pathExists(path.join(cwd, ".git"));
-  const hasCommitHistory = isGitRepo && (await pathExists(path.join(cwd, ".git", "HEAD")));
-
-  const manifests: ManifestDetection[] = [];
-  for (const pattern of MANIFEST_PATTERNS) {
-    const m = await detectManifest(cwd, pattern.name);
-    if (m) manifests.push(m);
-  }
-
-  const { count: srcFileCount, langs: detectedLangs } = await countSrcFiles(cwd);
-
-  const languages = Array.from(new Set([...manifests.map((m) => m.inferredLang), ...detectedLangs]));
-  const frameworks = Array.from(new Set(manifests.flatMap((m) => m.inferredFrameworks)));
-
-  const classification = classify(cwd, manifests, srcFileCount);
-
-  return { isGitRepo, hasCommitHistory, srcFileCount, manifests, languages, frameworks, classification };
-}
-
-function classify(
-  _cwd: string,
-  manifests: ManifestDetection[],
-  srcFileCount: number,
-): ExistingProjectSignals["classification"] {
-  if (srcFileCount === 0 && manifests.length === 0) return "greenfield";
-  // Polyglot (multiple manifests) = ambiguous — cannot confidently pick one stack
-  if (manifests.length > 1) return "ambiguous";
-  const singleManifest = manifests.length === 1 ? manifests[0] : null;
-  // Empty manifest (no deps, weight=0) with src files = ambiguous (might be scaffold)
-  if (!singleManifest || singleManifest.weight === 0) return "ambiguous";
-  // Single manifest with any declared deps + enough src files = existing
-  if (srcFileCount > 5) return "existing";
-  return "ambiguous";
-}