@design-ai/cli 4.55.0

package/cli/commands/workspace.mjs

@@ -0,0 +1,176 @@
+// `design-ai workspace` — read-only dogfood workspace summary.
+
+import {
+  collectWorkspaceReport,
+  formatWorkspaceJson,
+  hasWorkspaceStrictIssues,
+  parseWorkspaceArgs,
+} from "../lib/workspace.mjs";
+import { dim, error, header, info, success, warn } from "../lib/log.mjs";
+
+function printHelp() {
+  console.log("Usage:  design-ai workspace [--root path] [--learning-file path] [--learning-usage path] [--learning-eval path] [--strict] [--json]\n");
+  console.log("Shows the current local dogfood workspace state without changing files.\n");
+  console.log("Options:");
+  console.log("  --root path           Inspect a specific git workspace root. Default: current directory");
+  console.log("  --learning-file path  Inspect a specific learning profile. Default: DESIGN_AI_LEARNING_FILE or ~/.design-ai/learning.json");
+  console.log("  --learning-usage path Include a read-only local learning usage sidecar summary. Default: auto-detect sibling learning.usage.json");
+  console.log("  --learning-eval path  Include a read-only local learning eval checkpoint summary. Default: auto-detect sibling learning-eval.json");
+  console.log("  --strict              Exit non-zero when readiness warnings or failures are present");
+  console.log("  --json                Emit machine-readable workspace diagnostics");
+}
+
+function formatCountMap(counts) {
+  const entries = Object.entries(counts || {});
+  if (entries.length === 0) return "none";
+  return entries
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([key, count]) => `${key}:${count}`)
+    .join(", ");
+}
+
+function printAction(action) {
+  const line = action.command ? `${action.text} ${dim(action.command)}` : action.text;
+  if (action.level === "pass") {
+    success(line);
+  } else if (action.level === "fail") {
+    error(line);
+  } else if (action.level === "warn") {
+    warn(line);
+  } else {
+    info(line);
+  }
+}
+
+function printWorkspaceReport(report) {
+  header("design-ai workspace", "Local dogfood readiness snapshot");
+
+  info(`Root: ${report.context.root}`);
+  info(`Source: ${report.context.sourceRoot}`);
+  if (report.context.packageName || report.context.version) {
+    info(`Package: ${report.context.packageName || "unknown"} ${report.context.version || ""}`.trim());
+  }
+
+  console.log("\nGit:");
+  if (!report.git.isRepo) {
+    warn(`Not a git repository: ${report.git.reason}`);
+  } else {
+    const sync = report.git.upstream
+      ? `${report.git.upstream} (ahead ${report.git.ahead}, behind ${report.git.behind})`
+      : "no upstream";
+    const ignored = report.git.ignoredLocalArtifactCount > 0
+      ? `, ${report.git.ignoredLocalArtifactCount} ignored local artifact(s)`
+      : "";
+    const clean = report.git.clean ? `clean${ignored}` : `${report.git.statusShort.length} changed path(s)${ignored}`;
+    info(`Branch: ${report.git.branch || "detached"} | ${clean} | ${sync}`);
+    if (report.git.remote) info(`Remote: ${report.git.remote}`);
+    if (report.git.lastCommit) {
+      info(`Last commit: ${report.git.lastCommit.hash} ${report.git.lastCommit.subject}`);
+    }
+  }
+
+  console.log("\nLearning:");
+  const audit = report.learning.auditSummary;
+  info(`File: ${report.learning.file}`);
+  info(`Entries: ${report.learning.count} | audit ${audit.status} (${audit.failures} failure(s), ${audit.warnings} warning(s))`);
+  info(`Categories: ${formatCountMap(report.learning.categoryCounts)}`);
+  if (report.learning.latestEntry) {
+    info(`Latest: ${report.learning.latestEntry.category} / ${report.learning.latestEntry.source}`);
+  }
+  if (report.learning.error) warn(`Learning profile error: ${report.learning.error}`);
+
+  if (report.learningUsage) {
+    console.log("\nLearning usage:");
+    info(`Usage sidecar: ${report.learningUsage.usageFile}`);
+    info(`Events: ${report.learningUsage.eventCount} | used ${report.learningUsage.usedEntryCount}/${report.learningUsage.profileEntryCount} | stale ${report.learningUsage.staleSelectedEntryCount}`);
+    if (report.learningUsage.latestEvent) {
+      info(`Latest: ${report.learningUsage.latestEvent.command || "unknown"} / ${report.learningUsage.latestEvent.routeId || "unrouted"} at ${report.learningUsage.latestEvent.createdAt || "unknown"}`);
+    }
+    if (report.learningUsage.readiness) {
+      info(`Readiness: ${report.learningUsage.readiness.status}${report.learningUsage.readiness.reason ? ` | ${report.learningUsage.readiness.reason}` : ""}`);
+    }
+    info("Privacy: selected entry ids and brief hashes only, no raw brief text");
+    if (report.learningUsage.error) warn(`Learning usage error: ${report.learningUsage.error}`);
+  }
+
+  if (report.learningEval) {
+    console.log("\nLearning eval:");
+    info(`Checkpoint: ${report.learningEval.source}`);
+    info(`Status: ${report.learningEval.status} | cases ${report.learningEval.caseCount} (pass ${report.learningEval.passed}, warn ${report.learningEval.warned}, fail ${report.learningEval.failed})`);
+    if (report.learningEval.generatedAt) {
+      info(`Generated: ${report.learningEval.generatedAt}`);
+    }
+    if (report.learningEval.freshness) {
+      info(`Freshness: ${report.learningEval.freshness.status}${report.learningEval.freshness.reason ? ` | ${report.learningEval.freshness.reason}` : ""}`);
+    }
+    info(`Privacy: brief hashes only, no raw brief text`);
+    if (report.learningEval.error) warn(`Learning eval error: ${report.learningEval.error}`);
+  }
+
+  if (report.learningRestoreBackups) {
+    console.log("\nLearning restore backups:");
+    info(`Directory: ${report.learningRestoreBackups.directory}`);
+    info(`Backups: ${report.learningRestoreBackups.totalCount} total | showing ${report.learningRestoreBackups.count}`);
+    if (report.learningRestoreBackups.latestBackup) {
+      info(`Latest: ${report.learningRestoreBackups.latestBackup.name} | entries ${report.learningRestoreBackups.latestBackup.entryCount}`);
+    }
+    if (report.learningRestoreBackups.readiness) {
+      const readiness = report.learningRestoreBackups.readiness;
+      info(`Readiness: ${readiness.status}${readiness.reason ? ` | ${readiness.reason}` : ""}`);
+    }
+    info("Privacy: backup inventory only, no entry text previews");
+    if (report.learningRestoreBackups.error) warn(`Learning restore backup error: ${report.learningRestoreBackups.error}`);
+  }
+
+  console.log("\nRepository:");
+  info(`Canonical: ${report.repository.slug} (${report.repository.url})`);
+  const remoteStatus = report.repository.remoteAligned === null
+    ? "not checked"
+    : report.repository.remoteAligned ? "aligned" : "mismatch";
+  info(`Remote: ${report.repository.remoteUrl || "none"} | ${remoteStatus}`);
+  if (report.repository.metadataAligned) {
+    success("Package/plugin metadata aligned.");
+  } else {
+    warn("Package/plugin metadata mismatch detected.");
+  }
+  for (const issue of report.repository.issues) {
+    warn(issue);
+  }
+
+  console.log("\nRelease scripts:");
+  info(`Available: ${report.release.available.join(", ") || "none"}`);
+  if (report.release.missing.length > 0) {
+    warn(`Missing: ${report.release.missing.join(", ")}`);
+  }
+
+  console.log("\nNext actions:");
+  for (const action of report.nextActions) {
+    printAction(action);
+  }
+}
+
+export async function runWorkspace(args, deps = {}) {
+  const flags = parseWorkspaceArgs(args);
+  if (flags.help) {
+    printHelp();
+    return;
+  }
+
+  const report = collectWorkspaceReport({
+    root: flags.root || process.cwd(),
+    learningFilePath: flags.learningFilePath || undefined,
+    learningUsagePath: flags.learningUsagePath || undefined,
+    learningEvalPath: flags.learningEvalPath || undefined,
+    ...deps,
+  });
+
+  if (flags.json) {
+    console.log(formatWorkspaceJson(report));
+  } else {
+    printWorkspaceReport(report);
+  }
+
+  if (flags.strict && hasWorkspaceStrictIssues(report)) {
+    process.exitCode = 1;
+  }
+}

