nolo-cli 0.1.32 → 0.1.33

package/cli/buildPublishImportAnalysis.ts

@@ -1,242 +0,0 @@
-import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
-import { dirname, join, relative } from "node:path";
-
-function extractPackageNameFromImportPath(importPath: string): string {
-  if (importPath.startsWith("@")) {
-    const parts = importPath.split("/");
-    return parts.slice(0, 2).join("/");
-  }
-
-  const firstSlash = importPath.indexOf("/");
-  return firstSlash === -1 ? importPath : importPath.slice(0, firstSlash);
-}
-
-function extractModuleSpecifiers(content: string): string[] {
-  const specifiers = new Set<string>();
-  const importOrExportRegex =
-    /(?:import|export)\s+(?:(?:type\s+)?(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)\s+from\s+)?['"]([^'"]+)['"]/g;
-  const dynamicImportRegex = /import\(\s*['"]([^'"]+)['"]\s*\)/g;
-
-  let match: RegExpExecArray | null;
-  while ((match = importOrExportRegex.exec(content)) !== null) {
-    specifiers.add(match[1]);
-  }
-
-  while ((match = dynamicImportRegex.exec(content)) !== null) {
-    specifiers.add(match[1]);
-  }
-
-  return Array.from(specifiers);
-}
-
-export function extractExternalImports(content: string): string[] {
-  const imports = new Set<string>();
-  for (const importPath of extractModuleSpecifiers(content)) {
-    if (
-      importPath.startsWith(".") ||
-      importPath.startsWith("node:") ||
-      importPath.startsWith("/")
-    ) {
-      continue;
-    }
-    imports.add(extractPackageNameFromImportPath(importPath));
-  }
-  return Array.from(imports);
-}
-
-export function extractLocalRelativeImports(content: string): string[] {
-  return extractModuleSpecifiers(content).filter(
-    (importPath) => importPath.startsWith(".") && !importPath.startsWith("/")
-  );
-}
-
-export function extractWorkspaceDependencies(
-  manifest: Record<string, any>
-): string[] {
-  const deps: string[] = [];
-  for (const field of ["dependencies", "devDependencies", "peerDependencies"]) {
-    if (!manifest[field]) {
-      continue;
-    }
-    for (const [name, version] of Object.entries(manifest[field])) {
-      if (typeof version === "string" && version.startsWith("workspace:")) {
-        deps.push(name);
-      }
-    }
-  }
-  return deps;
-}
-
-export function findSiblingWorkspacePackageNames(sourceDir: string): string[] {
-  const packagesDir = join(sourceDir, "..");
-  const names: string[] = [];
-
-  for (const entry of readdirSync(packagesDir)) {
-    const pkgPath = join(packagesDir, entry, "package.json");
-    if (!existsSync(pkgPath)) {
-      continue;
-    }
-    try {
-      const manifest = JSON.parse(readFileSync(pkgPath, "utf8"));
-      if (typeof manifest.name === "string" && manifest.name.length > 0) {
-        names.push(manifest.name);
-      }
-    } catch {
-      // Ignore malformed sibling manifests while scanning workspace package names.
-    }
-  }
-
-  return names;
-}
-
-export function extractWorkspaceImports(
-  content: string,
-  workspacePackageNames: Set<string>
-): string[] {
-  const imports = new Set<string>();
-
-  for (const packageName of extractExternalImports(content)) {
-    if (workspacePackageNames.has(packageName)) {
-      imports.add(packageName);
-    }
-  }
-
-  const relativeWorkspaceImportRegex =
-    /(?:from\s+['"]\.\.\/([^./'"][^/'"]*)(?:\/[^'"]*)?['"]|import\(\s*['"]\.\.\/([^./'"][^/'"]*)(?:\/[^'"]*)?['"]\s*\))/g;
-
-  let match: RegExpExecArray | null;
-  while ((match = relativeWorkspaceImportRegex.exec(content)) !== null) {
-    const packageName = match[1] || match[2];
-    if (packageName && workspacePackageNames.has(packageName)) {
-      imports.add(packageName);
-    }
-  }
-
-  return Array.from(imports);
-}
-
-export function collectWorkspaceDependencies(
-  sourceDir: string,
-  manifest: Record<string, any>,
-  filesToCopy: string[]
-): string[] {
-  const workspaceDeps = new Set(extractWorkspaceDependencies(manifest));
-  const workspacePackageNames = new Set(findSiblingWorkspacePackageNames(sourceDir));
-
-  for (const filePath of collectTypeScriptSourceFiles(sourceDir, filesToCopy)) {
-    const content = readFileSync(filePath, "utf8");
-    for (const dep of extractWorkspaceImports(content, workspacePackageNames)) {
-      workspaceDeps.add(dep);
-    }
-  }
-
-  return Array.from(workspaceDeps);
-}
-
-export function findTypeScriptFiles(dir: string): string[] {
-  const files: string[] = [];
-
-  for (const entry of readdirSync(dir)) {
-    const fullPath = join(dir, entry);
-    const stat = statSync(fullPath);
-    if (stat.isDirectory()) {
-      files.push(...findTypeScriptFiles(fullPath));
-      continue;
-    }
-    if (stat.isFile() && fullPath.endsWith(".ts")) {
-      files.push(fullPath);
-    }
-  }
-
-  return files;
-}
-
-export function collectTypeScriptSourceFiles(
-  sourceDir: string,
-  filesToCopy: string[]
-): string[] {
-  const files: string[] = [];
-
-  for (const entry of filesToCopy) {
-    const sourcePath = join(sourceDir, entry);
-    if (!existsSync(sourcePath)) {
-      continue;
-    }
-    const stat = statSync(sourcePath);
-    if (stat.isDirectory()) {
-      files.push(...findTypeScriptFiles(sourcePath));
-      continue;
-    }
-    if (stat.isFile() && sourcePath.endsWith(".ts")) {
-      files.push(sourcePath);
-    }
-  }
-
-  return files;
-}
-
-function escapeRegex(text: string): string {
-  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-function createWorkspaceSpecifier(relativeFilePath: string, packageName: string, path = ""): string {
-  const fileDir = dirname(relativeFilePath);
-  const relativePackagePath = relative(fileDir === "." ? "" : fileDir, packageName).replace(
-    /\\/g,
-    "/"
-  );
-  const prefix = relativePackagePath.startsWith(".")
-    ? relativePackagePath
-    : `./${relativePackagePath}`;
-  return `${prefix}${path}`;
-}
-
-export function rewriteCrossPackageImports(
-  content: string,
-  workspaceDeps: string[],
-  relativeFilePath = ""
-): string {
-  if (workspaceDeps.length === 0) {
-    return content;
-  }
-
-  const patterns = workspaceDeps.map(escapeRegex);
-  const relativeDepth =
-    dirname(relativeFilePath) === "."
-      ? 1
-      : dirname(relativeFilePath).split(/[\\/]/).filter(Boolean).length + 1;
-  const crossPackagePrefixPattern = `(?:\\.\\./){${relativeDepth}}`;
-
-  const relativeImportRegex = new RegExp(
-    `(from\\s+['"])${crossPackagePrefixPattern}((?!\\.)${patterns.join("|")})(/[^'"]*)?(['"])`,
-    "g"
-  );
-  const bareImportRegex = new RegExp(
-    `(from\\s+['"])(${patterns.join("|")})(/[^'"]*)?(['"])`,
-    "g"
-  );
-  const dynamicRelativeImportRegex = new RegExp(
-    `(import\\(\\s*['"])${crossPackagePrefixPattern}((?!\\.)${patterns.join("|")})(/[^'"]*)?(['"]\\s*\\))`,
-    "g"
-  );
-  const dynamicBareImportRegex = new RegExp(
-    `(import\\(\\s*['"])(${patterns.join("|")})(/[^'"]*)?(['"]\\s*\\))`,
-    "g"
-  );
-
-  let result = content;
-  result = result.replace(relativeImportRegex, (_, prefix, packageName, path, suffix) => {
-    return `${prefix}${createWorkspaceSpecifier(relativeFilePath, packageName, path)}${suffix}`;
-  });
-  result = result.replace(bareImportRegex, (_, prefix, packageName, path, suffix) => {
-    return `${prefix}${createWorkspaceSpecifier(relativeFilePath, packageName, path)}${suffix}`;
-  });
-  result = result.replace(dynamicRelativeImportRegex, (_, prefix, packageName, path, suffix) => {
-    return `${prefix}${createWorkspaceSpecifier(relativeFilePath, packageName, path)}${suffix}`;
-  });
-  result = result.replace(dynamicBareImportRegex, (_, prefix, packageName, path, suffix) => {
-    return `${prefix}${createWorkspaceSpecifier(relativeFilePath, packageName, path)}${suffix}`;
-  });
-
-  return result;
-}

package/cli/cliIoTypes.ts

@@ -1,3 +0,0 @@
-export type OutputLike = {
-  write(chunk: string): unknown;
-};

package/cli/cliRuntimeDoctorReport.ts

@@ -1,193 +0,0 @@
-import { resolveAgentRuntimeDecision } from "../agent-runtime/runtimeDecision";
-import type { AgentRuntimeDecision } from "../agent-runtime/types";
-import type { LocalRuntimeProbeResult } from "./agentCommandSupport";
-import type { EnvLike } from "./cliEnvHelpers";
-
-export type CliRuntimeDoctorProbe = {
-  levelDb: {
-    ok: boolean;
-    path: string;
-    error?: string;
-  };
-  agentConfig: {
-    key: string;
-    cacheReady: boolean;
-    found: boolean;
-  };
-  provider: {
-    available: boolean;
-    label: string;
-  };
-  sync: {
-    available: boolean;
-  };
-  serverFallback: {
-    available: boolean;
-    url: string;
-  };
-};
-
-export type CliRuntimeDoctorReport = {
-  decision: AgentRuntimeDecision;
-  levelDb: {
-    status: "ok" | "failed";
-    path: string;
-    error?: string;
-  };
-  agentConfig: {
-    status: "found" | "missing";
-    value: string;
-  };
-  provider: {
-    status: "available" | "missing";
-    label: string;
-  };
-  sync: {
-    status: "available" | "unavailable";
-  };
-  serverFallback: {
-    status: "available" | "unavailable";
-    value: string;
-  };
-};
-
-function readLocalAgentKey(env: EnvLike) {
-  return env.NOLO_LOCAL_AGENT_KEY || env.NOLO_AGENT || "";
-}
-
-function detectLocalProvider(env: EnvLike) {
-  return Boolean(
-    env.OPENAI_API_KEY ||
-      env.ANTHROPIC_API_KEY ||
-      env.GOOGLE_API_KEY ||
-      env.NOLO_LOCAL_OPENAI_BASE_URL ||
-      env.OLLAMA_BASE_URL
-  );
-}
-
-function detectProviderLabel(env: EnvLike) {
-  if (env.NOLO_LOCAL_OPENAI_BASE_URL) {
-    return `openai-compatible endpoint ${env.NOLO_LOCAL_OPENAI_BASE_URL}`;
-  }
-  if (env.OLLAMA_BASE_URL) {
-    return `ollama-compatible endpoint ${env.OLLAMA_BASE_URL}`;
-  }
-  if (env.OPENAI_API_KEY) return "openai via env OPENAI_API_KEY";
-  if (env.ANTHROPIC_API_KEY) return "anthropic via env ANTHROPIC_API_KEY";
-  if (env.GOOGLE_API_KEY) return "google via env GOOGLE_API_KEY";
-  return "missing";
-}
-
-export function buildCliRuntimeDoctorProbe(input: {
-  env: EnvLike;
-  localProbe: LocalRuntimeProbeResult;
-  authToken: string;
-  serverUrl: string;
-}): CliRuntimeDoctorProbe {
-  const agentKey = input.localProbe.agentKey || readLocalAgentKey(input.env);
-  const cacheReady = Boolean(input.env.NOLO_AGENT_CACHE_READY);
-  return {
-    levelDb: {
-      ok: input.localProbe.ok,
-      path: input.localProbe.dbPath,
-      ...(input.localProbe.error ? { error: input.localProbe.error } : {}),
-    },
-    agentConfig: {
-      key: agentKey,
-      cacheReady,
-      found: input.localProbe.ok && input.localProbe.agentFound && (Boolean(agentKey) || cacheReady),
-    },
-    provider: {
-      available: detectLocalProvider(input.env),
-      label: detectProviderLabel(input.env),
-    },
-    sync: {
-      available: Boolean(input.authToken),
-    },
-    serverFallback: {
-      available: Boolean(input.authToken || input.env.NOLO_SERVER || input.env.BASE_URL),
-      url: input.serverUrl,
-    },
-  };
-}
-
-export function buildCliRuntimeDoctorReport(
-  probe: CliRuntimeDoctorProbe
-): CliRuntimeDoctorReport {
-  const missingLocalCapabilities = [
-    ...(probe.levelDb.ok ? [] : ["leveldb"]),
-    ...(probe.agentConfig.found ? [] : ["agent-config"]),
-    ...(probe.provider.available ? [] : ["provider"]),
-  ];
-  const decision = resolveAgentRuntimeDecision({
-    requestedMode: "auto",
-    syncRequested: false,
-    host: "cli",
-    hasLocalAgentConfig: probe.agentConfig.found,
-    hasLocalProvider: probe.provider.available,
-    hasLocalPersistence: true,
-    missingLocalCapabilities,
-    requiresServer: false,
-    serverFallbackAvailable: probe.serverFallback.available,
-  });
-
-  return {
-    decision,
-    levelDb: {
-      status: probe.levelDb.ok ? "ok" : "failed",
-      path: probe.levelDb.path,
-      ...(probe.levelDb.error ? { error: probe.levelDb.error } : {}),
-    },
-    agentConfig: {
-      status: probe.agentConfig.found ? "found" : "missing",
-      value: probe.agentConfig.key || (probe.agentConfig.cacheReady ? "cache ready" : "no local agent key"),
-    },
-    provider: {
-      status: probe.provider.available ? "available" : "missing",
-      label: probe.provider.label,
-    },
-    sync: {
-      status: probe.sync.available ? "available" : "unavailable",
-    },
-    serverFallback: {
-      status: probe.serverFallback.available ? "available" : "unavailable",
-      value: probe.serverFallback.available ? probe.serverFallback.url : "unavailable",
-    },
-  };
-}
-
-export function formatCliRuntimeDoctorReport(
-  report: CliRuntimeDoctorReport
-): string {
-  const lines = [
-    `Runtime: ${report.decision.mode}`,
-    `Reason: ${report.decision.reason}`,
-    `LevelDB: ${report.levelDb.status}`,
-    `DB path: ${report.levelDb.path}`,
-  ];
-  if (report.levelDb.error) {
-    lines.push(`DB error: ${report.levelDb.error}`);
-  }
-  if (report.agentConfig.status === "found") {
-    lines.push(`Agent config: found (${report.agentConfig.value})`);
-  } else if (report.agentConfig.value === "no local agent key") {
-    lines.push("Agent config: missing (no local agent key)");
-  } else {
-    lines.push(`Agent config: missing (${report.agentConfig.value})`);
-  }
-  lines.push(`Provider: ${report.provider.status} (${report.provider.label})`);
-  lines.push("Persistence: LevelDB local store");
-  lines.push(
-    `Sync: ${report.sync.status}${
-      report.sync.status === "available" ? "" : " (not authenticated)"
-    }`
-  );
-  lines.push(`Server fallback: ${report.serverFallback.value}`);
-  if (report.decision.missingLocalCapabilities.length > 0) {
-    lines.push("Missing local capabilities:");
-    for (const capability of report.decision.missingLocalCapabilities) {
-      lines.push(`- ${capability}`);
-    }
-  }
-  return `${lines.join("\n")}\n`;
-}

package/cli/client/agentRunInput.ts

@@ -1,10 +0,0 @@
-export function buildUserInputContent(message: string, imageUrls: string[] = []) {
-  if (imageUrls.length === 0) return message;
-  return [
-    ...(message.trim() ? [{ type: "text" as const, text: message }] : []),
-    ...imageUrls.map((url) => ({
-      type: "image_url" as const,
-      image_url: { url },
-    })),
-  ];
-}

package/cli/client/agentRunLocalExecution.ts

@@ -1,124 +0,0 @@
-import type { LocalAgentToolEvent } from "../../agent-runtime/localLoop";
-import type { EnvLike } from "../cliEnvHelpers";
-
-type TaskRunReviewStatus = "passed" | "needs_changes" | "blocked";
-
-export type TaskRunToolEvidence = {
-  toolsUsed: string[];
-  summary: {
-    callCount: number;
-    resultCount: number;
-    errorCount: number;
-    rounds: number;
-  };
-};
-
-type TraceLocalToolOptions = {
-  traceTools?: boolean;
-  env: EnvLike;
-};
-
-type CollectLocalToolEvidenceOptions = {
-  taskRunContext?: {
-    rowDbKey?: string;
-  };
-};
-
-type ResolveLocalToolRoundRetryLimitOptions = {
-  env: EnvLike;
-};
-
-const DEFAULT_LOCAL_AGENT_TOOL_ROUND_RETRY_LIMIT = 512;
-
-function parsePositiveInteger(value: string | undefined) {
-  if (!value) return null;
-  const parsed = Number(value);
-  if (!Number.isInteger(parsed) || parsed <= 0) return null;
-  return parsed;
-}
-
-export function shouldTraceLocalTools(options: TraceLocalToolOptions) {
-  return Boolean(options.traceTools || options.env.NOLO_TRACE_TOOLS === "1");
-}
-
-export function shouldCollectLocalToolEvidence(options: CollectLocalToolEvidenceOptions) {
-  return Boolean(options.taskRunContext?.rowDbKey);
-}
-
-export function summarizeLocalToolEvidence(
-  events: LocalAgentToolEvent[]
-): TaskRunToolEvidence | undefined {
-  if (events.length === 0) return undefined;
-  const toolsUsed = [
-    ...new Set(
-      events
-        .filter((event) => event.type === "tool-call")
-        .map((event) => event.toolName)
-        .filter(Boolean)
-    ),
-  ];
-  const rounds = new Set(events.map((event) => event.round)).size;
-  return {
-    toolsUsed,
-    summary: {
-      callCount: events.filter((event) => event.type === "tool-call").length,
-      resultCount: events.filter((event) => event.type === "tool-result").length,
-      errorCount: events.filter((event) => event.type === "tool-error").length,
-      rounds,
-    },
-  };
-}
-
-export function parseLocalToolRoundLimitError(error: unknown) {
-  const message = error instanceof Error ? error.message : String(error);
-  const match = message.match(/Local agent exceeded max tool rounds:\s*(\d+)/);
-  if (!match) return null;
-  return Number(match[1]);
-}
-
-export function resolveLocalToolRoundRetryLimit(
-  options: ResolveLocalToolRoundRetryLimitOptions
-) {
-  return (
-    parsePositiveInteger(options.env.NOLO_LOCAL_MAX_TOOL_ROUNDS_LIMIT) ??
-    DEFAULT_LOCAL_AGENT_TOOL_ROUND_RETRY_LIMIT
-  );
-}
-
-export function nextLocalToolRoundLimit(current: number) {
-  return current <= 0 ? 1 : current * 2;
-}
-
-export function formatToolTraceEvent(event: LocalAgentToolEvent) {
-  const round = event.round + 1;
-  if (event.type === "tool-call") {
-    return `[nolo:tool] round ${round} -> ${event.toolName} (${event.toolCallId})\n`;
-  }
-  if (event.type === "tool-error") {
-    return `[nolo:tool] round ${round} !! ${event.toolName}: ${event.message ?? "failed"}\n`;
-  }
-  return `[nolo:tool] round ${round} <- ${event.toolName} (${event.toolCallId})\n`;
-}
-
-export function classifyTaskRunReviewStatus(summary?: string): TaskRunReviewStatus | undefined {
-  const normalized = summary?.toLowerCase().trim();
-  if (!normalized) return undefined;
-
-  const explicit = normalized.match(/review\s+decision\s*:\s*(passed|needs_changes|blocked)/);
-  if (explicit?.[1]) return explicit[1] as TaskRunReviewStatus;
-
-  if (/\b(blocked|cannot review|unable to review)\b|无法审查|阻塞/.test(normalized)) {
-    return "blocked";
-  }
-  if (
-    /\b(needs changes|request changes|changes requested|not approved)\b|需要修改|需修改|发现问题/.test(
-      normalized
-    )
-  ) {
-    return "needs_changes";
-  }
-  if (/\b(approved|lgtm|no issues|passed)\b|通过|无问题/.test(normalized)) {
-    return "passed";
-  }
-  return undefined;
-}