helloloop 0.2.1 → 0.6.1

package/src/analyze_user_input.mjs

@@ -0,0 +1,321 @@
+import path from "node:path";
+
+import { classifyExplicitPath, pathExists, resolveAbsolute } from "./discovery_paths.mjs";
+import { normalizeEngineName } from "./engine_metadata.mjs";
+
+const DOC_SUFFIX = new Set([
+  ".md",
+  ".markdown",
+  ".mdx",
+  ".txt",
+  ".rst",
+  ".adoc",
+]);
+
+const ROLE_LABELS = {
+  docs: "开发文档",
+  repo: "项目路径",
+  input: "补充路径",
+  new_repo: "项目路径",
+};
+
+const SOURCE_LABELS = {
+  flag: "命令参数",
+  positional: "命令附带路径",
+  interactive: "交互确认",
+  interactive_new_repo: "交互确认",
+  workspace_single_doc: "工作区唯一文档候选",
+  workspace_single_repo: "工作区唯一项目候选",
+};
+
+function isProbablyPathToken(token) {
+  const value = String(token || "").trim();
+  if (!value) {
+    return false;
+  }
+
+  if (/^[A-Za-z]:[\\/]/.test(value) || /^\\\\/.test(value)) {
+    return true;
+  }
+
+  if (/^\.\.?([\\/]|$)/.test(value) || /^[~][\\/]/.test(value)) {
+    return true;
+  }
+
+  if (value.includes("/") || value.includes("\\")) {
+    return true;
+  }
+
+  return DOC_SUFFIX.has(path.extname(value).toLowerCase());
+}
+
+function normalizePathKey(targetPath) {
+  const resolved = path.resolve(String(targetPath || ""));
+  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+
+function isSamePath(left, right) {
+  return normalizePathKey(left) === normalizePathKey(right);
+}
+
+function createIssue(severity, message) {
+  return { severity, message: String(message || "").trim() };
+}
+
+function roleLabel(role) {
+  return ROLE_LABELS[role] || "路径";
+}
+
+function sourceLabel(source) {
+  return SOURCE_LABELS[source] || "输入";
+}
+
+function formatPathRef(ref) {
+  const label = roleLabel(ref.role);
+  const statusSuffix = ref.role === "new_repo" ? "，当前不存在，将按新项目创建" : "";
+  const suffix = ref.source ? `（来源：${sourceLabel(ref.source)}${statusSuffix}）` : "";
+  return `${label}：${String(ref.absolutePath || "").replaceAll("\\", "/")}${suffix}`;
+}
+
+function ensureSelectionSource(selectionSources, role, source) {
+  if (!selectionSources[role] && source) {
+    selectionSources[role] = source;
+  }
+}
+
+function pushDistinctRef(refs, role, absolutePath, source) {
+  const existing = refs.find((item) => item.role === role && isSamePath(item.absolutePath, absolutePath));
+  if (!existing) {
+    refs.push({ role, absolutePath, source });
+  }
+}
+
+function pushRoleConflict(issues, role, acceptedPath, incomingPath, acceptedSource, incomingSource) {
+  if (isSamePath(acceptedPath, incomingPath)) {
+    return;
+  }
+
+  issues.blocking.push(createIssue(
+    "blocking",
+    `同时给出了多个${roleLabel(role)}：${String(acceptedPath).replaceAll("\\", "/")}（${sourceLabel(acceptedSource)}） 与 ${String(incomingPath).replaceAll("\\", "/")}（${sourceLabel(incomingSource)}）。请只保留一个，或改用 ${role === "repo" ? "--repo" : "--docs"} 明确指定。`,
+  ));
+}
+
+function assignDocsPath({
+  absolutePath,
+  source,
+  explicitRefs,
+  issues,
+  selectionSources,
+  currentDocsPath,
+}) {
+  if (!currentDocsPath) {
+    pushDistinctRef(explicitRefs, "docs", absolutePath, source);
+    ensureSelectionSource(selectionSources, "docs", source);
+    return absolutePath;
+  }
+
+  pushRoleConflict(issues, "docs", currentDocsPath, absolutePath, selectionSources.docs || source, source);
+  pushDistinctRef(explicitRefs, "docs", absolutePath, source);
+  return currentDocsPath;
+}
+
+function assignRepoRoot({
+  absolutePath,
+  source,
+  explicitRefs,
+  issues,
+  selectionSources,
+  currentRepoRoot,
+  allowNewRepoRoot = false,
+}) {
+  if (!currentRepoRoot) {
+    pushDistinctRef(explicitRefs, allowNewRepoRoot ? "new_repo" : "repo", absolutePath, source);
+    ensureSelectionSource(selectionSources, "repo", source);
+    return absolutePath;
+  }
+
+  pushRoleConflict(issues, "repo", currentRepoRoot, absolutePath, selectionSources.repo || source, source);
+  pushDistinctRef(explicitRefs, allowNewRepoRoot ? "new_repo" : "repo", absolutePath, source);
+  return currentRepoRoot;
+}
+
+export function normalizeAnalyzeOptions(rawOptions = {}, cwd = process.cwd()) {
+  const options = {
+    ...rawOptions,
+    requiredDocs: Array.isArray(rawOptions.requiredDocs) ? [...rawOptions.requiredDocs] : [],
+    constraints: Array.isArray(rawOptions.constraints) ? [...rawOptions.constraints] : [],
+  };
+  const rawPositionals = Array.isArray(rawOptions.positionalArgs) ? rawOptions.positionalArgs : [];
+  const positionals = [...rawPositionals];
+  const explicitRefs = [];
+  const requestTokens = [];
+  const issues = {
+    blocking: [],
+    warnings: [],
+  };
+  const selectionSources = {
+    ...(rawOptions.selectionSources || {}),
+  };
+
+  let docsPath = options.docsPath ? resolveAbsolute(options.docsPath, cwd) : "";
+  let repoRoot = options.repoRoot ? resolveAbsolute(options.repoRoot, cwd) : "";
+  let inputPath = options.inputPath ? resolveAbsolute(options.inputPath, cwd) : "";
+  let allowNewRepoRoot = Boolean(options.allowNewRepoRoot);
+  let engine = normalizeEngineName(options.engine);
+  let engineSource = options.engineSource || (engine ? "flag" : "");
+
+  if (!engine && positionals.length) {
+    const firstToken = String(positionals[0] || "").trim();
+    const leadingEngine = normalizeEngineName(firstToken);
+    if (leadingEngine && firstToken.toLowerCase() === leadingEngine) {
+      engine = leadingEngine;
+      engineSource = "leading_positional";
+      positionals.shift();
+    }
+  }
+
+  if (docsPath) {
+    ensureSelectionSource(selectionSources, "docs", rawOptions.selectionSources?.docs || "flag");
+  }
+  if (repoRoot) {
+    ensureSelectionSource(selectionSources, "repo", rawOptions.selectionSources?.repo || "flag");
+    if (allowNewRepoRoot && !pathExists(repoRoot)) {
+      pushDistinctRef(explicitRefs, "new_repo", repoRoot, selectionSources.repo);
+    }
+  }
+
+  for (const token of positionals) {
+    if (!isProbablyPathToken(token)) {
+      requestTokens.push(token);
+      continue;
+    }
+
+    const absolutePath = resolveAbsolute(token, cwd);
+    if (pathExists(absolutePath)) {
+      const classified = classifyExplicitPath(absolutePath);
+      if (classified.kind === "docs") {
+        docsPath = assignDocsPath({
+          absolutePath: classified.absolutePath,
+          source: "positional",
+          explicitRefs,
+          issues,
+          selectionSources,
+          currentDocsPath: docsPath,
+        });
+        continue;
+      }
+      if (classified.kind === "repo") {
+        repoRoot = assignRepoRoot({
+          absolutePath: classified.absolutePath,
+          source: "positional",
+          explicitRefs,
+          issues,
+          selectionSources,
+          currentRepoRoot: repoRoot,
+        });
+        continue;
+      }
+      if ((classified.kind === "workspace" || classified.kind === "directory") && docsPath) {
+        repoRoot = assignRepoRoot({
+          absolutePath: classified.absolutePath,
+          source: "positional",
+          explicitRefs,
+          issues,
+          selectionSources,
+          currentRepoRoot: repoRoot,
+        });
+        continue;
+      }
+      if (!inputPath) {
+        inputPath = classified.absolutePath;
+        pushDistinctRef(explicitRefs, "input", classified.absolutePath, "positional");
+        continue;
+      }
+    } else if (!repoRoot) {
+      repoRoot = absolutePath;
+      allowNewRepoRoot = true;
+      ensureSelectionSource(selectionSources, "repo", "positional");
+      pushDistinctRef(explicitRefs, "new_repo", absolutePath, "positional");
+      continue;
+    } else {
+      pushRoleConflict(issues, "repo", repoRoot, absolutePath, selectionSources.repo || "positional", "positional");
+      pushDistinctRef(explicitRefs, "new_repo", absolutePath, "positional");
+      continue;
+    }
+
+    requestTokens.push(token);
+  }
+
+  if (options.dryRun && options.yes) {
+    issues.warnings.push(createIssue(
+      "warning",
+      "同时传入了 --dry-run 和 -y；本次仍按 --dry-run 只分析，不自动执行。",
+    ));
+  }
+
+  const userRequestText = requestTokens.join(" ").trim();
+
+  options.docsPath = docsPath;
+  options.repoRoot = repoRoot;
+  options.inputPath = inputPath;
+  options.allowNewRepoRoot = allowNewRepoRoot;
+  options.engine = engine;
+  options.engineSource = engineSource;
+  options.selectionSources = selectionSources;
+  options.userRequestText = userRequestText;
+  options.inputIssues = issues;
+  options.userIntent = {
+    rawPositionals,
+    explicitRefs,
+    requestText: userRequestText,
+    issues,
+    selectionSources,
+    explicitEngine: engine,
+    explicitEngineSource: engineSource,
+  };
+
+  return options;
+}
+
+export function hasBlockingInputIssues(inputIssues = {}) {
+  return Array.isArray(inputIssues.blocking) && inputIssues.blocking.length > 0;
+}
+
+export function renderInputIssueLines(inputIssues = {}) {
+  return [
+    ...(Array.isArray(inputIssues.blocking) ? inputIssues.blocking : []),
+    ...(Array.isArray(inputIssues.warnings) ? inputIssues.warnings : []),
+  ].map((item) => `- ${item.message}`);
+}
+
+export function renderBlockingInputIssueMessage(inputIssues = {}) {
+  const lines = renderInputIssueLines({
+    blocking: Array.isArray(inputIssues.blocking) ? inputIssues.blocking : [],
+  });
+  if (!lines.length) {
+    return "";
+  }
+
+  return [
+    "检测到命令输入存在冲突：",
+    ...lines,
+    "",
+    "请整理后重试；建议只保留一个开发文档路径和一个项目路径，必要时改用 `--docs` / `--repo` 明确指定。",
+  ].join("\n");
+}
+
+export function renderUserIntentLines(userIntent = {}) {
+  const lines = [];
+  const explicitRefs = Array.isArray(userIntent.explicitRefs) ? userIntent.explicitRefs : [];
+  const requestText = String(userIntent.requestText || "").trim();
+
+  if (explicitRefs.length) {
+    lines.push(...explicitRefs.map((ref) => formatPathRef(ref)));
+  }
+  if (requestText) {
+    lines.push(`附加要求：${requestText}`);
+  }
+
+  return lines;
+}

package/src/analyzer.mjs

@@ -6,7 +6,11 @@ import { loadPolicy, loadProjectConfig, scaffoldIfMissing, writeStateMarkdown, w
 import { createContext } from "./context.mjs";
 import { discoverWorkspace } from "./discovery.mjs";
 import { readDocumentPackets } from "./doc_loader.mjs";
-import { runCodexTask } from "./process.mjs";
+import {
+  rememberEngineSelection,
+  resolveEngineSelection,
+} from "./engine_selection.mjs";
+import { runEngineTask } from "./process.mjs";
 import { buildAnalysisPrompt } from "./analyze_prompt.mjs";
 
 function renderAnalysisState(context, backlog, analysis) {
@@ -45,33 +49,67 @@ function sanitizeTask(task) {
 }
 
 function normalizeAnalysisPayload(payload, docsEntries) {
+  const summary = {
+    currentState: String(payload?.summary?.currentState || "").trim() || "已完成接续分析。",
+    implemented: Array.isArray(payload?.summary?.implemented) ? payload.summary.implemented.map((item) => String(item || "").trim()).filter(Boolean) : [],
+    remaining: Array.isArray(payload?.summary?.remaining) ? payload.summary.remaining.map((item) => String(item || "").trim()).filter(Boolean) : [],
+    nextAction: String(payload?.summary?.nextAction || "").trim() || "查看下一任务。",
+  };
   const tasks = Array.isArray(payload.tasks)
     ? payload.tasks.map((task) => sanitizeTask(task)).filter((task) => (
       task.id && task.title && task.goal && task.acceptance.length
     ))
     : [];
 
-  if (!tasks.length) {
-    throw new Error("Codex 分析结果无效：未生成可用任务。");
+  if (!tasks.length && summary.remaining.length) {
+    throw new Error("分析结果无效：仍存在剩余工作，但未生成可用任务。");
   }
 
+  const requestInterpretation = payload?.requestInterpretation && typeof payload.requestInterpretation === "object"
+    ? {
+      summary: String(payload.requestInterpretation.summary || "").trim(),
+      priorities: Array.isArray(payload.requestInterpretation.priorities)
+        ? payload.requestInterpretation.priorities.map((item) => String(item || "").trim()).filter(Boolean)
+        : [],
+      cautions: Array.isArray(payload.requestInterpretation.cautions)
+        ? payload.requestInterpretation.cautions.map((item) => String(item || "").trim()).filter(Boolean)
+        : [],
+    }
+    : null;
+  const repoDecision = payload?.repoDecision && typeof payload.repoDecision === "object"
+    ? {
+      compatibility: ["compatible", "conflict", "uncertain"].includes(String(payload.repoDecision.compatibility || ""))
+        ? String(payload.repoDecision.compatibility)
+        : "compatible",
+      action: ["continue_existing", "confirm_rebuild", "start_new"].includes(String(payload.repoDecision.action || ""))
+        ? String(payload.repoDecision.action)
+        : "continue_existing",
+      reason: String(payload.repoDecision.reason || "").trim(),
+    }
+    : null;
+
   return {
     project: String(payload.project || "").trim() || "helloloop-project",
-    summary: {
-      currentState: String(payload?.summary?.currentState || "").trim() || "已完成接续分析。",
-      implemented: Array.isArray(payload?.summary?.implemented) ? payload.summary.implemented.map((item) => String(item || "").trim()).filter(Boolean) : [],
-      remaining: Array.isArray(payload?.summary?.remaining) ? payload.summary.remaining.map((item) => String(item || "").trim()).filter(Boolean) : [],
-      nextAction: String(payload?.summary?.nextAction || "").trim() || "查看下一任务。",
-    },
+    summary,
     constraints: Array.isArray(payload.constraints)
       ? payload.constraints.map((item) => String(item || "").trim()).filter(Boolean)
       : [],
+    requestInterpretation: requestInterpretation && (
+      requestInterpretation.summary
+      || requestInterpretation.priorities.length
+      || requestInterpretation.cautions.length
+    )
+      ? requestInterpretation
+      : null,
+    repoDecision: repoDecision && repoDecision.reason
+      ? repoDecision
+      : null,
     tasks,
     requiredDocs: docsEntries,
   };
 }
 
-function buildAnalysisSummaryText(context, analysis, backlog) {
+function buildAnalysisSummaryText(context, analysis, backlog, engineResolution) {
   const summary = summarizeBacklog(backlog);
   const nextTask = selectNextTask(backlog);
 
@@ -79,6 +117,7 @@ function buildAnalysisSummaryText(context, analysis, backlog) {
     "HelloLoop 已完成接续分析。",
     `项目仓库：${context.repoRoot}`,
     `开发文档：${analysis.requiredDocs.join(", ")}`,
+    `执行引擎：${engineResolution?.displayName || "未记录"}`,
     "",
     "当前进度：",
     analysis.summary.currentState,
@@ -92,29 +131,27 @@ function buildAnalysisSummaryText(context, analysis, backlog) {
   ].join("\n");
 }
 
-export async function analyzeWorkspace(options = {}) {
-  const discovery = discoverWorkspace({
-    cwd: options.cwd,
-    inputPath: options.inputPath,
-    repoRoot: options.repoRoot,
-    docsPath: options.docsPath,
-    configDirName: options.configDirName,
-  });
-
-  if (!discovery.ok) {
+async function analyzeResolvedWorkspace(context, discovery, options = {}) {
+  scaffoldIfMissing(context);
+  const policy = loadPolicy(context);
+  let engineResolution = options.engineResolution?.ok
+    ? options.engineResolution
+    : await resolveEngineSelection({
+      context,
+      policy,
+      options,
+      interactive: !options.yes,
+    });
+  if (!engineResolution.ok) {
     return {
       ok: false,
-      code: discovery.code,
-      summary: discovery.message,
+      code: engineResolution.code,
+      summary: engineResolution.message,
+      discovery,
+      engineResolution,
     };
   }
 
-  const context = createContext({
-    repoRoot: discovery.repoRoot,
-    configDirName: options.configDirName,
-  });
-  scaffoldIfMissing(context);
-
   const existingProjectConfig = loadProjectConfig(context);
   const existingStateText = readTextIfExists(context.stateFile, "");
   const existingBacklogText = readTextIfExists(context.backlogFile, "");
@@ -125,46 +162,49 @@ export async function analyzeWorkspace(options = {}) {
 
   const prompt = buildAnalysisPrompt({
     repoRoot: context.repoRoot,
+    repoOriginallyExisted: discovery?.resolution?.repo?.exists !== false,
     docsEntries: discovery.docsEntries,
     docPackets,
     existingStateText,
     existingBacklogText,
     existingProjectConstraints: existingProjectConfig.constraints,
+    userIntent: options.userIntent,
   });
 
   const runDir = path.join(context.runsDir, `${nowIso().replaceAll(":", "-").replaceAll(".", "-")}-analysis`);
-  const policy = loadPolicy(context);
   const schemaFile = path.join(context.templatesDir, "analysis-output.schema.json");
-  const codexResult = await runCodexTask({
+  let analysisResult = await runEngineTask({
+    engine: engineResolution.engine,
     context,
     prompt,
     runDir,
-    model: policy.codex.model,
-    executable: policy.codex.executable,
-    sandbox: policy.codex.sandbox,
-    dangerouslyBypassSandbox: policy.codex.dangerouslyBypassSandbox,
+    policy,
+    executionMode: "analyze",
     outputSchemaFile: schemaFile,
-    outputPrefix: "analysis",
-    jsonOutput: false,
+    outputPrefix: `${engineResolution.engine}-analysis`,
     skipGitRepoCheck: true,
   });
 
-  if (!codexResult.ok) {
+  if (!analysisResult.ok) {
     return {
       ok: false,
       code: "analysis_failed",
-      summary: codexResult.stderr || codexResult.stdout || "Codex 接续分析失败。",
+      summary: analysisResult.stderr || analysisResult.stdout || `${engineResolution.displayName} 接续分析失败。`,
+      engineResolution,
+      discovery,
     };
   }
 
   let payload;
   try {
-    payload = JSON.parse(codexResult.finalMessage);
+    payload = JSON.parse(analysisResult.finalMessage);
   } catch (error) {
     return {
       ok: false,
       code: "invalid_analysis_json",
-      summary: `Codex 分析结果无法解析为 JSON：${String(error?.message || error || "")}`,
+      summary: `${engineResolution.displayName} 分析结果无法解析为 JSON：${String(error?.message || error || "")}`,
+      engineResolution,
+      discovery,
     };
   }
 
@@ -179,11 +219,14 @@ export async function analyzeWorkspace(options = {}) {
   const projectConfig = {
     requiredDocs: analysis.requiredDocs,
     constraints: analysis.constraints.length ? analysis.constraints : existingProjectConfig.constraints,
+    defaultEngine: existingProjectConfig.defaultEngine,
+    lastSelectedEngine: engineResolution.engine,
     planner: existingProjectConfig.planner,
   };
 
   writeJson(context.backlogFile, backlog);
   writeJson(context.projectFile, projectConfig);
+  rememberEngineSelection(context, engineResolution, options);
   writeStateMarkdown(context, renderAnalysisState(context, backlog, analysis));
   writeStatus(context, {
     ok: true,
@@ -194,15 +237,97 @@ export async function analyzeWorkspace(options = {}) {
     summary: summarizeBacklog(backlog),
     message: analysis.summary.currentState,
   });
-  writeText(path.join(runDir, "analysis-summary.txt"), buildAnalysisSummaryText(context, analysis, backlog));
+  writeText(path.join(runDir, "analysis-summary.txt"), buildAnalysisSummaryText(context, analysis, backlog, engineResolution));
 
   return {
     ok: true,
     code: "analyzed",
     context,
     runDir,
+    engineResolution,
     analysis,
     backlog,
-    summary: buildAnalysisSummaryText(context, analysis, backlog),
+    summary: buildAnalysisSummaryText(context, analysis, backlog, engineResolution),
+    discovery,
   };
 }
+
+function buildCurrentWorkspaceDiscovery(context, docsEntries) {
+  return {
+    ok: true,
+    repoRoot: context.repoRoot,
+    docsEntries,
+    resolvedDocs: docsEntries,
+    resolution: {
+      repo: {
+        source: "current_repo",
+        sourceLabel: "当前项目",
+        confidence: "high",
+        confidenceLabel: "高",
+        path: context.repoRoot,
+        exists: true,
+        basis: [
+          "已在当前项目基础上执行主线终态复核。",
+        ],
+      },
+      docs: {
+        source: "existing_state",
+        sourceLabel: "已有 .helloloop 配置",
+        confidence: "high",
+        confidenceLabel: "高",
+        entries: docsEntries,
+        basis: [
+          "已复用 `.helloloop/project.json` 中记录的 requiredDocs。",
+        ],
+      },
+    },
+  };
+}
+
+export async function reanalyzeCurrentWorkspace(context, options = {}) {
+  const existingProjectConfig = loadProjectConfig(context);
+  const docsEntries = Array.isArray(options.requiredDocs) && options.requiredDocs.length
+    ? options.requiredDocs
+    : existingProjectConfig.requiredDocs;
+
+  if (!docsEntries.length) {
+    return {
+      ok: false,
+      code: "missing_docs",
+      summary: "当前 `.helloloop/project.json` 未记录 requiredDocs，无法执行主线终态复核。",
+      discovery: null,
+    };
+  }
+
+  return analyzeResolvedWorkspace(
+    context,
+    buildCurrentWorkspaceDiscovery(context, docsEntries),
+    options,
+  );
+}
+
+export async function analyzeWorkspace(options = {}) {
+  const discovery = discoverWorkspace({
+    cwd: options.cwd,
+    inputPath: options.inputPath,
+    repoRoot: options.repoRoot,
+    docsPath: options.docsPath,
+    configDirName: options.configDirName,
+    allowNewRepoRoot: options.allowNewRepoRoot,
+  });
+
+  if (!discovery.ok) {
+    return {
+      ok: false,
+      code: discovery.code,
+      summary: discovery.message,
+      discovery,
+    };
+  }
+
+  const context = createContext({
+    repoRoot: discovery.repoRoot,
+    configDirName: options.configDirName,
+  });
+  return analyzeResolvedWorkspace(context, discovery, options);
+}