taketomarket 2.2.0 → 2.3.0

package/bin/lib/health.cjs

@@ -14,7 +14,7 @@ const path = require('path');
 const { output, safeReadFile, parseFrontmatter } = require('./core.cjs');
 
 /**
- * Expected reference files in .marketing/ directory.
+ * Expected reference files in .taketomarket/ directory.
  */
 const REFERENCE_FILES = [
   'POSITIONING.md',
@@ -26,6 +26,7 @@ const REFERENCE_FILES = [
   'COMPETITORS.md',
   'METRICS.md',
   'LEARNINGS.md',
+  'PRODUCT-DNA.md',
 ];
 
 /**
@@ -85,7 +86,7 @@ function checkCampaignStateConsistency(campaignsDir) {
       checks.push({
         name: `campaign_state_${entry.name}`,
         status: 'fail',
-        path: `.marketing/CAMPAIGNS/${entry.name}/STATE.md`,
+        path: `.taketomarket/CAMPAIGNS/${entry.name}/STATE.md`,
         detail: 'STATE.md missing',
       });
       continue;
@@ -95,14 +96,14 @@ function checkCampaignStateConsistency(campaignsDir) {
       checks.push({
         name: `campaign_state_${entry.name}`,
         status: 'fail',
-        path: `.marketing/CAMPAIGNS/${entry.name}/STATE.md`,
+        path: `.taketomarket/CAMPAIGNS/${entry.name}/STATE.md`,
         detail: `invalid phase: ${frontmatter.phase || 'undefined'}`,
       });
     } else {
       checks.push({
         name: `campaign_state_${entry.name}`,
         status: 'pass',
-        path: `.marketing/CAMPAIGNS/${entry.name}/STATE.md`,
+        path: `.taketomarket/CAMPAIGNS/${entry.name}/STATE.md`,
       });
     }
   }
@@ -111,7 +112,7 @@ function checkCampaignStateConsistency(campaignsDir) {
 
 /**
  * Check reference file staleness based on mtime.
- * @param {string} marketingDir - Path to .marketing/ directory
+ * @param {string} marketingDir - Path to .taketomarket/ directory
  * @param {number} thresholdDays - Days threshold for staleness warning (default 90)
  * @returns {Array} Array of check objects
  */
@@ -131,14 +132,14 @@ function checkReferenceStaleness(marketingDir, thresholdDays) {
         checks.push({
           name: `staleness_${file.toLowerCase().replace('.md', '')}`,
           status: 'warn',
-          path: `.marketing/${file}`,
+          path: `.taketomarket/${file}`,
           detail: `not updated in ${ageDays} days`,
         });
       } else {
         checks.push({
           name: `staleness_${file.toLowerCase().replace('.md', '')}`,
           status: 'pass',
-          path: `.marketing/${file}`,
+          path: `.taketomarket/${file}`,
         });
       }
     } catch {
@@ -183,14 +184,14 @@ function checkCampaignVelocity(campaignsDir, thresholdDays) {
       checks.push({
         name: `velocity_${entry.name}`,
         status: 'warn',
-        path: `.marketing/CAMPAIGNS/${entry.name}/STATE.md`,
+        path: `.taketomarket/CAMPAIGNS/${entry.name}/STATE.md`,
         detail: `stuck in ${frontmatter.phase} for ${ageDays} days`,
       });
     } else {
       checks.push({
         name: `velocity_${entry.name}`,
         status: 'pass',
-        path: `.marketing/CAMPAIGNS/${entry.name}/STATE.md`,
+        path: `.taketomarket/CAMPAIGNS/${entry.name}/STATE.md`,
       });
     }
   }