package/cli/lib/brief.mjs

@@ -0,0 +1,52 @@
+// Shared task brief input handling for route/prompt/pack commands.
+
+import { readFileSync } from "node:fs";
+import path from "node:path";
+
+export function parseBriefSourceFlag(args, out) {
+  const arg = args[out.index];
+
+  if (arg === "--from-file" || arg === "--file") {
+    const next = args[out.index + 1];
+    if (!next || next.startsWith("--")) throw new Error(`${arg} expects a file path`);
+    out.fromFile = next;
+    out.index += 1;
+    return true;
+  }
+
+  if (arg === "--stdin") {
+    out.stdin = true;
+    return true;
+  }
+
+  return false;
+}
+
+export function resolveBriefInput({
+  briefParts = [],
+  fromFile = "",
+  stdin = false,
+  cwd = process.cwd(),
+  readStdin = () => readFileSync(0, "utf8"),
+}) {
+  const inlineBrief = briefParts.join(" ").trim();
+  const sources = [
+    inlineBrief ? "inline brief" : "",
+    fromFile ? "--from-file" : "",
+    stdin ? "--stdin" : "",
+  ].filter(Boolean);
+
+  if (sources.length > 1) {
+    throw new Error(`Use only one brief source: ${sources.join(", ")}`);
+  }
+
+  let brief = inlineBrief;
+  if (fromFile) {
+    brief = readFileSync(path.resolve(cwd, fromFile), "utf8").trim();
+  } else if (stdin) {
+    brief = String(readStdin()).trim();
+  }
+
+  if (!brief) throw new Error("Brief is empty");
+  return brief;
+}