climaybe 1.0.0

package/src/lib/prompts.js

@@ -0,0 +1,117 @@
+import prompts from 'prompts';
+import pc from 'picocolors';
+
+/**
+ * Extract the subdomain (storeKey) from a Shopify domain.
+ * "voldt-staging.myshopify.com" → "voldt-staging"
+ */
+export function extractAlias(domain) {
+  return domain.replace(/\.myshopify\.com$/i, '').trim();
+}
+
+/**
+ * Normalize a store domain input.
+ * Appends ".myshopify.com" if not present.
+ */
+export function normalizeDomain(input) {
+  const trimmed = input.trim().toLowerCase();
+  if (trimmed.endsWith('.myshopify.com')) return trimmed;
+  return `${trimmed}.myshopify.com`;
+}
+
+/**
+ * Prompt the user for a single store URL + alias pair.
+ * Returns { alias, domain } or null if cancelled.
+ */
+export async function promptStore(defaultDomain = '') {
+  const { domain } = await prompts({
+    type: 'text',
+    name: 'domain',
+    message: 'Store URL',
+    initial: defaultDomain,
+    validate: (v) =>
+      v.trim().length > 0 ? true : 'Store URL is required',
+  });
+
+  if (!domain) return null;
+
+  const normalized = normalizeDomain(domain);
+  const suggestedAlias = extractAlias(normalized);
+
+  const { alias } = await prompts({
+    type: 'text',
+    name: 'alias',
+    message: `Alias`,
+    initial: suggestedAlias,
+    validate: (v) => {
+      const val = v.trim();
+      if (!val) return 'Alias is required';
+      if (!/^[a-z0-9][a-z0-9-]*$/.test(val)) return 'Alias must be lowercase alphanumeric with hyphens';
+      return true;
+    },
+  });
+
+  if (!alias) return null;
+
+  return { alias: alias.trim(), domain: normalized };
+}
+
+/**
+ * Prompt the user for one or more stores in a loop.
+ * Returns an array of { alias, domain } objects.
+ */
+export async function promptStoreLoop() {
+  const stores = [];
+
+  console.log(pc.cyan('\n  Configure your Shopify store(s)\n'));
+
+  // First store is required
+  const first = await promptStore();
+  if (!first) {
+    console.log(pc.red('  Setup cancelled.'));
+    process.exit(1);
+  }
+  stores.push(first);
+
+  // Ask for more stores
+  while (true) {
+    const { another } = await prompts({
+      type: 'confirm',
+      name: 'another',
+      message: 'Add another store?',
+      initial: false,
+    });
+
+    if (!another) break;
+
+    const store = await promptStore();
+    if (!store) break;
+
+    if (stores.some((s) => s.alias === store.alias)) {
+      console.log(pc.yellow(`  Alias "${store.alias}" already exists, skipping.`));
+      continue;
+    }
+
+    stores.push(store);
+  }
+
+  return stores;
+}
+
+/**
+ * Prompt for a single new store (used by add-store command).
+ * Takes existing aliases to prevent duplicates.
+ */
+export async function promptNewStore(existingAliases = []) {
+  console.log(pc.cyan('\n  Add a new store\n'));
+
+  const store = await promptStore();
+  if (!store) return null;
+
+  if (existingAliases.includes(store.alias)) {
+    console.log(pc.red(`  Alias "${store.alias}" already exists.`));
+    return null;
+  }
+
+  return store;
+}

package/src/lib/store-sync.js

