@mytegroupinc/myte-core 0.0.7 → 0.0.8

package/README.md

@@ -5,19 +5,25 @@ Internal implementation package for the `myte` CLI.
 Most users should install the unscoped wrapper instead:
 - `npm install myte` then `npx myte bootstrap`
 - `npm install myte` then `npx myte sync-qaqc`
+- `npm install myte` then `npx myte feedback-sync`
 - `npm install myte` then `npx myte query "..." --with-diff`
 - `npm install myte` then `npm exec myte -- query "..." --with-diff`
 - `npm install myte` then `npx myte update-team "Backend deploy completed; QAQC rerun queued."`
+- `npm install myte` then `npx myte update-owner --subject "QAQC progress" --body-file ./updates/owner.md`
 - `npm install myte` then `npx myte update-client --subject "Weekly client update" --body-file ./updates/week-12.md`
 - `npm i -g myte` then `myte bootstrap`
 - `npm i -g myte` then `myte sync-qaqc`
+- `npm i -g myte` then `myte feedback-sync`
 - `npm i -g myte` then `myte query "..." --with-diff`
 - `npm i -g myte` then `myte update-team "Backend deploy completed; QAQC rerun queued."`
+- `npm i -g myte` then `myte update-owner --subject "QAQC progress" --body-file ./updates/owner.md`
 - `npm i -g myte` then `myte update-client --subject "Weekly client update" --body-file ./updates/week-12.md`
 - `npx myte@latest bootstrap`
 - `npx myte@latest sync-qaqc`
+- `npx myte@latest feedback-sync`
 - `npx myte@latest query "..." --with-diff`
 - `npx myte@latest update-team "Backend deploy completed; QAQC rerun queued."`
+- `npx myte@latest update-owner --subject "QAQC progress" --body-file ./updates/owner.md`
 - `npx myte@latest update-client --subject "Weekly client update" --body-file ./updates/week-12.md`
 - `npm install myte` then `npx myte create-prd ./drafts/auth-prd.md`
 - `cat ./drafts/auth-prd.md | npx myte create-prd --stdin`
@@ -41,8 +47,13 @@ Notes:
 - `sync-qaqc` writes active mission QAQC cards to `MyteCommandCenter/data/qaqc/active-missions` and refreshes matching `MyteCommandCenter/data/missions` cards.
 - `sync-qaqc` only exports active `Todo` / `In Progress` missions plus a public QAQC summary and sanitized latest batch metadata.
 - `sync-qaqc` removes previously QAQC-managed mission files from `MyteCommandCenter/data/missions` once they leave the active set.
+- `feedback-sync` writes public feedback cards under `MyteCommandCenter/data/feedback/items`.
+- `feedback-sync` writes readable PRD copies under `MyteCommandCenter/data/feedback/prds` when PRD text exists.
+- `feedback-sync` fully replaces the feedback-owned sync folders to avoid stale local feedback noise.
 - `create-prd` is a deterministic PRD upload path, not an LLM generation command.
 - `update-team` creates a project comment through `/api/project-assistant/project-comment`.
+- `update-owner` sends a direct owner email through `/api/project-assistant/update-owner`.
+- `update-owner` requires `--subject` plus body markdown from `--body-markdown`, `--body-file`, positional input, or `--stdin`.
 - `update-client` creates a client update draft through `/api/project-assistant/client-update-drafts`.
 - `update-client` requires `--subject` plus body markdown from `--body-markdown`, `--body-file`, positional input, or `--stdin`.
 - `update-client` accepts optional `--target-contact-id` repeats or `--target-contact-ids <id1,id2>`.
@@ -64,11 +75,13 @@ Deterministic `create-prd` contract:
 Examples:
 - `npx myte bootstrap`
 - `npx myte sync-qaqc`
+- `npx myte feedback-sync`
 - `npx myte bootstrap --dry-run --json`
 - `npx myte sync-qaqc --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`
 - `npx myte update-team "Backend deploy completed; QAQC rerun queued."`