@@ -199,7 +200,7 @@ function checkCampaignVelocity(campaignsDir, thresholdDays) {
 
 /**
  * Check DRIFT-LOG.md structural integrity.
- * @param {string} marketingDir - Path to .marketing/ directory
+ * @param {string} marketingDir - Path to .taketomarket/ directory
  * @returns {Array} Array of check objects
  */
 function checkDriftLogIntegrity(marketingDir) {
@@ -211,7 +212,7 @@ function checkDriftLogIntegrity(marketingDir) {
     checks.push({
       name: 'drift_log_integrity',
       status: 'warn',
-      path: '.marketing/DRIFT-LOG.md',
+      path: '.taketomarket/DRIFT-LOG.md',
       detail: 'no drift log yet',
     });
     return checks;
@@ -222,21 +223,21 @@ function checkDriftLogIntegrity(marketingDir) {
     checks.push({
       name: 'drift_log_integrity',
       status: 'fail',
-      path: '.marketing/DRIFT-LOG.md',
+      path: '.taketomarket/DRIFT-LOG.md',
       detail: 'missing audit trail marker',
     });
   } else if (markerCount > 1) {
     checks.push({
       name: 'drift_log_integrity',
       status: 'fail',
-      path: '.marketing/DRIFT-LOG.md',
+      path: '.taketomarket/DRIFT-LOG.md',
       detail: 'duplicate audit trail markers',
     });
   } else {
     checks.push({
       name: 'drift_log_integrity',
       status: 'pass',
-      path: '.marketing/DRIFT-LOG.md',
+      path: '.taketomarket/DRIFT-LOG.md',
     });
   }
   return checks;
@@ -276,14 +277,14 @@ function checkGateConsistency(campaignsDir) {
       checks.push({
         name: `gate_consistency_${entry.name}`,
         status: 'fail',
-        path: `.marketing/CAMPAIGNS/${entry.name}/STATE.md`,
+        path: `.taketomarket/CAMPAIGNS/${entry.name}/STATE.md`,
         detail: `invalid gate values: ${invalidGates.join(', ')}`,
       });
     } else {
       checks.push({
         name: `gate_consistency_${entry.name}`,
         status: 'pass',
-        path: `.marketing/CAMPAIGNS/${entry.name}/STATE.md`,
+        path: `.taketomarket/CAMPAIGNS/${entry.name}/STATE.md`,
       });
     }
   }
@@ -291,11 +292,11 @@ function checkGateConsistency(campaignsDir) {
 }
 
 /**
- * Validate .marketing/ directory structure.
+ * Validate .taketomarket/ directory structure.
  *
  * Checks:
- * 1. .marketing/ directory exists
- * 2. .marketing/CAMPAIGNS/ directory exists
+ * 1. .taketomarket/ directory exists
+ * 2. .taketomarket/CAMPAIGNS/ directory exists
  * 3. Each expected reference file exists
  * 4. STATE.md has valid frontmatter (parseable)
  *
@@ -306,23 +307,23 @@ function checkGateConsistency(campaignsDir) {
  * 8. DRIFT-LOG integrity
  * 9. Gate result consistency
  *
- * healthy = true when .marketing/ and CAMPAIGNS/ both exist and no 'fail' checks.
+ * healthy = true when .taketomarket/ and CAMPAIGNS/ both exist and no 'fail' checks.
  * Reference files use "missing" status (expected before /ttm-init runs).
  *
  * @param {boolean} raw - Whether to output raw summary string
  * @param {boolean} full - Whether to run extended audit checks
  */
 function cmdHealth(raw, full) {
-  const marketingDir = path.resolve(process.cwd(), '.marketing');
+  const marketingDir = path.resolve(process.cwd(), '.taketomarket');
   const campaignsDir = path.resolve(marketingDir, 'CAMPAIGNS');
   const checks = [];
 
-  // Check .marketing/ directory
+  // Check .taketomarket/ directory
   const marketingExists = dirExists(marketingDir);
   checks.push({
-    name: 'marketing_dir',
+    name: 'taketomarket_dir',
     status: marketingExists ? 'pass' : 'fail',
-    path: '.marketing/',
+    path: '.taketomarket/',
   });
 
   // Check CAMPAIGNS/ directory
@@ -330,7 +331,7 @@ function cmdHealth(raw, full) {
   checks.push({
     name: 'campaigns_dir',
     status: campaignsExists ? 'pass' : 'fail',
-    path: '.marketing/CAMPAIGNS/',
+    path: '.taketomarket/CAMPAIGNS/',
   });
 
   // Check each reference file
@@ -346,14 +347,14 @@ function cmdHealth(raw, full) {
         checks.push({
           name,
           status: isValid ? 'pass' : 'fail',
-          path: `.marketing/${file}`,
+          path: `.taketomarket/${file}`,
           detail: isValid ? undefined : 'frontmatter unparseable',
         });
       } else {
-        checks.push({ name, status: 'pass', path: `.marketing/${file}` });
+        checks.push({ name, status: 'pass', path: `.taketomarket/${file}` });
       }
     } else {
-      checks.push({ name, status: 'missing', path: `.marketing/${file}` });
+      checks.push({ name, status: 'missing', path: `.taketomarket/${file}` });
     }
   }
 
@@ -402,12 +403,12 @@ function cmdHealth(raw, full) {
 
 /**
  * Lightweight init check.
- * Returns: { initialized, marketing_dir, reference_files_count, total_expected }
+ * Returns: { initialized, taketomarket_dir, reference_files_count, total_expected }
  *
  * @param {boolean} raw - Whether to output raw summary string
  */
 function cmdInit(raw) {
-  const marketingDir = path.resolve(process.cwd(), '.marketing');
+  const marketingDir = path.resolve(process.cwd(), '.taketomarket');
   const marketingExists = dirExists(marketingDir);
 
   let refCount = 0;
@@ -424,7 +425,7 @@ function cmdInit(raw) {
 
   const result = {
     initialized,
-    marketing_dir: marketingExists,
+    taketomarket_dir: marketingExists,
     reference_files_count: refCount,
     total_expected: totalExpected,
   };

package/bin/lib/install-detect.cjs

@@ -0,0 +1,62 @@
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const SENTINEL_FILENAME = '.install-method';
+
+function readSentinel(homeDir = os.homedir()) {
+  const sentinelPath = path.join(homeDir, '.taketomarket', SENTINEL_FILENAME);
+  if (!fs.existsSync(sentinelPath)) return null;
+  try {
+    const raw = fs.readFileSync(sentinelPath, 'utf8').trim();
+    if (!raw) return null;
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed.method === 'string') return parsed;
+  } catch (_) {
+    // Fall through to heuristic.
+  }
+  return null;
+}
+
+function isTakeToMarketRoot(dir) {
+  try {
+    const pkgPath = path.join(dir, 'package.json');
+    if (!fs.existsSync(pkgPath)) return false;
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    return pkg && pkg.name === 'taketomarket';
+  } catch (_) {
+    return false;
+  }
+}
+
+function findPluginRoot() {
+  if (process.env.CLAUDE_PLUGIN_ROOT && isTakeToMarketRoot(process.env.CLAUDE_PLUGIN_ROOT)) {
+    return process.env.CLAUDE_PLUGIN_ROOT;
+  }
+  const candidate = path.join(
+    process.env.HOME || os.homedir(),
+    '.claude',
+    'plugins',
+    'cache',
+    'claude-plugins-official',
+    'taketomarket',
+  );
+  if (isTakeToMarketRoot(candidate)) return candidate;
+  return null;
+}
+
+function detectInstallMethod() {
+  const sentinel = readSentinel();
+  if (sentinel) {
+    return { method: sentinel.method, root: sentinel.source || null, source: 'sentinel' };
+  }
+  const root = findPluginRoot();
+  if (!root) return { method: 'unknown', root: null, source: 'heuristic' };
+  if (fs.existsSync(path.join(root, '.git'))) {
+    return { method: 'clone', root, source: 'heuristic' };
+  }
+  return { method: 'npm', root, source: 'heuristic' };
+}
+
+module.exports = { detectInstallMethod, findPluginRoot, readSentinel, isTakeToMarketRoot, SENTINEL_FILENAME };

package/bin/lib/legacy-folder.cjs

@@ -0,0 +1,100 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const LEGACY = '.marketing';
+const CURRENT = '.taketomarket';
+
+function legacyFolderCheck(cwd) {
+  const legacyPath = path.join(cwd, LEGACY);
+  const currentPath = path.join(cwd, CURRENT);
+  const legacyExists = fs.existsSync(legacyPath);
+  const currentExists = fs.existsSync(currentPath);
+
+  if (legacyExists && currentExists) {
+    return { state: 'conflict', legacyPath, currentPath };
+  }
+  if (legacyExists) {
+    return { state: 'legacy', legacyPath, currentPath };
+  }
+  if (currentExists) {
+    return { state: 'current', currentPath };
+  }
+  return { state: 'none' };
+}
+
+function migrateLegacyFolder(cwd) {
+  const check = legacyFolderCheck(cwd);
+  if (check.state === 'conflict') {
+    return { ok: false, error: `Both .marketing/ and .taketomarket/ already exist in ${cwd}. Resolve manually.` };
+  }
+  if (check.state !== 'legacy') {
+    return { ok: false, error: `Nothing to migrate. State: ${check.state}.` };
+  }
+  try {
+    fs.renameSync(check.legacyPath, check.currentPath);
+  } catch (e) {
+    if (e.code === 'EXDEV') {
+      // Cross-device rename not allowed: copy-then-verify-then-delete.
+      try {
+        fs.cpSync(check.legacyPath, check.currentPath, { recursive: true });
+      } catch (copyErr) {
+        return { ok: false, error: `Cross-device migration copy failed: ${copyErr.message}` };
+      }
+      if (!fs.existsSync(check.currentPath)) {
+        return { ok: false, error: `Cross-device migration copy did not produce ${check.currentPath}; legacy folder preserved.` };
+      }
+      try {
+        fs.rmSync(check.legacyPath, { recursive: true, force: true });
+      } catch (rmErr) {
+        return { ok: false, error: `Copied to ${check.currentPath} but failed to remove legacy folder ${check.legacyPath}: ${rmErr.message}. Both directories now exist; remove the legacy one manually.` };
+      }
+    } else {
+      return { ok: false, error: `Migration failed (${e.code || 'unknown'}): ${e.message}` };
+    }
+  }
+  return { ok: true, from: check.legacyPath, to: check.currentPath };
+}
+
+/**
+ * Decide whether a state-reading command can safely proceed.
+ *
+ * Returns { ok: true } when state is `current` or `none` (a fresh project that
+ * the command itself may create state in). Returns { ok: false, message } when
+ * state is `legacy` (user has not migrated) or `conflict` (both folders
+ * present). Callers should print `message` to stderr and exit non-zero so the
+ * user gets actionable guidance instead of a generic "STATE.md not found".
+ */
+function requireMigratedState(cwd) {
+  const check = legacyFolderCheck(cwd);
+  if (check.state === 'legacy') {
+    return {
+      ok: false,
+      state: check.state,
+      message:
+        `Legacy '.marketing/' state directory detected. Run '/ttm-update' (preferred) or ` +
+        `'node ${path.basename(process.argv[1] || 'ttm-tools.cjs')} legacy-folder migrate' to ` +
+        `rename it to '.taketomarket/' before using this command.`,
+    };
+  }
+  if (check.state === 'conflict') {
+    return {
+      ok: false,
+      state: check.state,
+      message:
+        `Conflict: both '.marketing/' and '.taketomarket/' exist. Resolve manually: ` +
+        `diff -r .marketing .taketomarket, merge any unique files, remove the legacy ` +
+        `'.marketing/' once '.taketomarket/' is complete, then re-run.`,
+    };
+  }
+  return { ok: true, state: check.state };
+}
+
+module.exports = {
+  legacyFolderCheck,
+  migrateLegacyFolder,
+  requireMigratedState,
+  LEGACY,
+  CURRENT,
+};

package/bin/lib/playwright-check.cjs

@@ -0,0 +1,26 @@
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+function defaultSettingsPath() {
+  return path.join(os.homedir(), '.claude', 'settings.json');
+}
+
+function checkPlaywrightMcp(opts = {}) {
+  const settingsPath = opts.settingsPath || defaultSettingsPath();
+  let detected = false;
+  if (fs.existsSync(settingsPath)) {
+    try {
+      const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+      if (settings.mcpServers && settings.mcpServers.playwright) detected = true;
+    } catch {}
+  }
+  return {
+    detected,
+    settingsPath,
+    setupHint: detected ? 'Playwright MCP is configured.' : 'Run /ttm-playwright-setup to install.',
+  };
+}
+
+module.exports = { checkPlaywrightMcp };

package/bin/lib/site-location.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const { detectMonorepo } = require('./codebase-scan.cjs');
+
+function suggestSitePath(cwd) {
+  const monorepo = detectMonorepo(cwd);
+  if (!monorepo) {
+    return { monorepo: false, default: path.join(cwd, 'landing') };
+  }
+  if (fs.existsSync(path.join(cwd, 'apps'))) {
+    return { monorepo: true, default: path.join(cwd, 'apps', 'site') };
+  }
+  if (fs.existsSync(path.join(cwd, 'packages'))) {
+    return { monorepo: true, default: path.join(cwd, 'packages', 'site') };
+  }
+  return { monorepo: true, default: path.join(cwd, 'apps', 'site') };
+}
+
+module.exports = { suggestSitePath };

package/bin/lib/state.cjs

@@ -23,10 +23,10 @@ const {
 /**
  * Resolve and validate the STATE.md path.
  * Security: uses path.resolve() and rejects paths containing '..' after resolution.
- * @returns {string} Absolute path to .marketing/STATE.md
+ * @returns {string} Absolute path to .taketomarket/STATE.md
  */
 function resolveStatePath() {
-  const statePath = path.resolve(process.cwd(), '.marketing', 'STATE.md');
+  const statePath = path.resolve(process.cwd(), '.taketomarket', 'STATE.md');
   // Reject paths that escape the project directory
   const projectRoot = path.resolve(process.cwd());
   if (!statePath.startsWith(projectRoot)) {
@@ -36,7 +36,7 @@ function resolveStatePath() {
 }
 
 /**
- * Read .marketing/STATE.md, parse frontmatter, output as JSON.
+ * Read .taketomarket/STATE.md, parse frontmatter, output as JSON.
  * If STATE.md does not exist, outputs { exists: false, error: "..." }.
  *
  * @param {boolean} raw - Whether to output raw string

package/bin/lib/svg-render.cjs

@@ -0,0 +1,42 @@
+'use strict';
+
+const { execSync, execFileSync } = require('child_process');
+
+// `cmd` is always a hardcoded literal (rsvg-convert, inkscape, magick).
+// Not user input, so the shell expansion is safe.
+function commandExists(cmd) {
+  try {
+    execSync(`command -v ${cmd}`, { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function detectRenderer() {
+  if (commandExists('rsvg-convert')) return 'rsvg-convert';
+  if (commandExists('inkscape')) return 'inkscape';
+  if (commandExists('magick')) return 'magick';
+  return 'none';
+}
+
+function renderSvgToPng(svgPath, pngPath, renderer) {
+  const r = renderer || detectRenderer();
+  if (r === 'none') {
+    return { ok: false, error: 'No renderer available. Install rsvg-convert (brew install librsvg) or Inkscape.' };
+  }
+  try {
+    if (r === 'rsvg-convert') {
+      execFileSync('rsvg-convert', [svgPath, '-o', pngPath]);
+    } else if (r === 'inkscape') {
+      execFileSync('inkscape', [svgPath, '--export-type=png', `--export-filename=${pngPath}`]);
+    } else if (r === 'magick') {
+      execFileSync('magick', [svgPath, pngPath]);
+    }
+    return { ok: true, renderer: r };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+
+module.exports = { detectRenderer, renderSvgToPng };