@@ -0,0 +1,142 @@
+import { existsSync, mkdirSync, readdirSync, copyFileSync, statSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import pc from 'picocolors';
+
+/**
+ * Directories that participate in the root <-> stores/ sync.
+ * These are the JSON-holding directories in a Shopify theme.
+ */
+const SYNC_DIRS = ['config', 'templates', 'sections'];
+
+/**
+ * Files explicitly excluded from sync — they travel via branch history.
+ */
+const EXCLUDED_FILES = [
+  'config/settings_schema.json',
+];
+
+/**
+ * Patterns to exclude from sync (directory-level).
+ */
+const EXCLUDED_DIRS = ['locales'];
+
+/**
+ * Check if a file path should be excluded from sync.
+ */
+function isExcluded(relativePath) {
+  // Check direct file exclusions
+  if (EXCLUDED_FILES.includes(relativePath)) return true;
+
+  // Check directory exclusions
+  for (const dir of EXCLUDED_DIRS) {
+    if (relativePath.startsWith(dir + '/')) return true;
+  }
+
+  return false;
+}
+
+/**
+ * Recursively collect all .json files in a directory.
+ * Returns paths relative to the base directory.
+ */
+function collectJsonFiles(dir, base = dir) {
+  const files = [];
+  if (!existsSync(dir)) return files;
+
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const full = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...collectJsonFiles(full, base));
+    } else if (entry.name.endsWith('.json')) {
+      files.push(relative(base, full));
+    }
+  }
+
+  return files;
+}
+
+/**
+ * Ensure a directory exists (recursive).
+ */
+function ensureDir(dir) {
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+
+/**
+ * Copy JSON files from stores/<alias>/ to the repo root.
+ * Used by: `climaybe switch`, `stores-to-root` workflow.
+ */
+export function storesToRoot(alias, cwd = process.cwd()) {
+  const storeDir = join(cwd, 'stores', alias);
+
+  if (!existsSync(storeDir)) {
+    console.log(pc.red(`  Store directory "stores/${alias}/" does not exist.`));
+    return false;
+  }
+
+  let copied = 0;
+
+  for (const syncDir of SYNC_DIRS) {
+    const sourceDir = join(storeDir, syncDir);
+    const jsonFiles = collectJsonFiles(sourceDir, storeDir);
+
+    for (const relPath of jsonFiles) {
+      if (isExcluded(relPath)) continue;
+
+      const src = join(storeDir, relPath);
+      const dest = join(cwd, relPath);
+
+      ensureDir(join(dest, '..'));
+      copyFileSync(src, dest);
+      copied++;
+    }
+  }
+
+  console.log(pc.green(`  Copied ${copied} file(s) from stores/${alias}/ → root`));
+  return true;
+}
+
+/**
+ * Copy JSON files from the repo root to stores/<alias>/.
+ * Used by: `climaybe sync`, `root-to-stores` workflow.
+ */
+export function rootToStores(alias, cwd = process.cwd()) {
+  const storeDir = join(cwd, 'stores', alias);
+
+  let copied = 0;
+
+  for (const syncDir of SYNC_DIRS) {
+    const sourceDir = join(cwd, syncDir);
+    const jsonFiles = collectJsonFiles(sourceDir, cwd);
+
+    for (const relPath of jsonFiles) {
+      if (isExcluded(relPath)) continue;
+
+      const src = join(cwd, relPath);
+      const dest = join(storeDir, relPath);
+
+      ensureDir(join(dest, '..'));
+      copyFileSync(src, dest);
+      copied++;
+    }
+  }
+
+  console.log(pc.green(`  Copied ${copied} file(s) from root → stores/${alias}/`));
+  return true;
+}
+
+/**
+ * Create the store directory structure for a new store.
+ */
+export function createStoreDirectories(alias, cwd = process.cwd()) {
+  const storeDir = join(cwd, 'stores', alias);
+
+  for (const dir of SYNC_DIRS) {
+    const target = join(storeDir, dir);
+    ensureDir(target);
+  }
+
+  console.log(pc.green(`  Created store directory: stores/${alias}/`));
+}

package/src/lib/workflows.js

@@ -0,0 +1,99 @@
+import { existsSync, mkdirSync, readdirSync, copyFileSync, rmSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import pc from 'picocolors';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const TEMPLATES_DIR = join(__dirname, '..', 'workflows');
+
+/**
+ * Get the path to the target repo's .github/workflows/ directory.
+ */
+function ghWorkflowsDir(cwd = process.cwd()) {
+  return join(cwd, '.github', 'workflows');
+}
+
+/**
+ * Collect all .yml files in a directory (non-recursive).
+ */
+function listYmls(dir) {
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir).filter((f) => f.endsWith('.yml'));
+}
+
+/**
+ * Copy a single workflow template to the target repo.
+ */
+function copyWorkflow(srcDir, fileName, destDir) {
+  const src = join(srcDir, fileName);
+  const dest = join(destDir, fileName);
+  copyFileSync(src, dest);
+}
+
+/**
+ * Remove all climaybe-managed workflow files.
+ * We prefix a comment header in each workflow so we can identify them,
+ * but for simplicity we track known filenames instead.
+ */
+function getKnownWorkflowFiles() {
+  const dirs = ['shared', 'single', 'multi'];
+  const files = new Set();
+  for (const dir of dirs) {
+    const dirPath = join(TEMPLATES_DIR, dir);
+    for (const f of listYmls(dirPath)) {
+      files.add(f);
+    }
+  }
+  return files;
+}
+
+/**
+ * Remove previously scaffolded climaybe workflows from target.
+ */
+function cleanWorkflows(cwd = process.cwd()) {
+  const dest = ghWorkflowsDir(cwd);
+  if (!existsSync(dest)) return;
+
+  const known = getKnownWorkflowFiles();
+  for (const file of readdirSync(dest)) {
+    if (known.has(file)) {
+      rmSync(join(dest, file));
+    }
+  }
+}
+
+/**
+ * Scaffold the correct set of GitHub Actions workflows based on mode.
+ * - Always copies shared/ workflows.
+ * - Copies single/ or multi/ (+ single/) based on mode.
+ */
+export function scaffoldWorkflows(mode = 'single', cwd = process.cwd()) {
+  const dest = ghWorkflowsDir(cwd);
+  mkdirSync(dest, { recursive: true });
+
+  // Clean previously scaffolded files
+  cleanWorkflows(cwd);
+
+  // Always copy shared workflows
+  const sharedDir = join(TEMPLATES_DIR, 'shared');
+  for (const f of listYmls(sharedDir)) {
+    copyWorkflow(sharedDir, f, dest);
+  }
+
+  // Single-store workflows (used in both modes)
+  const singleDir = join(TEMPLATES_DIR, 'single');
+  for (const f of listYmls(singleDir)) {
+    copyWorkflow(singleDir, f, dest);
+  }
+
+  if (mode === 'multi') {
+    const multiDir = join(TEMPLATES_DIR, 'multi');
+    for (const f of listYmls(multiDir)) {
+      copyWorkflow(multiDir, f, dest);
+    }
+  }
+
+  const total = readdirSync(dest).filter((f) => f.endsWith('.yml')).length;
+  console.log(pc.green(`  Scaffolded ${total} workflow(s) → .github/workflows/`));
+  console.log(pc.dim(`  Mode: ${mode}-store`));
+}

package/src/workflows/multi/hotfix-backport.yml

@@ -0,0 +1,100 @@
+# climaybe — Hotfix Backport (Multi-store)
+# After root-to-stores completes on a live-* branch,
+# creates a PR to main with [hotfix-backport] flag.
+# This ensures hotfixes on live stores are propagated back to the dev branch.
+# Triggers a patch version bump on main.
+
+name: Hotfix Backport
+
+on:
+  workflow_run:
+    workflows: ["Root to Stores"]
+    types: [completed]
+    branches:
+      - 'live-*'
+
+jobs:
+  backport:
+    if: github.event.workflow_run.conclusion == 'success'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+    env:
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.workflow_run.head_branch }}
+          fetch-depth: 0
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Extract store alias
+        id: alias
+        run: |
+          BRANCH="${{ github.event.workflow_run.head_branch }}"
+          ALIAS="${BRANCH#live-}"
+          echo "alias=$ALIAS" >> $GITHUB_OUTPUT
+          echo "live_branch=$BRANCH" >> $GITHUB_OUTPUT
+
+      - name: Check if backport is needed
+        id: check
+        run: |
+          LIVE="${{ steps.alias.outputs.live_branch }}"
+
+          # Get the last common ancestor with main
+          MERGE_BASE=$(git merge-base origin/main origin/$LIVE 2>/dev/null || echo "")
+
+          if [ -z "$MERGE_BASE" ]; then
+            echo "needs_backport=false" >> $GITHUB_OUTPUT
+            exit 0
+          fi
+
+          # Check for commits on live that aren't on main
+          COMMITS=$(git log --oneline ${MERGE_BASE}..origin/$LIVE -- . ':!stores/' 2>/dev/null | grep -v "\[stores-to-root\]" | grep -v "\[root-to-stores\]" | grep -v "chore(release)" || true)
+
+          if [ -n "$COMMITS" ]; then
+            echo "needs_backport=true" >> $GITHUB_OUTPUT
+            echo "Commits to backport:"
+            echo "$COMMITS"
+          else
+            echo "needs_backport=false" >> $GITHUB_OUTPUT
+            echo "No new commits to backport."
+          fi
+
+      - name: Create backport PR
+        if: steps.check.outputs.needs_backport == 'true'
+        run: |
+          LIVE="${{ steps.alias.outputs.live_branch }}"
+          ALIAS="${{ steps.alias.outputs.alias }}"
+
+          # Check for existing open backport PR
+          EXISTING_PR=$(gh pr list --base main --head "$LIVE" --state open --json number --jq '.[0].number' 2>/dev/null || echo "")
+
+          if [ -n "$EXISTING_PR" ]; then
+            echo "Backport PR #$EXISTING_PR already exists"
+            exit 0
+          fi
+
+          PR_URL=$(gh pr create \
+            --base main \
+            --head "$LIVE" \
+            --title "[hotfix-backport] ${ALIAS}: hotfix from live" \
+            --body "Backporting hotfix changes from **${LIVE}** to main.
+
+          This PR was automatically created because direct commits were detected on the live branch.
+
+          **Important:** Merging this will trigger a patch version bump on main.
+
+          *Generated by climaybe*" 2>/dev/null || echo "")
+
+          if [ -n "$PR_URL" ]; then
+            echo "Created backport PR: $PR_URL"
+          else
+            echo "PR creation failed or no diff between branches."
+          fi
+
+  # Patch version bump after backport merge
+  # This is handled by the nightly-hotfix workflow or can be triggered manually.
+  # The [hotfix-backport] flag in the commit message ensures main-to-staging-stores
+  # does NOT push this back to stores.

package/src/workflows/multi/main-to-staging-stores.yml

@@ -0,0 +1,118 @@
+# climaybe — Main to Staging Stores (Multi-store)
+# When a PR is merged into main (from staging), this workflow
+# opens and auto-merges PRs from main to each staging-<alias> branch.
+# Skips hotfix backport commits to prevent recursive triggers.
+
+name: Main to Staging Stores
+
+on:
+  push:
+    branches: [main]
+
+# Prevent concurrent store pushes
+concurrency:
+  group: main-to-staging-stores
+  cancel-in-progress: false
+
+jobs:
+  # Gate: skip hotfix backports and version bump commits
+  gate:
+    runs-on: ubuntu-latest
+    outputs:
+      should_run: ${{ steps.check.outputs.should_run }}
+    steps:
+      - name: Check commit message
+        id: check
+        run: |
+          COMMIT_MSG="${{ github.event.head_commit.message }}"
+
+          if echo "$COMMIT_MSG" | grep -q "\[hotfix-backport\]"; then
+            echo "Skipping — hotfix backport commit"
+            echo "should_run=false" >> $GITHUB_OUTPUT
+          elif echo "$COMMIT_MSG" | grep -q "chore(release): bump version"; then
+            echo "Skipping — version bump commit"
+            echo "should_run=false" >> $GITHUB_OUTPUT
+          elif echo "$COMMIT_MSG" | grep -q "\[skip-store-sync\]"; then
+            echo "Skipping — store sync commit"
+            echo "should_run=false" >> $GITHUB_OUTPUT
+          else
+            echo "should_run=true" >> $GITHUB_OUTPUT
+          fi
+
+  # Read store list from package.json
+  config:
+    needs: gate
+    if: needs.gate.outputs.should_run == 'true'
+    runs-on: ubuntu-latest
+    outputs:
+      stores: ${{ steps.read.outputs.stores }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Read store aliases
+        id: read
+        run: |
+          STORES=$(node -e "
+            const pkg = require('./package.json');
+            const stores = Object.keys(pkg.config?.stores || {});
+            console.log(JSON.stringify(stores));
+          ")
+          echo "stores=$STORES" >> $GITHUB_OUTPUT
+          echo "Store aliases: $STORES"
+
+  # Create PRs to each staging-<alias> branch
+  sync:
+    needs: [gate, config]
+    if: needs.gate.outputs.should_run == 'true'
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        store: ${{ fromJson(needs.config.outputs.stores) }}
+      fail-fast: false
+    permissions:
+      contents: write
+      pull-requests: write
+    env:
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Sync main to staging-${{ matrix.store }}
+        run: |
+          BRANCH="staging-${{ matrix.store }}"
+
+          # Check if branch exists
+          if ! git ls-remote --heads origin "$BRANCH" | grep -q "$BRANCH"; then
+            echo "Branch $BRANCH does not exist on remote, skipping."
+            exit 0
+          fi
+
+          # Check for existing open PR
+          EXISTING_PR=$(gh pr list --base "$BRANCH" --head main --state open --json number --jq '.[0].number' 2>/dev/null || echo "")
+
+          if [ -n "$EXISTING_PR" ]; then
+            echo "PR #$EXISTING_PR already exists for main → $BRANCH"
+            # Update the existing PR by force
+            gh pr close "$EXISTING_PR" --delete-branch=false 2>/dev/null || true
+          fi
+
+          # Create PR
+          PR_URL=$(gh pr create \
+            --base "$BRANCH" \
+            --head main \
+            --title "Sync main → $BRANCH" \
+            --body "Automated sync from main to $BRANCH after staging merge.
+
+          *Generated by climaybe*" 2>/dev/null || echo "")
+
+          if [ -n "$PR_URL" ]; then
+            echo "Created PR: $PR_URL"
+
+            # Auto-merge
+            PR_NUM=$(echo "$PR_URL" | grep -oP '\d+$')
+            gh pr merge "$PR_NUM" --merge --admin 2>/dev/null || echo "Auto-merge failed — manual review may be needed."
+          else
+            echo "No changes to sync for $BRANCH"
+          fi

package/src/workflows/multi/pr-to-live.yml

@@ -0,0 +1,71 @@
+# climaybe — PR to Live (Multi-store)
+# After stores-to-root completes on a staging-* branch,
+# opens a PR from staging-<alias> to live-<alias>.
+
+name: PR to Live
+
+on:
+  workflow_run:
+    workflows: ["Stores to Root"]
+    types: [completed]
+    branches:
+      - 'staging-*'
+
+jobs:
+  create-pr:
+    # Only run if the triggering workflow succeeded
+    if: github.event.workflow_run.conclusion == 'success'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: write
+    env:
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Extract store alias
+        id: alias
+        run: |
+          BRANCH="${{ github.event.workflow_run.head_branch }}"
+          ALIAS="${BRANCH#staging-}"
+          echo "alias=$ALIAS" >> $GITHUB_OUTPUT
+          echo "staging_branch=$BRANCH" >> $GITHUB_OUTPUT
+          echo "live_branch=live-${ALIAS}" >> $GITHUB_OUTPUT
+
+      - name: Create PR to live branch
+        run: |
+          STAGING="${{ steps.alias.outputs.staging_branch }}"
+          LIVE="${{ steps.alias.outputs.live_branch }}"
+          ALIAS="${{ steps.alias.outputs.alias }}"
+
+          # Check if live branch exists
+          if ! git ls-remote --heads origin "$LIVE" | grep -q "$LIVE"; then
+            echo "Live branch $LIVE does not exist, skipping."
+            exit 0
+          fi
+
+          # Check for existing open PR
+          EXISTING_PR=$(gh pr list --base "$LIVE" --head "$STAGING" --state open --json number --jq '.[0].number' 2>/dev/null || echo "")
+
+          if [ -n "$EXISTING_PR" ]; then
+            echo "PR #$EXISTING_PR already open for $STAGING → $LIVE"
+            exit 0
+          fi
+
+          # Create PR
+          PR_URL=$(gh pr create \
+            --base "$LIVE" \
+            --head "$STAGING" \
+            --title "Deploy to ${ALIAS}" \
+            --body "Deployment PR for **${ALIAS}** store.
+
+          Review the changes and merge to deploy.
+
+          *Generated by climaybe*" 2>/dev/null || echo "")
+
+          if [ -n "$PR_URL" ]; then
+            echo "Created PR: $PR_URL"
+          else
+            echo "No changes to deploy for $ALIAS or PR creation failed."
+          fi