miriad-viz 0.1.0 → 0.1.2

package/dist-cli/chunk-ANKD3SEX.js

@@ -0,0 +1,120 @@
+// src/cli/extract/extract-chat.ts
+function extractMentions(content, sender, agents) {
+  const mentions = /* @__PURE__ */ new Set();
+  if (content.includes("@channel") && agents) {
+    for (const agent of agents) {
+      if (agent !== sender) mentions.add(agent);
+    }
+    return [...mentions].sort();
+  }
+  const matches = content.match(/@(\w+)/g);
+  if (!matches) return [];
+  for (const match of matches) {
+    const name = match.slice(1).toLowerCase();
+    if (name === "channel") continue;
+    if (name === sender) continue;
+    if (agents && !agents.has(name)) continue;
+    mentions.add(name);
+  }
+  return [...mentions].sort();
+}
+function hourKey(timestamp) {
+  return timestamp.slice(0, 13);
+}
+function detectBursts(messages, windowMinutes = 10, minMessages = 50) {
+  if (messages.length === 0) return [];
+  const sorted = [...messages].sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+  const bursts = [];
+  const windowMs = windowMinutes * 60 * 1e3;
+  let windowStart = 0;
+  for (let windowEnd = 0; windowEnd < sorted.length; windowEnd++) {
+    const endTime = new Date(sorted[windowEnd].timestamp).getTime();
+    while (windowStart < windowEnd && endTime - new Date(sorted[windowStart].timestamp).getTime() > windowMs) {
+      windowStart++;
+    }
+    const count = windowEnd - windowStart + 1;
+    if (count >= minMessages) {
+      const start = sorted[windowStart].timestamp;
+      const end = sorted[windowEnd].timestamp;
+      if (bursts.length === 0 || start > bursts[bursts.length - 1].end) {
+        bursts.push({ start, end, messages: count, label: "" });
+      } else {
+        const prev = bursts[bursts.length - 1];
+        prev.end = end;
+        prev.messages = Math.max(prev.messages, count);
+      }
+    }
+  }
+  return bursts;
+}
+function buildChatActivity(messages, channelName, knownAgents) {
+  if (messages.length === 0) {
+    throw new Error("No messages to process. Check channel name and extraction.");
+  }
+  const sorted = [...messages].sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+  const agents = knownAgents ? new Set(knownAgents.map((a) => a.toLowerCase())) : new Set(sorted.map((m) => m.sender.toLowerCase()));
+  const agentTotals = {};
+  for (const msg of sorted) {
+    agentTotals[msg.sender] = (agentTotals[msg.sender] || 0) + 1;
+  }
+  const hourlyTotals = {};
+  for (const msg of sorted) {
+    const key = hourKey(msg.timestamp);
+    hourlyTotals[key] = (hourlyTotals[key] || 0) + 1;
+  }
+  const mentionGraph = {};
+  for (const msg of sorted) {
+    const mentions = extractMentions(msg.content, msg.sender, agents);
+    if (mentions.length === 0) continue;
+    if (!mentionGraph[msg.sender]) mentionGraph[msg.sender] = {};
+    for (const target of mentions) {
+      mentionGraph[msg.sender][target] = (mentionGraph[msg.sender][target] || 0) + 1;
+    }
+  }
+  const pairCounts = /* @__PURE__ */ new Map();
+  for (const [sender, targets] of Object.entries(mentionGraph)) {
+    for (const [target, count] of Object.entries(targets)) {
+      const key = [sender, target].sort().join("\u2194");
+      const existing = pairCounts.get(key);
+      if (existing) {
+        existing.total += count;
+      } else {
+        pairCounts.set(key, { agents: [sender, target].sort(), total: count });
+      }
+    }
+  }
+  const topPairs = [...pairCounts.values()].sort((a, b) => b.total - a.total).slice(0, 20);
+  const bursts = detectBursts(sorted);
+  const roleActivity = {};
+  const start = sorted[0].timestamp;
+  const end = sorted[sorted.length - 1].timestamp;
+  const hoursSpanned = (new Date(end).getTime() - new Date(start).getTime()) / (1e3 * 60 * 60);
+  return {
+    extractedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    method: `miriad-viz extract-chat from channel "${channelName}"`,
+    coverage: {
+      start,
+      end,
+      hoursSpanned: Math.round(hoursSpanned * 10) / 10,
+      totalMessages: sorted.length,
+      errorMessages: sorted.filter(
+        (m) => m.content.startsWith("Error:") || m.content.startsWith("error:")
+      ).length,
+      contentMessages: sorted.filter(
+        (m) => !m.content.startsWith("Error:") && !m.content.startsWith("error:")
+      ).length,
+      note: `Extracted from #${channelName}`
+    },
+    agentTotals,
+    hourlyTotals,
+    mentionGraph,
+    topPairs,
+    bursts,
+    roleActivity
+  };
+}
+
+export {
+  extractMentions,
+  buildChatActivity
+};

