@mytegroupinc/myte-core 0.0.3 → 0.0.5

package/README.md

@@ -3,8 +3,49 @@
 Internal implementation package for the `myte` CLI.
 
 Most users should install the unscoped wrapper instead:
-- `npm i -g myte`
+- `npm install myte` then `npx myte bootstrap`
+- `npm install myte` then `npx myte query "..." --with-diff`
+- `npm install myte` then `npm exec myte -- query "..." --with-diff`
+- `npm i -g myte` then `myte bootstrap`
+- `npm i -g myte` then `myte query "..." --with-diff`
+- `npx myte@latest bootstrap`
 - `npx myte@latest query "..." --with-diff`
+- `npm install myte` then `npx myte create-prd ./drafts/auth-prd.md`
+- `cat ./drafts/auth-prd.md | npx myte create-prd --stdin`
 
-This package is published under the org scope for governance; the wrapper delegates here.
+Requirements:
+- Node `18+`
+- macOS, Linux, or Windows
+- `git` in `PATH` for `--with-diff`
+- `MYTE_API_KEY=<project_api_key>` in env or `.env`
+- repo folder names must match the project repo names configured in Myte, including casing on case-sensitive filesystems
 
+Notes:
+- `npm install myte` installs the wrapper locally; use `npx myte` or `npm exec myte -- ...` to run it.
+- `npm install myte` means the CLI is available locally; bare `myte ...` still requires a global install.
+- `bootstrap` is a local file materialization path, not a hosted file download.
+- `bootstrap` expects to run from a wrapper root that contains the project's configured repo folders.
+- `bootstrap` writes `MyteCommandCenter/data/phases`, `epics`, `stories`, `missions`, `project.yml`, and `bootstrap-manifest.json`.
+- `create-prd` is a deterministic PRD upload path, not an LLM generation command.
+- `--with-diff` only searches repo folders whose names match the project repo names configured in Myte.
+- `--with-diff` includes per-repo diagnostics in `print-context` payload:
+  - missing repo directories
+  - per-repo errors (for example fetch or command failures)
+  - clean/no-change repo summaries
+- `--with-diff` query payload includes `diff_diagnostics` so backend/UI can report exactly why context may be missing.
+
+Deterministic `create-prd` contract:
+- Required: `MYTE_API_KEY`, a PRD markdown body, and a title.
+- Title source: `myte-kanban.title`, the first markdown `# Heading`, or `--title`.
+- Description source: `myte-kanban.description` or `--description`.
+- The markdown body is stored verbatim as PRD content and is what the backend uses to build the PRD DOCX.
+- Legacy `feedback_text` is still accepted for older payloads, but new callers should use `description`.
+- Optional structured fields: `priority`, `status`, `tags`, `assigned_user_email`, `assigned_user_id`, `due_date`, `repo_name`, `repo_id`, `preview_url`, `source`.
+
+Examples:
+- `npx myte bootstrap`
+- `npx myte bootstrap --dry-run --json`
+- `npx myte create-prd ./drafts/auth-prd.md --description "Short card summary"`
+- `npx myte create-prd ./drafts/auth-prd.md --print-context`
+
+This package is published under the org scope for governance; the public `myte` wrapper delegates here.

package/cli.js