+- `npx myte update-owner --subject "QAQC progress" --body-file ./updates/owner.md`
 - `npx myte update-client --subject "Weekly client update" --body-file ./updates/week-12.md`
 
 This package is published under the org scope for governance; the public `myte` wrapper delegates here.

package/cli.js

@@ -61,7 +61,9 @@ function splitCommand(argv) {
     "add-prd",
     "prd",
     "update-team",
+    "update-owner",
     "update-client",
+    "feedback-sync",
     "help",
     "--help",
     "-h",
@@ -78,7 +80,7 @@ function parseArgs(argv) {
   try {
     // eslint-disable-next-line global-require
     return require("minimist")(argv, {
-      boolean: ["with-diff", "diff", "print-context", "dry-run", "fetch", "json", "stdin"],
+      boolean: ["with-diff", "diff", "print-context", "dry-run", "fetch", "json", "stdin", "with-prd-text"],
       string: [
         "query",
         "q",
@@ -97,6 +99,8 @@ function parseArgs(argv) {
         "body-file",
         "target-contact-id",
         "target-contact-ids",
+        "status",
+        "source",
       ],
       alias: {
         q: "query",
@@ -153,11 +157,14 @@ function printHelp() {
     "  myte bootstrap [--output-dir ./MyteCommandCenter] [--json]",
     "  myte sync-qaqc [--output-dir ./MyteCommandCenter] [--json]",
     "  myte update-team \"<content>\" [--json]",
+    "  myte update-owner --subject \"<text>\" [--body-markdown \"...\"] [--body-file ./update.md] [--json]",
     "  myte update-client --subject \"<text>\" [--body-markdown \"...\"] [--body-file ./update.md] [--target-contact-ids <id1,id2>] [--json]",
+    "  myte feedback-sync [--status Pending] [--source User] [--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 \"...\"]",
+    "  cat update.md | myte update-owner --stdin --subject \"Owner update\"",
     "  cat update.md | myte update-client --stdin --subject \"Weekly client update\"",
     "",
     "Run forms:",
@@ -190,11 +197,21 @@ function printHelp() {
     "  - Creates a project team comment through /api/project-assistant/project-comment",
     "  - Required: content (inline, --content, or --stdin)",
     "",
+    "update-owner contract:",
+    "  - Sends a direct owner email through /api/project-assistant/update-owner",
+    "  - Required: --subject and body markdown (via --body-markdown, --body-file, positional file/text, or --stdin)",
+    "  - Uses Myte SMTP, resolves the owner from the project, and stores a durable send record",
+    "",
     "update-client contract:",
     "  - Creates a client update draft through /api/project-assistant/client-update-drafts",
     "  - Required: --subject and body markdown (via --body-markdown, --body-file, positional file/text, or --stdin)",
     "  - Optional: --target-contact-id <id> (repeatable) or --target-contact-ids <id1,id2>",
     "",
+    "feedback-sync contract:",
+    "  - Runs from the wrapper root that contains the project's configured repo folders",
+    "  - Writes project feedback cards under MyteCommandCenter/data/feedback/items",
+    "  - Writes PRD text copies under MyteCommandCenter/data/feedback/prds when available",
+    "",
     "Options:",
     "  --with-diff           Include deterministic git diffs (project-scoped)",
     "  --diff-limit <chars>  Truncate diff context to N chars (default: 200000)",
@@ -205,11 +222,14 @@ function printHelp() {
     "  --title <text>        Override PRD title for raw markdown uploads",
     "  --description <text>  Set feedback description/card summary for raw markdown uploads",
     "  --content <text>      Team update content for update-team",
-    "  --subject <text>      Client update subject for update-client",
-    "  --body-markdown <md>  Client update markdown body for update-client",
-    "  --body-file <path>    Read client update markdown body from a file",
+    "  --subject <text>      Subject for update-owner or update-client",
+    "  --body-markdown <md>  Markdown body for update-owner or update-client",
+    "  --body-file <path>    Read update-owner or update-client markdown body from a file",
     "  --target-contact-id   Add one client contact ObjectId (repeatable)",
     "  --target-contact-ids  Comma-separated client contact ObjectIds",
+    "  --status <value>      Feedback status filter for feedback-sync (default: Pending)",
+    "  --source <value>      Feedback source filter for feedback-sync",
+    "  --with-prd-text       Include extracted PRD text in feedback-sync (default: on)",
     "  --print-context       Print JSON payload and exit (no query call)",
     "  --no-fetch            Don't git fetch origin main/master before diff",
     "",
@@ -219,7 +239,9 @@ function printHelp() {
     "  myte bootstrap --output-dir ./MyteCommandCenter",
     "  myte sync-qaqc",
     "  myte update-team \"Backend deploy completed; QAQC rerun queued.\"",
+    "  myte update-owner --subject \"QAQC progress\" --body-file ./updates/owner.md",
     "  myte update-client --subject \"Weekly client update\" --body-file ./updates/week-12.md",
+    "  myte feedback-sync --status Pending --source User",
     "  myte update-client --subject \"Weekly client update\" --body-markdown \"## Progress\\n- Login complete\" --target-contact-ids 507f1f77bcf86cd799439011,507f1f77bcf86cd799439012",
     "  myte create-prd ./drafts/auth-prd.md --description \"Short card summary\"",
     "  cat ./drafts/auth-prd.md | myte create-prd --stdin",
@@ -377,6 +399,15 @@ async function resolveClientUpdateBody(args) {
   process.exit(1);
 }
 
+async function resolveOwnerUpdateBody(args) {
+  const body = await resolveClientUpdateBody(args);
+  if (!body) {
+    console.error("Owner update body_markdown is empty.");
+    process.exit(1);
+  }
+  return body;
+}
+
 function resolveTargetContactIds(args) {
   return dedupeStrings(
     parseCsvValues(
@@ -951,6 +982,33 @@ async function fetchQaqcSyncSnapshot({ apiBase, key, timeoutMs }) {
   return body.data || {};
 }
 
+async function fetchFeedbackSyncSnapshot({ apiBase, key, timeoutMs, filters = {} }) {
+  const fetchFn = await getFetch();
+  const url = new URL(`${apiBase}/project-assistant/feedback-sync`);
+  if (filters.status) url.searchParams.set("status", String(filters.status));
+  if (filters.source) url.searchParams.set("source", String(filters.source));
+  if (filters.includePrdText !== undefined) {
+    url.searchParams.set("include_prd_text", filters.includePrdText ? "true" : "false");
+  }
+  const { resp, body } = await fetchJsonWithTimeout(
+    fetchFn,
+    url.toString(),
+    {
+      method: "GET",
+      headers: { Authorization: `Bearer ${key}` },
+    },
+    timeoutMs
+  );
+
+  if (!resp.ok || body.status !== "success") {
+    const msg = body?.message || `Feedback sync 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}`;
@@ -1042,6 +1100,74 @@ async function runUpdateTeam(args) {
   }
 }
 
+async function runUpdateOwner(args) {
+  const key = getProjectApiKey();
+  if (!key) {
+    console.error("Missing MYTE_API_KEY (project key) in environment/.env");
+    process.exit(1);
+  }
+
+  const subject = firstNonEmptyString(args.subject);
+  if (!subject) {
+    console.error("Missing --subject for owner update.");
+    printHelp();
+    process.exit(1);
+  }
+
+  const payload = {
+    subject,
+    body_markdown: await resolveOwnerUpdateBody(args),
+  };
+
+  if (args["print-context"] || args.printContext || args["dry-run"] || args.dryRun) {
+    console.log(JSON.stringify(payload, null, 2));
+    return;
+  }
+
+  const timeoutMs = resolveTimeoutMs(args);
+  const apiBase = resolveApiBase(args);
+
+  let data;
+  try {
+    data = await callAssistantQuery({
+      apiBase,
+      key,
+      payload,
+      timeoutMs,
+      endpoint: "/project-assistant/update-owner",
+    });
+  } catch (err) {
+    if (err?.name === "AbortError") {
+      console.error(`Request timed out after ${timeoutMs}ms`);
+    } else {
+      console.error("Owner update failed:", err?.message || err);
+    }
+    process.exit(1);
+  }
+
+  if (args.json) {
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+
+  if (data.update_id) console.log(`Update ID: ${data.update_id}`);
+  if (data.project_title) console.log(`Project: ${data.project_title}`);
+  if (data.project_id) console.log(`Project ID: ${data.project_id}`);
+  if (data.status) console.log(`Status: ${data.status}`);
+  if (data.subject) console.log(`Subject: ${data.subject}`);
+  if (data.owner_name || data.owner_email) {
+    console.log(`Owner: ${data.owner_name || data.owner_email}${data.owner_email && data.owner_name ? ` <${data.owner_email}>` : ""}`);
+  }
+  if (data.sender_name || data.sender_email) {
+    console.log(`Sender: ${data.sender_name || data.sender_email}${data.sender_email && data.sender_name ? ` <${data.sender_email}>` : ""}`);
+  }
+  if (data.sent_at) console.log(`Sent At: ${data.sent_at}`);
+  if (data.snippet) {
+    console.log("Snippet:");
+    console.log(data.snippet);
+  }
+}
+
 async function runUpdateClient(args) {
   const key = getProjectApiKey();
   if (!key) {
@@ -1125,6 +1251,20 @@ function clearYamlDirectory(dirPath) {
   }
 }
 
+function clearFileDirectory(dirPath, extensions) {
+  const normalized = new Set((Array.isArray(extensions) ? extensions : []).map((ext) => String(ext || "").toLowerCase()));
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+    return;
+  }
+  for (const entry of fs.readdirSync(dirPath, { withFileTypes: true })) {
+    if (!entry.isFile()) continue;
+    const ext = path.extname(entry.name).toLowerCase();
+    if (normalized.size && !normalized.has(ext)) 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();
@@ -1149,6 +1289,11 @@ function writeJsonFile(filePath, value) {
   fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
 }
 
+function writeTextFile(filePath, value) {
+  ensureDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, String(value || ""), "utf8");
+}
+
 function readJsonFile(filePath) {
   if (!fs.existsSync(filePath) || !fs.statSync(filePath).isFile()) return null;
   try {
@@ -1324,6 +1469,66 @@ function writeQaqcSnapshot({ snapshot, wrapperRoot, outputDir }) {
   };
 }
 
+function writeFeedbackSnapshot({ snapshot, wrapperRoot, outputDir }) {
+  const targetRoot = outputDir
+    ? path.resolve(process.cwd(), String(outputDir))
+    : path.join(wrapperRoot, "MyteCommandCenter");
+  const dataRoot = path.join(targetRoot, "data");
+  const feedbackRoot = path.join(dataRoot, "feedback");
+  const itemsDir = path.join(feedbackRoot, "items");
+  const prdsDir = path.join(feedbackRoot, "prds");
+
+  ensureDir(dataRoot);
+  ensureDir(feedbackRoot);
+  clearYamlDirectory(itemsDir);
+  clearFileDirectory(prdsDir, [".md"]);
+
+  const items = Array.isArray(snapshot.items) ? snapshot.items.map((item) => scrubBootstrapValue(item)) : [];
+  const itemIds = [];
+  let prdCount = 0;
+
+  if (snapshot.project && typeof snapshot.project === "object") {
+    writeYamlFile(path.join(dataRoot, "project.yml"), scrubBootstrapValue(snapshot.project));
+  }
+
+  items.forEach((item, index) => {
+    const feedbackId = stableItemId(item, ["feedback_id", "id"], `F${String(index + 1).padStart(3, "0")}`);
+    itemIds.push(feedbackId);
+    const card = scrubBootstrapValue(item);
+    const prdText = String(card.prd_text || "").trim();
+    if (prdText) {
+      delete card.prd_text;
+      card.prd_file = `prds/${feedbackId}.md`;
+      writeTextFile(path.join(prdsDir, `${feedbackId}.md`), `${prdText}\n`);
+      prdCount += 1;
+    }
+    writeYamlFile(path.join(itemsDir, `${feedbackId}.yml`), card);
+  });
+
+  const manifest = {
+    schema_version: snapshot.schema_version || 1,
+    generated_at: snapshot.generated_at || null,
+    snapshot_hash: snapshot.snapshot_hash || null,
+    project: snapshot.project ? scrubBootstrapValue(snapshot.project) : null,
+    repo_names: Array.isArray(snapshot.repo_names) ? snapshot.repo_names : [],
+    filters: snapshot.filters && typeof snapshot.filters === "object" ? scrubBootstrapValue(snapshot.filters) : {},
+    item_ids: itemIds,
+    counts: snapshot.counts && typeof snapshot.counts === "object"
+      ? scrubBootstrapValue(snapshot.counts)
+      : { total_feedback: items.length, with_prd_text: prdCount },
+  };
+  if (snapshot.pagination && typeof snapshot.pagination === "object") {
+    manifest.pagination = scrubBootstrapValue(snapshot.pagination);
+  }
+  writeJsonFile(path.join(feedbackRoot, "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) {
@@ -1667,6 +1872,103 @@ async function runSyncQaqc(args) {
   console.log(`Snapshot: ${summary.snapshot_hash || "n/a"}`);
 }
 
+async function runFeedbackSync(args) {
+  const key = getProjectApiKey();
+  if (!key) {
+    console.error("Missing MYTE_API_KEY (project key) in environment/.env");
+    process.exit(1);
+  }
+
+  const timeoutMs = resolveTimeoutMs(args);
+  const apiBase = resolveApiBase(args);
+  const includePrdText = args["with-prd-text"] !== undefined
+    ? Boolean(args["with-prd-text"])
+    : args.withPrdText !== undefined
+      ? Boolean(args.withPrdText)
+      : true;
+  const filters = {
+    status: firstNonEmptyString(args.status) || "Pending",
+    source: firstNonEmptyString(args.source) || "",
+    includePrdText,
+  };
+
+  let snapshot;
+  try {
+    snapshot = await fetchFeedbackSyncSnapshot({ apiBase, key, timeoutMs, filters });
+  } catch (err) {
+    console.error("Failed to fetch feedback sync 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 counts = snapshot.counts && typeof snapshot.counts === "object" ? snapshot.counts : {};
+  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 || [],
+    },
+    filters: snapshot.filters && typeof snapshot.filters === "object" ? snapshot.filters : filters,
+    counts,
+    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: total_feedback=${summary.counts.total_feedback || 0}, with_prd_text=${summary.counts.with_prd_text || 0}`);
+      console.log("Dry run only - no files written.");
+    }
+    return;
+  }
+
+  const writeResult = writeFeedbackSnapshot({ 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 feedback: total_feedback=${summary.counts.total_feedback || 0}, with_prd_text=${summary.counts.with_prd_text || 0}`);
+  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) {
@@ -1810,6 +2112,11 @@ async function main() {
     return;
   }
 
+  if (command === "feedback-sync") {
+    await runFeedbackSync(args);
+    return;
+  }
+
   if (command === "chat") {
     await runChat(args);
     return;
@@ -1825,6 +2132,11 @@ async function main() {
     return;
   }
 
+  if (command === "update-owner") {
+    await runUpdateOwner(args);
+    return;
+  }
+
   if (command === "update-client") {
     await runUpdateClient(args);
     return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mytegroupinc/myte-core",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "description": "Myte CLI core implementation (Project Assistant + deterministic diffs).",
   "type": "commonjs",
   "main": "cli.js",