package/dist-cli/chunk-JITEBF25.js

@@ -0,0 +1,63 @@
+// src/cli/extract/extract-artifacts.ts
+function buildArtifactData(artifacts, phasePatterns) {
+  const byType = {};
+  const byStatus = {};
+  for (const a of artifacts) {
+    byType[a.type] = (byType[a.type] || 0) + 1;
+    if (a.status) {
+      byStatus[a.status] = (byStatus[a.status] || 0) + 1;
+    }
+  }
+  const categories = {};
+  for (const a of artifacts) {
+    if (!categories[a.type]) {
+      categories[a.type] = { count: 0, items: [] };
+    }
+    categories[a.type].count++;
+    categories[a.type].items?.push({
+      slug: a.slug,
+      title: a.title,
+      ...a.createdBy ? { createdBy: a.createdBy } : {}
+    });
+  }
+  const phases = {};
+  if (phasePatterns) {
+    for (const [phaseName, patterns] of Object.entries(phasePatterns)) {
+      const matching = artifacts.filter(
+        (a) => patterns.some(
+          (p) => a.slug.includes(p) || a.parentSlug?.includes(p) || a.title?.includes(p)
+        )
+      );
+      phases[phaseName] = {
+        artifacts: matching.map((a) => a.slug),
+        count: matching.length
+      };
+    }
+  } else {
+    const byParent = /* @__PURE__ */ new Map();
+    for (const a of artifacts) {
+      const parent = a.parentSlug || "_root";
+      if (!byParent.has(parent)) byParent.set(parent, []);
+      byParent.get(parent).push(a);
+    }
+    for (const [parent, items] of byParent) {
+      phases[parent] = {
+        artifacts: items.map((a) => a.slug),
+        count: items.length
+      };
+    }
+  }
+  return {
+    summary: {
+      total: artifacts.length,
+      byType,
+      byStatus
+    },
+    categories,
+    phases
+  };
+}
+
+export {
+  buildArtifactData
+};

package/dist-cli/chunk-O4B2276N.js