@@ -49,7 +49,7 @@ function loadEnv() {
 }
 
 function splitCommand(argv) {
-  const known = new Set(["query", "ask", "chat", "config", "help", "--help", "-h"]);
+  const known = new Set(["query", "ask", "chat", "config", "bootstrap", "create-prd", "add-prd", "prd", "help", "--help", "-h"]);
   const first = argv[0];
   if (first && known.has(first)) {
     const cmd = first === "--help" || first === "-h" ? "help" : first;
@@ -62,8 +62,8 @@ function parseArgs(argv) {
   try {
     // eslint-disable-next-line global-require
     return require("minimist")(argv, {
-      boolean: ["with-diff", "diff", "print-context", "dry-run", "fetch", "json"],
-      string: ["query", "q", "context", "ctx", "base-url", "timeout-ms", "diff-limit"],
+      boolean: ["with-diff", "diff", "print-context", "dry-run", "fetch", "json", "stdin"],
+      string: ["query", "q", "context", "ctx", "base-url", "timeout-ms", "diff-limit", "title", "description", "feedback-text", "output-dir"],
       alias: {
         q: "query",
         d: "with-diff",
@@ -116,27 +116,84 @@ function printHelp() {
     "Usage:",
     "  myte query \"<text>\" [--with-diff] [--context \"...\"]",
     "  myte config [--json]",
+    "  myte bootstrap [--output-dir ./MyteCommandCenter] [--json]",
     "  myte chat",
+    "  myte create-prd <file.md> [--json] [--title \"...\"] [--description \"...\"]",
+    "  myte add-prd <file.md> [--json]",
+    "  cat file.md | myte create-prd --stdin [--title \"...\"] [--description \"...\"]",
+    "",
+    "Run forms:",
+    "  npm install myte   then npx myte query \"...\" --with-diff",
+    "  npm install myte   then npm exec myte -- query \"...\" --with-diff",
+    "  npm i -g myte      then myte query \"...\" --with-diff",
+    "  npx myte@latest query \"What changed in logging?\" --with-diff",
     "",
     "Auth:",
     "  - Set MYTE_API_KEY in a workspace .env (or env var)",
     "",
+    "bootstrap contract:",
+    "  - Run from the wrapper root that contains the project's configured repo folders",
+    "  - Writes MyteCommandCenter/data/phases, epics, stories, and missions locally",
+    "  - Uses the project-scoped bootstrap snapshot from the Myte API",
+    "",
+    "create-prd contract:",
+    "  - Required: valid MYTE_API_KEY, PRD markdown body, title",
+    "  - Title source: myte-kanban.title, first # heading, or --title",
+    "  - Description source: myte-kanban.description or --description",
+    "  - PRD DOCX content: the markdown body is stored verbatim",
+    "",
     "Options:",
     "  --with-diff           Include deterministic git diffs (project-scoped)",
     "  --diff-limit <chars>  Truncate diff context to N chars (default: 200000)",
     "  --timeout-ms <ms>     Request timeout (default: 300000)",
     "  --base-url <url>      API base (default: https://api.myte.dev)",
+    "  --output-dir <path>   Bootstrap output directory (default: <wrapper-root>/MyteCommandCenter)",
+    "  --stdin               Read PRD content from stdin instead of a file path",
+    "  --title <text>        Override PRD title for raw markdown uploads",
+    "  --description <text>  Set feedback description/card summary for raw markdown uploads",
     "  --print-context       Print JSON payload and exit (no query call)",
     "  --no-fetch            Don't git fetch origin main/master before diff",
     "",
     "Examples:",
     "  myte query \"What changed in logging?\" --with-diff",
-    "  myte query \"...\" --with-diff --diff-limit 120000",
+    "  myte bootstrap",
+    "  myte bootstrap --output-dir ./MyteCommandCenter",
+    "  myte create-prd ./drafts/auth-prd.md --description \"Short card summary\"",
+    "  cat ./drafts/auth-prd.md | myte create-prd --stdin",
     "  myte config",
   ].join("\n");
   console.log(text);
 }
 
+function extractMarkdownTitle(text) {
+  const raw = String(text || "");
+  const lines = raw.split(/\r?\n/);
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (line.startsWith("#")) {
+      const title = line.replace(/^#+\s*/, "").trim();
+      if (title) return title;
+    }
+  }
+  return "";
+}
+
+function isMyteKanbanTicket(text) {
+  return /^\s*```myte-kanban\s*\{[\s\S]*?\}\s*```\s*/.test(String(text || ""));
+}
+
+async function readStdinText() {
+  return new Promise((resolve, reject) => {
+    let data = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => resolve(data));
+    process.stdin.on("error", reject);
+  });
+}
+
 async function getFetch() {
   if (typeof fetch !== "undefined") return fetch;
   const mod = await import("node-fetch");
@@ -170,10 +227,47 @@ async function fetchJsonWithTimeout(fetchFn, url, options, timeoutMs) {
   }
 }
 
-function buildContext(args, diffText) {
+function summarizeDiffDiagnosticsForContext(diagnostics) {
+  if (!diagnostics) return null;
+  const repos = Array.isArray(diagnostics.repo_summaries)
+    ? diagnostics.repo_summaries
+    : [];
+  return {
+    project_id: diagnostics.project_id || null,
+    mode: diagnostics.mode,
+    requested_repos: diagnostics.requested_repo_names || [],
+    found_repos: diagnostics.found_repos || [],
+    missing_repos: diagnostics.missing_repos || [],
+    collected_any: Boolean(diagnostics.collected_any),
+    truncation: diagnostics.truncated ? "truncated" : "full",
+    repos: repos.map((repo) => ({
+      name: repo.name,
+      status: repo.status || "ok",
+      head_branch: repo.head_branch || null,
+      base_ref: repo.base_ref || null,
+      has_changes: Boolean(repo.has_changes),
+      changed_blocks: repo.changed_blocks || {},
+      untracked_file_count: repo.untracked_file_count || 0,
+      error_count: Array.isArray(repo.errors) ? repo.errors.length : 0,
+    })),
+    warnings: diagnostics.warnings || [],
+    errors: diagnostics.errors || [],
+  };
+}
+
+function formatDiffDiagnosticText(diagnostics) {
+  const summary = summarizeDiffDiagnosticsForContext(diagnostics);
+  if (!summary) return "";
+  return `Git diff diagnostics:\n${JSON.stringify(summary, null, 2)}`;
+}
+
+function buildContext(args, diffText, diffDiagnostics) {
   const ctx = args.context ?? args.ctx ?? args.c;
   const extra = ctx === undefined ? [] : Array.isArray(ctx) ? ctx.map(String) : [String(ctx)];
   if (diffText) extra.push(`Current git diff snapshot (project-configured):\n${diffText}`);
+  if (diffDiagnostics) {
+    extra.push(formatDiffDiagnosticText(diffDiagnostics));
+  }
   return extra;
 }
 
@@ -203,7 +297,7 @@ function hasGitDir(repoPath) {
   return fs.existsSync(path.join(repoPath, ".git"));
 }
 
-function runGitDiff(repoPath, args, opts = {}) {
+function runGitRaw(repoPath, args, opts = {}) {
   const res = spawnSync("git", args, {
     cwd: repoPath,
     encoding: "utf8",
@@ -214,15 +308,40 @@ function runGitDiff(repoPath, args, opts = {}) {
   if (res.error && res.error.code === "ENOENT") {
     const err = new Error("git executable not found in PATH. Install Git and ensure PATH includes git.");
     err.code = "ENOENT";
-    throw err;
+    return { ok: false, status: null, stdout: "", stderr: "", error: err };
   }
   if (res.status !== 0 && res.status !== 1) {
     const msg = res.stderr || res.error?.message || "unknown git error";
     const err = new Error(`git ${args.join(" ")} failed (${res.status}): ${msg}`);
     err.code = res.status;
-    throw err;
+    return { ok: false, status: res.status, stdout: "", stderr: msg, error: err };
+  }
+  return { ok: true, status: res.status, stdout: (res.stdout || "").trim(), stderr: res.stderr || "" };
+}
+
+function runGitDiff(repoPath, args, opts = {}) {
+  const result = runGitRaw(repoPath, args, opts);
+  if (!result.ok) {
+    throw result.error;
+  }
+  return result.stdout;
+}
+
+function runGitDiffResult(repoPath, args, opts = {}) {
+  return runGitRaw(repoPath, args, opts);
+}
+
+function toPatchWithPrefix(diffText, prefix) {
+  if (!diffText) return "";
+  return patchPaths(diffText, prefix);
+}
+
+function safeText(value) {
+  try {
+    return String(value || "");
+  } catch (err) {
+    return "";
   }
-  return (res.stdout || "").trim();
 }
 
 function runGitOk(repoPath, args, opts = {}) {
@@ -230,7 +349,7 @@ function runGitOk(repoPath, args, opts = {}) {
     cwd: repoPath,
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"],
-    maxBuffer: 16 * 1024 * 1024,
+    maxBuffer: 64 * 1024 * 1024,
     ...opts,
   });
   return res.status === 0;
@@ -244,6 +363,19 @@ function runGitTry(repoPath, args) {
   }
 }
 
+function runGitTryWithResult(repoPath, args, opts = {}) {
+  const result = runGitDiffResult(repoPath, args, opts);
+  if (!result.ok) {
+    return {
+      ok: false,
+      output: "",
+      error: safeText(result.error?.message),
+      status: result.status,
+    };
+  }
+  return { ok: true, output: result.stdout, error: "", status: result.status };
+}
+
 function runGitSafeDiff(repoPath, args, prefix) {
   const patchText = runGitTry(repoPath, args);
   if (!patchText) {
@@ -258,27 +390,27 @@ function patchPaths(diff, prefix = "") {
     .replace(
       /^diff --git ([ab]\/|\/dev\/null)(.+?) ([ab]\/|\/dev\/null)(.+?)$/gm,
       (_, aPre, a, bPre, b) =>
-        `diff --git ${aPre === "/dev/null" ? "/dev/null" : prefix + a} ${
-          bPre === "/dev/null" ? "/dev/null" : prefix + b
+        `diff --git ${aPre === "/dev/null" ? "/dev/null" : `${aPre}${prefix}${a}`} ${
+          bPre === "/dev/null" ? "/dev/null" : `${bPre}${prefix}${b}`
         }`
     )
     .replace(
       /^(---) ([ab]\/|\/dev\/null)(.+)$/gm,
-      (_, m, pre, p) => `${m} ${pre === "/dev/null" ? "/dev/null" : prefix + p}`
+      (_, m, pre, p) => `${m} ${pre === "/dev/null" ? "/dev/null" : `${pre}${prefix}${p}`}`
     )
     .replace(
       /^(?:\+\+\+) ([ab]\/|\/dev\/null)(.+)$/gm,
-      (_, pre, p) => `+++ ${pre === "/dev/null" ? "/dev/null" : prefix + p}`
+      (_, pre, p) => `+++ ${pre === "/dev/null" ? "/dev/null" : `${pre}${prefix}${p}`}`
     );
 }
 
 function filterDiff(diff) {
   if (!diff) return "";
   return diff
-    .split(/^diff --git /gm)
+    .split(/(?=^diff --git )/gm)
     .filter((block) => {
       if (!block.trim()) return false;
-      const m = block.match(/^([ab]\/\S+?) ([ab]\/\S+?)\n/);
+      const m = block.match(/^diff --git ([ab]\/\S+?) ([ab]\/\S+?)\n/);
       if (
         m &&
         (shouldIgnore(m[1].replace(/^[ab]\//, "")) || shouldIgnore(m[2].replace(/^[ab]\//, "")))
@@ -287,7 +419,6 @@ function filterDiff(diff) {
       }
       return true;
     })
-    .map((blk, i) => (i === 0 ? blk : `diff --git ${blk}`))
     .join("");
 }
 
@@ -362,80 +493,202 @@ function resolveBaseRef(repoPath) {
   return null;
 }
 
-function collectGitDiff({ projectId, repoNames, maxChars, fetchRemote = true } = {}) {
+function collectGitDiffWithDiagnostics({
+  projectId,
+  repoNames,
+  maxChars,
+  fetchRemote = true,
+} = {}) {
+  const configuredRepos = Array.isArray(repoNames) ? repoNames.map(String).map((s) => s.trim()).filter(Boolean) : [];
+  const diagnostics = {
+    project_id: projectId || null,
+    requested_repo_names: configuredRepos,
+    fetch_remote: Boolean(fetchRemote),
+    mode: "none",
+    search_root: null,
+    found_repos: [],
+    missing_repos: [],
+    repo_summaries: [],
+    collected_any: false,
+    collected_text_length: 0,
+    truncated: false,
+    warnings: [],
+    errors: [],
+  };
+
   try {
-    const resolved = resolveConfiguredRepos(repoNames);
+    const resolved = resolveConfiguredRepos(configuredRepos);
+    diagnostics.mode = resolved.mode || "none";
+    diagnostics.search_root = resolved.root || null;
+    diagnostics.found_repos = (resolved.repos || []).map((r) => r.name);
+    diagnostics.missing_repos = resolved.missing || [];
     const repos = resolved.repos || [];
     if (!repos.length) {
-      const configured = Array.isArray(repoNames) ? repoNames.join(", ") : "";
-      const msg = [
-        "[myte] No configured repos found locally.",
-        `Configured repos (from project ${projectId || "unknown"}): ${configured || "(none)"}`,
-        "Run from within a configured repo, or a parent folder that contains the repo folders by name.",
-      ].join("\n");
-      throw new Error(msg);
+      diagnostics.errors.push("No configured repos found locally.");
+      diagnostics.reason = "no_repos_found";
+      return {
+        text: "",
+        diagnostics,
+      };
     }
 
-    let output = "";
-    if (projectId) output += `# Project: ${projectId}\n`;
-    output += `# Mode: ${resolved.mode}\n`;
-    output += `# Configured repos: ${Array.isArray(repoNames) ? repoNames.join(", ") : ""}\n`;
+    const sections = [];
+    if (projectId) sections.push(`# Project: ${projectId}`);
+    sections.push(`# Mode: ${resolved.mode}`);
+    sections.push(`# Configured repos: ${configuredRepos.join(", ") || ""}`);
     if (resolved.missing && resolved.missing.length) {
-      output += `# Missing locally (skipped): ${resolved.missing.join(", ")}\n`;
+      sections.push(`# Missing locally (skipped): ${resolved.missing.join(", ")}`);
     }
-    output += "\n";
-
-    for (const { name, dir, abs, prefix } of repos) {
-      if (fetchRemote) fetchBaseBranches(abs);
+    sections.push("");
+
+    for (const repo of repos) {
+      const repoSummary = {
+        name: repo.name,
+        dir: repo.dir || ".",
+        root: repo.abs,
+        status: "ok",
+        head_branch: null,
+        base_ref: null,
+        has_changes: false,
+        changed_blocks: {
+          base_vs_head: false,
+          staged: false,
+          unstaged: false,
+          untracked_files: false,
+        },
+        untracked_file_count: 0,
+        errors: [],
+      };
+
+      const { name, dir, abs, prefix } = repo;
+      const fetchDiag = { attempted: false, ok: false, message: "" };
+      if (fetchRemote) {
+        fetchDiag.attempted = true;
+        fetchDiag.ok = fetchBaseBranches(abs);
+        if (!fetchDiag.ok) {
+          fetchDiag.message = "failed to refresh origin main/master";
+          repoSummary.errors.push(fetchDiag.message);
+          diagnostics.warnings.push(`Repo "${name}": ${fetchDiag.message}`);
+        }
+      }
 
       const headBranch = runGitTry(abs, ["rev-parse", "--abbrev-ref", "HEAD"]) || "HEAD";
       const baseRef = resolveBaseRef(abs);
+      repoSummary.head_branch = headBranch;
+      repoSummary.base_ref = baseRef || "base-unresolved";
+      repoSummary.fetch = fetchDiag;
+
+      let baseDiff = "";
+      if (baseRef) {
+        const baseDiffRaw = runGitTryWithResult(abs, ["diff", "--no-color", "-U2", `${baseRef}...HEAD`], {
+          maxBuffer: 64 * 1024 * 1024,
+        });
+        baseDiff = filterDiff(toPatchWithPrefix(baseDiffRaw.output || "", prefix));
+        if (baseDiff) {
+          repoSummary.changed_blocks.base_vs_head = true;
+          repoSummary.has_changes = true;
+        } else if (baseDiffRaw.ok === false) {
+          repoSummary.errors.push(`base-diff: ${baseDiffRaw.error}`);
+        }
+      }
 
-      const baseDiffRaw = baseRef
-        ? runGitSafeDiff(abs, ["diff", "--no-color", "-U2", `${baseRef}...HEAD`], prefix)
-        : "";
-      const stagedRaw = runGitSafeDiff(abs, ["diff", "--cached", "--no-color", "-U2"], prefix);
-      const unstagedRaw = runGitSafeDiff(abs, ["diff", "--no-color", "-U2"], prefix);
+      const stagedRaw = runGitTryWithResult(abs, ["diff", "--cached", "--no-color", "-U2"]);
+      const staged = filterDiff(toPatchWithPrefix(stagedRaw.output || "", prefix));
+      if (staged) {
+        repoSummary.changed_blocks.staged = true;
+        repoSummary.has_changes = true;
+      } else if (stagedRaw.ok === false) {
+        repoSummary.errors.push(`staged-diff: ${stagedRaw.error}`);
+      }
 
-      const baseDiff = filterDiff(baseDiffRaw);
-      const staged = filterDiff(stagedRaw);
-      const unstaged = filterDiff(unstagedRaw);
+      const unstagedRaw = runGitTryWithResult(abs, ["diff", "--no-color", "-U2"]);
+      const unstaged = filterDiff(toPatchWithPrefix(unstagedRaw.output || "", prefix));
+      if (unstaged) {
+        repoSummary.changed_blocks.unstaged = true;
+        repoSummary.has_changes = true;
+      } else if (unstagedRaw.ok === false) {
+        repoSummary.errors.push(`unstaged-diff: ${unstagedRaw.error}`);
+      }
 
-      const untracked = runGitTry(abs, ["ls-files", "--others", "--exclude-standard"])
-        .split("\n")
-        .filter(Boolean)
-        .filter((f) => !shouldIgnore(f));
+      const untrackedListResult = runGitTryWithResult(abs, ["ls-files", "--others", "--exclude-standard"]);
+      const untracked = untrackedListResult.ok
+        ? untrackedListResult.output
+            .split("\n")
+            .map((f) => f.trim())
+            .filter(Boolean)
+            .filter((f) => !shouldIgnore(f))
+        : [];
+      if (!untrackedListResult.ok) {
+        repoSummary.errors.push(`untracked-list: ${untrackedListResult.error}`);
+      }
 
       let untrackedDiffs = "";
       for (const file of untracked) {
         const absFile = path.join(abs, file);
-        if (!fs.existsSync(absFile) || !fs.statSync(absFile).isFile()) continue;
-        const patch = runGitTry(abs, ["diff", "--no-index", "--no-color", "/dev/null", file]);
-        if (patch) untrackedDiffs += patchPaths(patch, prefix) + "\n";
+        try {
+          if (!fs.existsSync(absFile) || !fs.statSync(absFile).isFile()) continue;
+        } catch (err) {
+          repoSummary.errors.push(`untracked-stat(${file}): ${safeText(err?.message || err)}`);
+          continue;
+        }
+        const patchResult = runGitTryWithResult(abs, ["diff", "--no-index", "--no-color", "/dev/null", file]);
+        if (patchResult.ok && patchResult.output) {
+          untrackedDiffs += toPatchWithPrefix(patchResult.output, prefix) + "\n";
+          repoSummary.untracked_file_count += 1;
+          repoSummary.changed_blocks.untracked_files = true;
+          repoSummary.has_changes = true;
+        } else if (!patchResult.ok) {
+          repoSummary.errors.push(`untracked-diff(${file}): ${patchResult.error}`);
+        }
+      }
+
+      if (repoSummary.errors.length) {
+        repoSummary.status = "partial";
       }
 
-      output += `### ${name} (${dir || "."})\n\n`;
-      output += `# ?? Base vs HEAD (${baseRef || "base-unresolved"}...HEAD | head=${headBranch})\n`;
-      if (baseDiff) output += `${baseDiff}\n\n`;
-      if (staged) output += `# ?? Staged changes\n${staged}\n\n`;
-      if (unstaged) output += `# ?? Unstaged changes\n${unstaged}\n\n`;
-      if (untrackedDiffs) output += `# ?? Untracked files (full contents below)\n${untrackedDiffs}\n`;
+      let section = `### ${name} (${dir || "."})\n\n`;
+      section += `# ?? Base vs HEAD (${repoSummary.base_ref}...HEAD | head=${headBranch})\n`;
+      if (baseDiff) section += `${baseDiff}\n\n`;
+      if (staged) section += `# ?? Staged changes\n${staged}\n\n`;
+      if (unstaged) section += `# ?? Unstaged changes\n${unstaged}\n\n`;
+      if (untrackedDiffs) section += `# ?? Untracked files (full contents below)\n${untrackedDiffs}\n`;
 
-      if (!baseDiff && !staged && !unstaged && !untrackedDiffs) {
-        output += "_No local changes - working tree clean_\n\n";
+      if (!repoSummary.has_changes) {
+        section += "_No local changes - working tree clean_\n\n";
       }
+      sections.push(section);
+      diagnostics.repo_summaries.push(repoSummary);
+      if (repoSummary.has_changes) diagnostics.collected_any = true;
     }
 
+    let output = sections.join("\n");
+    diagnostics.collected_text_length = output.length;
+    if (!diagnostics.collected_any && !diagnostics.reason) {
+      diagnostics.reason = "no_changes_detected";
+    }
     if (Number.isFinite(maxChars) && maxChars > 0 && output.length > maxChars) {
-      return `${output.slice(0, maxChars)}\n...[truncated to ${maxChars} chars]`;
+      diagnostics.truncated = true;
+      output = `${output.slice(0, maxChars)}\n...[truncated to ${maxChars} chars]`;
     }
-    return output.trim();
+    output = output.trim();
+    return {
+      text: output,
+      diagnostics,
+    };
   } catch (err) {
-    console.warn("Failed to collect git diffs:", err?.message || err);
-    return "";
+    diagnostics.errors.push(safeText(err?.message || err));
+    diagnostics.reason = "collection_error";
+    return {
+      text: "",
+      diagnostics,
+    };
   }
 }
 
+function collectGitDiff(options = {}) {
+  return collectGitDiffWithDiagnostics(options).text;
+}
+
 async function fetchProjectConfig({ apiBase, key, timeoutMs }) {
   const fetchFn = await getFetch();
   const url = `${apiBase}/project-assistant/config`;
@@ -458,9 +711,31 @@ async function fetchProjectConfig({ apiBase, key, timeoutMs }) {
   return body.data || {};
 }
 
-async function callAssistantQuery({ apiBase, key, payload, timeoutMs }) {
+async function fetchBootstrapSnapshot({ apiBase, key, timeoutMs }) {
   const fetchFn = await getFetch();
-  const url = `${apiBase}/project-assistant/query`;
+  const url = `${apiBase}/project-assistant/bootstrap`;
+  const { resp, body } = await fetchJsonWithTimeout(
+    fetchFn,
+    url,
+    {
+      method: "GET",
+      headers: { Authorization: `Bearer ${key}` },
+    },
+    timeoutMs
+  );
+
+  if (!resp.ok || body.status !== "success") {
+    const msg = body?.message || `Bootstrap request failed (${resp.status})`;
+    const err = new Error(msg);
+    err.status = resp.status;
+    throw err;
+  }
+  return body.data || {};
+}
+
+async function callAssistantQuery({ apiBase, key, payload, timeoutMs, endpoint = "/project-assistant/query" }) {
+  const fetchFn = await getFetch();
+  const url = `${apiBase}${endpoint}`;
   const { resp, body } = await fetchJsonWithTimeout(
     fetchFn,
     url,
@@ -484,6 +759,231 @@ async function callAssistantQuery({ apiBase, key, payload, timeoutMs }) {
   return body.data || {};
 }
 
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function clearYamlDirectory(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+    return;
+  }
+  for (const entry of fs.readdirSync(dirPath, { withFileTypes: true })) {
+    if (!entry.isFile()) continue;
+    if (!entry.name.toLowerCase().endsWith(".yml")) continue;
+    fs.rmSync(path.join(dirPath, entry.name), { force: true });
+  }
+}
+
+function stableItemId(item, keys, fallback) {
+  for (const key of keys) {
+    const value = String(item?.[key] || "").trim();
+    if (value) return value;
+  }
+  return fallback;
+}
+
+function stringifyYaml(value) {
+  // eslint-disable-next-line global-require
+  const YAML = require("yaml");
+  return YAML.stringify(value, { lineWidth: 0 });
+}
+
+function writeYamlFile(filePath, value) {
+  ensureDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, stringifyYaml(value), "utf8");
+}
+
+function writeJsonFile(filePath, value) {
+  ensureDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+
+function resolveBootstrapWorkspace(repoNames) {
+  const resolved = resolveConfiguredRepos(repoNames);
+  if (!resolved.root || !Array.isArray(resolved.repos) || !resolved.repos.length) {
+    const names = Array.isArray(repoNames) ? repoNames.join(", ") : "";
+    throw new Error(
+      `No configured project repos were found from the current workspace. Expected child folders matching: ${names || "(none)"}`
+    );
+  }
+  return resolved;
+}
+
+function writeBootstrapSnapshot({ snapshot, wrapperRoot, outputDir }) {
+  const targetRoot = outputDir
+    ? path.resolve(process.cwd(), String(outputDir))
+    : path.join(wrapperRoot, "MyteCommandCenter");
+  const dataRoot = path.join(targetRoot, "data");
+  const phasesDir = path.join(dataRoot, "phases");
+  const epicsDir = path.join(dataRoot, "epics");
+  const storiesDir = path.join(dataRoot, "stories");
+  const missionsDir = path.join(dataRoot, "missions");
+
+  ensureDir(dataRoot);
+  clearYamlDirectory(phasesDir);
+  clearYamlDirectory(epicsDir);
+  clearYamlDirectory(storiesDir);
+  clearYamlDirectory(missionsDir);
+
+  const phases = Array.isArray(snapshot.phases) ? snapshot.phases : [];
+  const epics = Array.isArray(snapshot.epics) ? snapshot.epics : [];
+  const stories = Array.isArray(snapshot.stories) ? snapshot.stories : [];
+  const missions = Array.isArray(snapshot.missions) ? snapshot.missions : [];
+
+  phases.forEach((phase, index) => {
+    const phaseId = stableItemId(phase, ["phase_id", "id"], `P${String(index + 1).padStart(3, "0")}`);
+    writeYamlFile(path.join(phasesDir, `${phaseId}.yml`), phase);
+  });
+  epics.forEach((epic, index) => {
+    const epicId = stableItemId(epic, ["epic_id", "id"], `E${String(index + 1).padStart(3, "0")}`);
+    writeYamlFile(path.join(epicsDir, `${epicId}.yml`), epic);
+  });
+  stories.forEach((story, index) => {
+    const storyId = stableItemId(story, ["story_id", "id"], `S${String(index + 1).padStart(3, "0")}`);
+    writeYamlFile(path.join(storiesDir, `${storyId}.yml`), story);
+  });
+  missions.forEach((mission, index) => {
+    const missionId = stableItemId(mission, ["mission_id", "id", "_id"], `M${String(index + 1).padStart(3, "0")}`);
+    writeYamlFile(path.join(missionsDir, `${missionId}.yml`), mission);
+  });
+
+  if (snapshot.project && typeof snapshot.project === "object") {
+    writeYamlFile(path.join(dataRoot, "project.yml"), snapshot.project);
+  }
+
+  const manifest = {
+    schema_version: snapshot.schema_version || 1,
+    generated_at: snapshot.generated_at || null,
+    snapshot_hash: snapshot.snapshot_hash || null,
+    project: snapshot.project || null,
+    repo_names: Array.isArray(snapshot.repo_names) ? snapshot.repo_names : [],
+    counts: {
+      phases: phases.length,
+      epics: epics.length,
+      stories: stories.length,
+      missions: missions.length,
+    },
+  };
+  writeJsonFile(path.join(dataRoot, "bootstrap-manifest.json"), manifest);
+
+  return {
+    targetRoot,
+    dataRoot,
+    manifest,
+  };
+}
+
+async function runCreatePrd(args) {
+  const key = (process.env.MYTE_API_KEY || process.env.MYTE_PROJECT_API_KEY || "").trim();
+  if (!key) {
+    console.error("Missing MYTE_API_KEY (project key) in environment/.env");
+    process.exit(1);
+  }
+  const printContext = Boolean(args["print-context"] || args.printContext || args["dry-run"] || args.dryRun);
+
+  const timeoutRaw = args["timeout-ms"] || args.timeoutMs || args.timeout_ms;
+  const timeoutParsed = timeoutRaw !== undefined ? Number(timeoutRaw) : 300_000;
+  const timeoutMs = Number.isFinite(timeoutParsed) ? timeoutParsed : 300_000;
+
+  const baseRaw = args["base-url"] || args.baseUrl || args.base_url || process.env.MYTE_API_BASE || DEFAULT_API_BASE;
+  const apiBase = normalizeApiBase(baseRaw);
+
+  const providedPath = args.file || args.path || (Array.isArray(args._) ? args._[0] : "");
+  const useStdin = Boolean(args.stdin || (!process.stdin.isTTY && !providedPath));
+
+  let sourceText = "";
+  let filePath = "";
+  if (useStdin) {
+    sourceText = String(await readStdinText() || "");
+  } else {
+    filePath = String(providedPath || "").trim();
+    if (!filePath) {
+      console.error("Missing PRD file path.");
+      printHelp();
+      process.exit(1);
+    }
+    const absPath = path.resolve(filePath);
+    if (!fs.existsSync(absPath) || !fs.statSync(absPath).isFile()) {
+      console.error(`PRD file not found: ${absPath}`);
+      process.exit(1);
+    }
+    sourceText = fs.readFileSync(absPath, "utf8");
+    filePath = absPath;
+  }
+
+  const trimmedSource = String(sourceText || "").trim();
+  if (!trimmedSource) {
+    console.error("PRD content is empty.");
+    process.exit(1);
+  }
+
+  const inferredTitle = String(args.title || extractMarkdownTitle(trimmedSource) || (!useStdin && filePath ? path.parse(filePath).name : "")).trim();
+  const description = String(args.description || args["feedback-text"] || args.feedbackText || "").trim();
+  const payload = isMyteKanbanTicket(trimmedSource)
+    ? {
+        ticket_markdown: trimmedSource,
+      }
+    : {
+        prd_markdown: trimmedSource,
+        title: inferredTitle,
+      };
+
+  if (!payload.ticket_markdown && description) {
+    payload.description = description;
+  }
+
+  if (!payload.ticket_markdown && !payload.title) {
+    console.error("A title is required when uploading raw markdown without a myte-kanban metadata block. Use --title or add a top-level # heading.");
+    process.exit(1);
+  }
+
+  if (printContext) {
+    console.log(JSON.stringify(payload, null, 2));
+    process.exit(0);
+  }
+
+  let data;
+  try {
+    data = await callAssistantQuery({
+      apiBase,
+      key,
+      payload,
+      timeoutMs,
+      endpoint: "/project-assistant/create-prd",
+    });
+  } catch (err) {
+    if (err?.name === "AbortError") {
+      console.error(`Request timed out after ${timeoutMs}ms`);
+    } else {
+      console.error("PRD upload failed:", err?.message || err);
+    }
+    process.exit(1);
+  }
+
+  if (args.json) {
+    console.log(
+      JSON.stringify(
+        {
+          feedback_id: data.feedback_id || null,
+          project_id: data.project_id || null,
+          title: data.title || null,
+          status: data.status || null,
+          deterministic: data.deterministic === true,
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+
+  if (data.feedback_id) console.log(`Feedback ID: ${data.feedback_id}`);
+  if (data.project_id) console.log(`Project ID: ${data.project_id}`);
+  if (data.title) console.log(`Title: ${data.title}`);
+  if (data.status) console.log(`Status: ${data.status}`);
+}
+
 async function runConfig(args) {
   const key = (process.env.MYTE_API_KEY || process.env.MYTE_PROJECT_API_KEY || "").trim();
   if (!key) {
@@ -532,6 +1032,100 @@ async function runConfig(args) {
   }
 }
 
+async function runBootstrap(args) {
+  const key = (process.env.MYTE_API_KEY || process.env.MYTE_PROJECT_API_KEY || "").trim();
+  if (!key) {
+    console.error("Missing MYTE_API_KEY (project key) in environment/.env");
+    process.exit(1);
+  }
+
+  const timeoutRaw = args["timeout-ms"] || args.timeoutMs || args.timeout_ms;
+  const timeoutParsed = timeoutRaw !== undefined ? Number(timeoutRaw) : 300_000;
+  const timeoutMs = Number.isFinite(timeoutParsed) ? timeoutParsed : 300_000;
+
+  const baseRaw = args["base-url"] || args.baseUrl || args.base_url || process.env.MYTE_API_BASE || DEFAULT_API_BASE;
+  const apiBase = normalizeApiBase(baseRaw);
+
+  let snapshot;
+  try {
+    snapshot = await fetchBootstrapSnapshot({ apiBase, key, timeoutMs });
+  } catch (err) {
+    console.error("Failed to fetch bootstrap snapshot:", err?.message || err);
+    process.exit(1);
+  }
+
+  if (args["print-context"] || args.printContext) {
+    console.log(JSON.stringify(snapshot, null, 2));
+    return;
+  }
+
+  let resolved;
+  try {
+    resolved = resolveBootstrapWorkspace(snapshot.repo_names || []);
+  } catch (err) {
+    console.error(err?.message || err);
+    process.exit(1);
+  }
+
+  const wrapperRoot = resolved.root;
+  const outputDir = args["output-dir"] || args.outputDir || args.output_dir;
+  const dryRun = Boolean(args["dry-run"] || args.dryRun);
+  const summary = {
+    api_base: apiBase,
+    project_id: snapshot?.project?.id || null,
+    wrapper_root: wrapperRoot,
+    output_root: outputDir ? path.resolve(process.cwd(), String(outputDir)) : path.join(wrapperRoot, "MyteCommandCenter"),
+    repo_names: Array.isArray(snapshot.repo_names) ? snapshot.repo_names : [],
+    local: {
+      mode: resolved.mode,
+      found: (resolved.repos || []).map((repo) => repo.name),
+      missing: resolved.missing || [],
+    },
+    counts: {
+      phases: Array.isArray(snapshot.phases) ? snapshot.phases.length : 0,
+      epics: Array.isArray(snapshot.epics) ? snapshot.epics.length : 0,
+      stories: Array.isArray(snapshot.stories) ? snapshot.stories.length : 0,
+      missions: Array.isArray(snapshot.missions) ? snapshot.missions.length : 0,
+    },
+    snapshot_hash: snapshot.snapshot_hash || null,
+    generated_at: snapshot.generated_at || null,
+    dry_run: dryRun,
+  };
+
+  if (dryRun) {
+    if (args.json) {
+      console.log(JSON.stringify(summary, null, 2));
+    } else {
+      console.log(`Project: ${summary.project_id || "(unknown)"}`);
+      console.log(`Wrapper root: ${summary.wrapper_root}`);
+      console.log(`Output root: ${summary.output_root}`);
+      console.log(`Configured repos: ${summary.repo_names.join(", ") || "(none)"}`);
+      console.log(`Found locally: ${summary.local.found.join(", ") || "(none)"}`);
+      if (summary.local.missing.length) console.log(`Missing locally: ${summary.local.missing.join(", ")}`);
+      console.log(`Counts: phases=${summary.counts.phases}, epics=${summary.counts.epics}, stories=${summary.counts.stories}, missions=${summary.counts.missions}`);
+      console.log("Dry run only - no files written.");
+    }
+    return;
+  }
+
+  const writeResult = writeBootstrapSnapshot({ snapshot, wrapperRoot, outputDir });
+  summary.data_root = writeResult.dataRoot;
+
+  if (args.json) {
+    console.log(JSON.stringify(summary, null, 2));
+    return;
+  }
+
+  console.log(`Project: ${summary.project_id || "(unknown)"}`);
+  console.log(`Wrapper root: ${summary.wrapper_root}`);
+  console.log(`Output root: ${summary.output_root}`);
+  console.log(`Configured repos: ${summary.repo_names.join(", ") || "(none)"}`);
+  console.log(`Found locally: ${summary.local.found.join(", ") || "(none)"}`);
+  if (summary.local.missing.length) console.log(`Missing locally: ${summary.local.missing.join(", ")}`);
+  console.log(`Wrote: phases=${summary.counts.phases}, epics=${summary.counts.epics}, stories=${summary.counts.stories}, missions=${summary.counts.missions}`);
+  console.log(`Snapshot: ${summary.snapshot_hash || "n/a"}`);
+}
+
 async function runQuery(args) {
   const key = (process.env.MYTE_API_KEY || process.env.MYTE_PROJECT_API_KEY || "").trim();
   if (!key) {
@@ -563,6 +1157,7 @@ async function runQuery(args) {
   const apiBase = normalizeApiBase(baseRaw);
 
   let diffText = "";
+  let diffDiagnostics = null;
   if (includeDiff) {
     let cfg = null;
     try {
@@ -575,14 +1170,20 @@ async function runQuery(args) {
 
     if (cfg) {
       const repoNames = Array.isArray(cfg.repo_names) ? cfg.repo_names : [];
-      diffText = collectGitDiff({
+      const diffResult = collectGitDiffWithDiagnostics({
         projectId: cfg.project_id,
         repoNames,
         maxChars: diffLimit,
         fetchRemote,
       });
+      diffText = diffResult.text;
+      diffDiagnostics = diffResult.diagnostics;
+      if (diffDiagnostics?.errors?.length) {
+        for (const warning of diffDiagnostics.errors) console.warn(`Warning: ${warning}`);
+      }
     } else {
       diffText = "";
+      diffDiagnostics = null;
     }
     if (!diffText) {
       console.error("Warning: no diff context collected. Continuing without --with-diff context.");
@@ -591,8 +1192,9 @@ async function runQuery(args) {
 
   const payload = {
     query,
-    additional_context: buildContext(args, diffText),
+    additional_context: buildContext(args, diffText, diffDiagnostics),
   };
+  if (diffDiagnostics) payload.diff_diagnostics = diffDiagnostics;
 
   if (printContext) {
     console.log(JSON.stringify(payload, null, 2));
@@ -657,11 +1259,21 @@ async function main() {
     return;
   }
 
+  if (command === "bootstrap") {
+    await runBootstrap(args);
+    return;
+  }
+
   if (command === "chat") {
     await runChat(args);
     return;
   }
 
+  if (command === "create-prd" || command === "add-prd" || command === "prd") {
+    await runCreatePrd(args);
+    return;
+  }
+
   // query/ask default
   await runQuery(args);
 }

package/package.json

@@ -1,9 +1,17 @@
 {
   "name": "@mytegroupinc/myte-core",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "Myte CLI core implementation (Project Assistant + deterministic diffs).",
   "type": "commonjs",
   "main": "cli.js",
+  "files": [
+    "README.md",
+    "cli.js",
+    "package.json"
+  ],
+  "scripts": {
+    "test": "node --test"
+  },
   "license": "MIT",
   "engines": {
     "node": ">=18"
@@ -14,6 +22,7 @@
   "dependencies": {
     "dotenv": "^16.5.0",
     "minimist": "^1.2.8",
-    "node-fetch": "^3.3.2"
+    "node-fetch": "^3.3.2",
+    "yaml": "^2.8.1"
   }
 }