@@ -0,0 +1,290 @@
+// src/transform/transform-raw.ts
+function inferRole(roleString) {
+  const s = roleString.toLowerCase();
+  if (s.includes("human") || s === "user") return "human";
+  if (s.includes("lead")) return "lead";
+  if (s.includes("pm")) return "pm";
+  if (s.includes("tester") || s.includes("qa")) return "tester";
+  if (s.includes("reviewer") || s.includes("review")) return "reviewer";
+  if (s.includes("auditor") || s.includes("audit")) return "auditor";
+  if (s.includes("challenger") || s.includes("challenge")) return "challenger";
+  if (s.includes("scout")) return "scout";
+  if (s.includes("ideation")) return "ideation";
+  if (s.includes("research")) return "researcher";
+  if (s.includes("builder") || s.includes("build")) return "builder";
+  return "builder";
+}
+function transformToRawData(sources) {
+  const defaultAgent = sources.retroPageData.teamAssembly[0]?.agent.replace("@", "") ?? "unknown";
+  return {
+    project: {
+      name: sources.retroPageData.meta.title,
+      description: sources.retroPageData.meta.subtitle
+    },
+    agents: transformAgents(
+      sources.retroPageData,
+      sources.chatActivity.agentTotals,
+      sources.timelineEvents
+    ),
+    commits: transformCommits(sources.commits, sources.prAgentMap, defaultAgent),
+    prs: transformPRs(sources.prs, sources.prAgentMap),
+    messages: transformMessages(sources.timelineEvents),
+    artifacts: sources.artifactData ? transformArtifacts(
+      sources.artifactData,
+      sources.retroPageData,
+      sources.prs,
+      sources.prAgentMap
+    ) : []
+  };
+}
+function buildFirstMessageTimeMap(timelineEvents) {
+  const map = /* @__PURE__ */ new Map();
+  if (!timelineEvents) return map;
+  for (const evt of timelineEvents.events) {
+    if (evt.type !== "message" && evt.type !== "beam") continue;
+    const sender = evt.from;
+    const ts = new Date(evt.t).getTime();
+    const existing = map.get(sender);
+    if (existing === void 0 || ts < existing) {
+      map.set(sender, ts);
+    }
+  }
+  return map;
+}
+function transformAgents(retroData, agentTotals, timelineEvents, agentRoles) {
+  const agents = [];
+  const seen = /* @__PURE__ */ new Set();
+  const firstMessageTime = buildFirstMessageTimeMap(timelineEvents);
+  const assemblyRoles = /* @__PURE__ */ new Map();
+  for (const entry of retroData.teamAssembly) {
+    const id = entry.agent.replace("@", "");
+    assemblyRoles.set(id, entry.role);
+  }
+  function resolveRole(id) {
+    if (agentRoles?.[id]) {
+      return inferRole(agentRoles[id]);
+    }
+    const assemblyRole = assemblyRoles.get(id);
+    if (assemblyRole) {
+      return inferRole(assemblyRole);
+    }
+    return "builder";
+  }
+  function resolveJoinedAt(id, assemblyTime) {
+    const msgTime = firstMessageTime.get(id);
+    if (msgTime !== void 0 && assemblyTime !== void 0) {
+      return Math.min(msgTime, assemblyTime);
+    }
+    if (msgTime !== void 0) return msgTime;
+    if (assemblyTime !== void 0) return assemblyTime;
+    return new Date(retroData.meta.startDate).getTime();
+  }
+  for (const entry of retroData.teamAssembly) {
+    const id = entry.agent.replace("@", "");
+    if (seen.has(id)) continue;
+    seen.add(id);
+    agents.push({
+      id,
+      role: resolveRole(id),
+      joinedAt: resolveJoinedAt(id, new Date(entry.time).getTime())
+    });
+  }
+  for (const id of Object.keys(agentTotals)) {
+    if (seen.has(id)) continue;
+    agents.push({
+      id,
+      role: resolveRole(id),
+      joinedAt: resolveJoinedAt(id)
+    });
+    seen.add(id);
+  }
+  return agents;
+}
+function transformCommits(commits, prAgentMap, defaultAgent = "unknown") {
+  return commits.map((c) => {
+    const agent = resolveCommitAgent(c, prAgentMap, defaultAgent);
+    return {
+      sha: c.hash,
+      timestamp: new Date(c.date).getTime(),
+      agent,
+      message: c.subject,
+      filesChanged: c.files.length,
+      insertions: c.totalInsertions,
+      deletions: c.totalDeletions,
+      prNumber: c.prNumber ?? void 0
+    };
+  });
+}
+function resolveCommitAgent(commit, prAgentMap, defaultAgent = "unknown") {
+  if (commit.prNumber != null) {
+    const agent = prAgentMap[String(commit.prNumber)];
+    if (agent) return agent;
+  }
+  const mergeMatch = commit.subject.match(/^Merge pull request #(\d+)/);
+  if (mergeMatch) {
+    const agent = prAgentMap[mergeMatch[1]];
+    if (agent) return agent;
+  }
+  const suffixMatch = commit.subject.match(/\(#(\d+)\)\s*$/);
+  if (suffixMatch) {
+    const agent = prAgentMap[suffixMatch[1]];
+    if (agent) return agent;
+  }
+  return defaultAgent;
+}
+function transformPRs(prs, prAgentMap) {
+  return prs.map((pr) => {
+    const agent = prAgentMap[String(pr.number)] ?? "unknown";
+    return {
+      number: pr.number,
+      title: pr.title,
+      agent,
+      createdAt: new Date(pr.createdAt).getTime(),
+      mergedAt: pr.mergedAt ? new Date(pr.mergedAt).getTime() : null,
+      additions: pr.additions,
+      deletions: pr.deletions,
+      branch: pr.headRefName
+    };
+  });
+}
+function inferArtifactType(slug) {
+  if (slug.includes(".app.") || slug.endsWith(".ts") || slug.endsWith(".js")) return "code";
+  if (slug.includes("screenshot") || slug.includes("qa-")) return "asset";
+  if (slug.includes("decision")) return "decision";
+  if (slug.includes("task") || slug.includes("phase-")) return "task";
+  if (slug.startsWith("spec-") || slug.startsWith("spec")) return "doc";
+  if (slug.includes("concept")) return "doc";
+  return "doc";
+}
+function resolveArtifactAgent(slug, prAgentMap, createdBy, defaultAgent) {
+  if (createdBy) return createdBy;
+  const prMatch = slug.match(/#?(\d+)/);
+  if (prMatch) {
+    const agent = prAgentMap[prMatch[1]];
+    if (agent) return agent;
+  }
+  return defaultAgent;
+}
+var CATEGORY_TYPE_MAP = {
+  qaScreenshots: "asset",
+  transitionSpecs: "doc",
+  transitionConcepts: "doc",
+  scenes: "doc",
+  vizConcepts: "code",
+  teamPrinciples: "doc",
+  retroData: "doc",
+  decisions: "decision"
+};
+function distributeTimestamps(count, bounds, prTimestamps) {
+  const phasePRTimes = prTimestamps.filter((t) => t >= bounds.start && t <= bounds.end);
+  const timestamps = [];
+  for (let i = 0; i < count; i++) {
+    let timestamp;
+    if (phasePRTimes.length > 0) {
+      const prIdx = i % phasePRTimes.length;
+      timestamp = phasePRTimes[prIdx] + i * 6e4;
+    } else {
+      const fraction = count > 1 ? i / (count - 1) : 0.5;
+      timestamp = bounds.start + fraction * (bounds.end - bounds.start);
+    }
+    timestamps.push(Math.round(Math.max(bounds.start, Math.min(bounds.end, timestamp))));
+  }
+  return timestamps;
+}
+function buildCategoryDistribution(categories) {
+  const entries = [];
+  let total = 0;
+  for (const [categoryName, categoryData] of Object.entries(categories)) {
+    if (categoryData.count === 0) continue;
+    entries.push({
+      type: CATEGORY_TYPE_MAP[categoryName] ?? "doc",
+      count: categoryData.count
+    });
+    total += categoryData.count;
+  }
+  if (total === 0) return [{ type: "doc", weight: 1 }];
+  return entries.sort((a, b) => b.count - a.count).map((e) => ({ type: e.type, weight: e.count / total }));
+}
+function buildCreatedByLookup(categories) {
+  const lookup = /* @__PURE__ */ new Map();
+  for (const categoryData of Object.values(categories)) {
+    for (const item of categoryData.items ?? []) {
+      if (typeof item === "object" && item.createdBy) {
+        lookup.set(item.slug, item.createdBy);
+      }
+    }
+  }
+  return lookup;
+}
+function transformArtifacts(artifactData, retroData, prs, prAgentMap) {
+  const artifacts = [];
+  const agentIds = retroData.teamAssembly.map((e) => e.agent.replace("@", ""));
+  const defaultAgent = agentIds[0] ?? "unknown";
+  const phaseBoundaries = retroData.phases.map((p) => ({
+    start: new Date(p.start).getTime(),
+    end: new Date(p.end).getTime()
+  }));
+  const prTimestamps = prs.map((pr) => new Date(pr.createdAt).getTime()).sort((a, b) => a - b);
+  const distribution = buildCategoryDistribution(artifactData.categories);
+  const createdByLookup = buildCreatedByLookup(artifactData.categories);
+  let phaseIndex = 0;
+  let globalBulkIndex = 0;
+  for (const [_phaseName, phaseData] of Object.entries(artifactData.phases)) {
+    if (phaseIndex >= phaseBoundaries.length) break;
+    const bounds = phaseBoundaries[phaseIndex];
+    phaseIndex++;
+    const totalCount = phaseData.count;
+    const slugs = phaseData.artifacts;
+    const bulkCount = Math.max(0, totalCount - slugs.length);
+    const timestamps = distributeTimestamps(totalCount, bounds, prTimestamps);
+    let tsIdx = 0;
+    for (const slug of slugs) {
+      artifacts.push({
+        slug,
+        type: inferArtifactType(slug),
+        createdAt: timestamps[tsIdx],
+        updatedAt: timestamps[tsIdx],
+        agent: resolveArtifactAgent(slug, prAgentMap, createdByLookup.get(slug), defaultAgent)
+      });
+      tsIdx++;
+    }
+    let distIdx = 0;
+    let distBudget = Math.round(distribution[0].weight * bulkCount);
+    for (let i = 0; i < bulkCount; i++) {
+      while (distBudget <= 0 && distIdx < distribution.length - 1) {
+        distIdx++;
+        distBudget = Math.round(distribution[distIdx].weight * bulkCount);
+      }
+      distBudget--;
+      const entry = distribution[distIdx];
+      const agent = agentIds.length > 0 ? agentIds[globalBulkIndex % agentIds.length] : defaultAgent;
+      artifacts.push({
+        slug: `phase${phaseIndex}-${entry.type}-${String(globalBulkIndex + 1).padStart(3, "0")}`,
+        type: entry.type,
+        createdAt: timestamps[tsIdx],
+        updatedAt: timestamps[tsIdx],
+        agent
+      });
+      tsIdx++;
+      globalBulkIndex++;
+    }
+  }
+  artifacts.sort((a, b) => a.createdAt - b.createdAt);
+  return artifacts;
+}
+function transformMessages(timelineEvents) {
+  const messageEvents = timelineEvents.events.filter(
+    (e) => e.type === "message" || e.type === "beam"
+  );
+  return messageEvents.map((evt, i) => ({
+    id: `msg-${String(i).padStart(4, "0")}`,
+    timestamp: new Date(evt.t).getTime(),
+    sender: evt.from,
+    mentions: [evt.to]
+  }));
+}
+
+export {
+  inferRole,
+  transformToRawData
+};

package/dist-cli/chunk-TJ2ZJRJV.js

@@ -0,0 +1,168 @@
+// src/cli/guided/types.ts
+var STEPS = [
+  "init",
+  "extract",
+  "curate",
+  "transform",
+  "preview",
+  "audio",
+  "render"
+];
+function createProgressFile(project) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    version: 1,
+    project,
+    steps: {
+      init: { status: "complete", completedAt: now },
+      extract: { status: "pending" },
+      curate: { status: "pending" },
+      transform: { status: "pending" },
+      preview: { status: "pending" },
+      audio: { status: "pending" },
+      render: { status: "pending" }
+    },
+    lastUpdated: now
+  };
+}
+function getNextStep(progress) {
+  for (const step of STEPS) {
+    if (progress.steps[step].status !== "complete") {
+      return step;
+    }
+  }
+  return null;
+}
+var STEP_CONFIG = {
+  init: {
+    mode: "inline",
+    label: "Initialize project",
+    outputFiles: [".miriad-viz.json"]
+  },
+  extract: {
+    mode: "background",
+    label: "Extract source data",
+    logFile: "extract.log",
+    outputFiles: ["data/git-commits.json", "data/chat-activity.json"]
+  },
+  curate: {
+    mode: "inline",
+    label: "Curate editorial content",
+    outputFiles: [
+      "data/retro-page-data.json",
+      "data/retro-page-quotes.json",
+      "data/timeline-events.json"
+    ]
+  },
+  transform: {
+    mode: "background",
+    label: "Transform to viz-data",
+    logFile: "transform.log",
+    outputFiles: ["output/viz-data.json"]
+  },
+  preview: {
+    mode: "inline",
+    label: "Preview visualization",
+    outputFiles: ["viewer/public/data/viz-data.json"]
+  },
+  audio: {
+    mode: "inline",
+    label: "Generate audio (ElevenLabs)",
+    outputFiles: []
+  },
+  render: {
+    mode: "background",
+    label: "Render video (Remotion)",
+    logFile: "render.log",
+    outputFiles: ["remotion/out/video.mp4"]
+  }
+};
+
+// src/cli/guided/progress.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { resolve } from "path";
+var PROGRESS_FILENAME = ".miriad-viz.json";
+function migrateProgressSteps(progress) {
+  let migrated = false;
+  for (const step of STEPS) {
+    if (!(step in progress.steps)) {
+      const stepIndex = STEPS.indexOf(step);
+      const nextStep = stepIndex < STEPS.length - 1 ? STEPS[stepIndex + 1] : null;
+      if (nextStep && progress.steps[nextStep]?.status !== "pending") {
+        progress.steps[step] = {
+          status: "complete",
+          completedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      } else {
+        progress.steps[step] = { status: "pending" };
+      }
+      migrated = true;
+    }
+  }
+  return migrated;
+}
+function readProgress(dir) {
+  const path = resolve(dir, PROGRESS_FILENAME);
+  if (!existsSync(path)) return null;
+  try {
+    const raw = readFileSync(path, "utf-8");
+    const data = JSON.parse(raw);
+    if (data.version !== 1) {
+      throw new Error(`Unsupported progress file version: ${data.version}`);
+    }
+    if (migrateProgressSteps(data)) {
+      writeProgress(dir, data);
+    }
+    return data;
+  } catch (err) {
+    if (err instanceof SyntaxError) {
+      throw new Error(`Corrupted progress file at ${path}: ${err.message}`);
+    }
+    throw err;
+  }
+}
+function writeProgress(dir, progress) {
+  progress.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+  const path = resolve(dir, PROGRESS_FILENAME);
+  writeFileSync(path, `${JSON.stringify(progress, null, 2)}
+`);
+}
+function markComplete(progress, step, outputs) {
+  progress.steps[step] = {
+    status: "complete",
+    completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    outputs
+  };
+}
+function markInProgress(progress, step) {
+  progress.steps[step] = { status: "in_progress" };
+}
+function markError(progress, step, error) {
+  progress.steps[step] = { status: "error", error };
+}
+function findProjectDir(startDir) {
+  let dir = resolve(startDir);
+  const root = resolve("/");
+  while (dir !== root) {
+    if (existsSync(resolve(dir, PROGRESS_FILENAME))) {
+      return dir;
+    }
+    const parent = resolve(dir, "..");
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+export {
+  createProgressFile,
+  getNextStep,
+  STEP_CONFIG,
+  PROGRESS_FILENAME,
+  readProgress,
+  writeProgress,
+  markComplete,
+  markInProgress,
+  markError,
+  findProjectDir
+};

package/dist-cli/chunk-XI2U2ON3.js

@@ -0,0 +1,56 @@
+// src/cli/guided/steps/init-template.ts
+import { cpSync, existsSync, readFileSync, writeFileSync } from "fs";
+import { dirname, relative, resolve } from "path";
+import { fileURLToPath } from "url";
+var VALID_TEMPLATES = ["viewer", "remotion"];
+function scaffoldTemplate(templateName, outDir, packageRoot) {
+  if (!VALID_TEMPLATES.includes(templateName)) {
+    throw new Error(`Template '${templateName}' not found. Valid: ${VALID_TEMPLATES.join(", ")}`);
+  }
+  if (existsSync(outDir)) {
+    throw new Error(`Directory already exists: ${outDir}`);
+  }
+  const templateDir = resolve(packageRoot, "template", templateName);
+  if (!existsSync(templateDir)) {
+    throw new Error(`Template directory not found: ${templateDir}`);
+  }
+  cpSync(templateDir, outDir, {
+    recursive: true,
+    filter: (src) => {
+      const rel = relative(templateDir, src);
+      return rel === "" || !rel.split("/").includes("node_modules");
+    }
+  });
+  const pkgPath = resolve(outDir, "package.json");
+  if (existsSync(pkgPath)) {
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    if (pkg.dependencies?.["miriad-viz"]?.startsWith("file:")) {
+      const parentPkgPath = resolve(packageRoot, "package.json");
+      const parentPkg = JSON.parse(readFileSync(parentPkgPath, "utf-8"));
+      const version = parentPkg.version;
+      if (packageRoot.split("/").includes("node_modules")) {
+        pkg.dependencies["miriad-viz"] = `^${version}`;
+      } else {
+        pkg.dependencies["miriad-viz"] = `file:${packageRoot}`;
+      }
+      writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}
+`);
+    }
+  }
+}
+function resolvePackageRoot(importMetaUrl) {
+  const thisFile = fileURLToPath(importMetaUrl);
+  let dir = dirname(thisFile);
+  for (let i = 0; i < 10; i++) {
+    if (existsSync(resolve(dir, "package.json")) && existsSync(resolve(dir, "template"))) {
+      return dir;
+    }
+    dir = resolve(dir, "..");
+  }
+  throw new Error("Could not find miriad-viz package root");
+}
+
+export {
+  scaffoldTemplate,
+  resolvePackageRoot
+};