shimwrappercheck 0.2.0

package/scripts/fetch-edge-logs.sh

@@ -0,0 +1,96 @@
+#!/usr/bin/env bash
+# Fetch recent Edge Function logs after deploy (optional).
+# Runs: supabase functions logs <function> --limit <n>
+set -euo pipefail
+
+resolve_project_root() {
+  if [[ -n "${SHIM_PROJECT_ROOT:-}" ]]; then
+    echo "$SHIM_PROJECT_ROOT"
+    return
+  fi
+  if command -v git >/dev/null 2>&1; then
+    local root
+    root="$(git rev-parse --show-toplevel 2>/dev/null || true)"
+    if [[ -n "$root" ]]; then
+      echo "$root"
+      return
+    fi
+  fi
+  pwd
+}
+
+PROJECT_ROOT="$(resolve_project_root)"
+cd "$PROJECT_ROOT"
+
+ARGS=("$@")
+ARGS_TEXT=" ${*:-} "
+
+# Only fetch logs when we just deployed functions
+if [[ "$ARGS_TEXT" != *" functions "* ]]; then
+  exit 0
+fi
+
+function_names=()
+if [[ "$ARGS_TEXT" == *" deploy "* ]]; then
+  for i in "${!ARGS[@]}"; do
+    if [[ "${ARGS[$i]}" == "deploy" ]]; then
+      next_index=$((i + 1))
+      if [[ $next_index -lt ${#ARGS[@]} ]]; then
+        candidate="${ARGS[$next_index]}"
+        if [[ -n "$candidate" ]] && [[ "$candidate" != -* ]]; then
+          function_names+=("$candidate")
+        fi
+      fi
+      break
+    fi
+  done
+fi
+
+if [[ -n "${SHIM_LOG_FUNCTIONS:-}" ]]; then
+  IFS=',' read -r -a extra_names <<< "${SHIM_LOG_FUNCTIONS}"
+  for name in "${extra_names[@]}"; do
+    name="$(echo "$name" | xargs)"
+    [[ -n "$name" ]] && function_names+=("$name")
+  done
+fi
+
+if [[ "${#function_names[@]}" -eq 0 ]]; then
+  if [[ -z "${SHIM_DEFAULT_FUNCTION+x}" ]]; then
+    default_fn="server"
+  else
+    default_fn="${SHIM_DEFAULT_FUNCTION}"
+  fi
+  if [[ -n "$default_fn" ]]; then
+    function_names+=("$default_fn")
+  else
+    echo "Edge logs: skipped (no function name detected; set SHIM_LOG_FUNCTIONS)"
+    exit 0
+  fi
+fi
+
+REAL_BIN="${SHIM_SUPABASE_BIN:-${SUPABASE_REAL_BIN:-}}"
+if [[ -z "$REAL_BIN" ]] && [[ -f "$HOME/.supabase-real-bin" ]]; then
+  REAL_BIN="$(cat "$HOME/.supabase-real-bin")"
+fi
+if [[ -z "$REAL_BIN" ]]; then
+  REAL_BIN="$(command -v supabase || true)"
+fi
+if [[ -n "$REAL_BIN" ]] && { [[ "$REAL_BIN" == *"node_modules"* ]] || [[ "$REAL_BIN" == "$PROJECT_ROOT"* ]]; }; then
+  REAL_BIN=""
+fi
+
+log_limit="${SHIM_LOG_LIMIT:-30}"
+if ! [[ "$log_limit" =~ ^[0-9]+$ ]]; then
+  log_limit=30
+fi
+
+for fn in "${function_names[@]}"; do
+  echo "Edge logs ($fn):"
+  if [[ -n "$REAL_BIN" ]] && [[ -x "$REAL_BIN" ]]; then
+    "$REAL_BIN" functions logs "$fn" --limit "$log_limit" 2>/dev/null || true
+  else
+    npx --yes --package supabase supabase functions logs "$fn" --limit "$log_limit" 2>/dev/null || true
+  fi
+done
+
+exit 0

package/scripts/git-checked.sh

@@ -0,0 +1,194 @@
+#!/usr/bin/env bash
+# Shim wrapper for Git: run checks (optional), then call real git.
+set -euo pipefail
+
+WRAPPER_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+
+resolve_project_root() {
+  if [[ -n "${SHIM_PROJECT_ROOT:-}" ]]; then
+    echo "$SHIM_PROJECT_ROOT"
+    return
+  fi
+  if command -v git >/dev/null 2>&1; then
+    local root
+    root="$(git rev-parse --show-toplevel 2>/dev/null || true)"
+    if [[ -n "$root" ]]; then
+      echo "$root"
+      return
+    fi
+  fi
+  pwd
+}
+
+PROJECT_ROOT="$(resolve_project_root)"
+cd "$PROJECT_ROOT"
+
+CONFIG_FILE="${SHIM_CONFIG_FILE:-$PROJECT_ROOT/.shimwrappercheckrc}"
+if [[ -f "$CONFIG_FILE" ]]; then
+  # shellcheck disable=SC1090
+  source "$CONFIG_FILE"
+fi
+
+ARGS_IN=("$@")
+ARGS_TEXT_RAW=" ${*:-} "
+GIT_ARGS=()
+CHECKS_PASSTHROUGH=()
+
+RUN_CHECKS=true
+CHECKS_ONLY=false
+
+matches_command_list() {
+  local list="$1"
+  local text="$2"
+
+  list="$(echo "$list" | tr '[:upper:]' '[:lower:]')"
+  text="$(echo "$text" | tr '[:upper:]' '[:lower:]')"
+
+  if [[ -z "$list" ]] || [[ "$list" == "all" ]]; then
+    return 0
+  fi
+  if [[ "$list" == "none" ]]; then
+    return 1
+  fi
+
+  IFS=',' read -r -a items <<< "$list"
+  for item in "${items[@]}"; do
+    item="$(echo "$item" | xargs)"
+    [[ -z "$item" ]] && continue
+    if [[ "$text" == *" $item "* ]]; then
+      return 0
+    fi
+  done
+  return 1
+}
+
+for arg in "${ARGS_IN[@]}"; do
+  case "$arg" in
+    --no-checks) RUN_CHECKS=false ;;
+    --checks-only) CHECKS_ONLY=true ;;
+    --no-ai-review|--ai-review) CHECKS_PASSTHROUGH+=("$arg") ;;
+    *) GIT_ARGS+=("$arg") ;;
+  esac
+done
+
+[[ -n "${SHIM_DISABLE_CHECKS:-}" ]] && RUN_CHECKS=false
+
+if [[ "${#GIT_ARGS[@]}" -eq 0 ]] && [[ "$CHECKS_ONLY" != true ]]; then
+  echo "No git command provided. Usage: git [shim flags] <git args>" >&2
+  echo "Shim flags: --no-checks --checks-only --no-ai-review" >&2
+  exit 1
+fi
+
+ARGS_TEXT=" ${GIT_ARGS[*]:-} "
+if [[ "$CHECKS_ONLY" != true ]]; then
+  enforce_list="${SHIM_GIT_ENFORCE_COMMANDS:-push}"
+  if ! matches_command_list "$enforce_list" "$ARGS_TEXT"; then
+    RUN_CHECKS=false
+  fi
+fi
+
+resolve_checks_script() {
+  local script="${SHIM_GIT_CHECKS_SCRIPT:-}"
+  if [[ -n "$script" ]]; then
+    if [[ "$script" != /* ]]; then
+      script="$PROJECT_ROOT/$script"
+    fi
+    echo "$script"
+    return
+  fi
+  script="${SHIM_CHECKS_SCRIPT:-}"
+  if [[ -n "$script" ]]; then
+    if [[ "$script" != /* ]]; then
+      script="$PROJECT_ROOT/$script"
+    fi
+    echo "$script"
+    return
+  fi
+  local candidates=("scripts/run-checks.sh" "scripts/shim-checks.sh")
+  for candidate in "${candidates[@]}"; do
+    if [[ -f "$PROJECT_ROOT/$candidate" ]]; then
+      echo "$PROJECT_ROOT/$candidate"
+      return
+    fi
+  done
+  echo ""
+}
+
+if [[ "$RUN_CHECKS" = true ]]; then
+  run_frontend=false
+  run_backend=false
+  run_ai_review=true
+
+  changed_files=""
+  if command -v git >/dev/null 2>&1; then
+    if git rev-parse --abbrev-ref --symbolic-full-name @{u} >/dev/null 2>&1; then
+      RANGE="@{u}...HEAD"
+      changed_files="$(git diff --name-only --diff-filter=ACMR "$RANGE" || true)"
+    else
+      if git rev-parse --verify HEAD~1 >/dev/null 2>&1; then
+        changed_files="$(git diff --name-only --diff-filter=ACMR HEAD~1...HEAD || true)"
+      else
+        changed_files="$(git diff --name-only --diff-filter=ACMR --root HEAD || true)"
+      fi
+    fi
+  fi
+
+  if [[ -n "$changed_files" ]]; then
+    echo "$changed_files" | grep -q '^src/' && run_frontend=true
+    echo "$changed_files" | grep -q '^supabase/functions/' && run_backend=true
+  fi
+
+  if [[ "$ARGS_TEXT_RAW" == *" --no-ai-review "* ]]; then
+    run_ai_review=false
+  fi
+  if [[ -n "${SKIP_AI_REVIEW:-}" ]]; then
+    run_ai_review=false
+  fi
+
+  if [[ "$run_frontend" = true ]] || [[ "$run_backend" = true ]]; then
+    CHECKS_SCRIPT="$(resolve_checks_script)"
+    if [[ -n "$CHECKS_SCRIPT" ]]; then
+      CHECKS_ARGS=()
+      if [[ -n "${SHIM_GIT_CHECKS_ARGS:-}" ]]; then
+        read -r -a CHECKS_ARGS <<< "${SHIM_GIT_CHECKS_ARGS}"
+      elif [[ -n "${SHIM_CHECKS_ARGS:-}" ]]; then
+        read -r -a CHECKS_ARGS <<< "${SHIM_CHECKS_ARGS}"
+      fi
+      [[ "$run_frontend" = true ]] && CHECKS_ARGS+=(--frontend)
+      [[ "$run_backend" = true ]] && CHECKS_ARGS+=(--backend)
+      [[ "$run_ai_review" = false ]] && CHECKS_ARGS+=(--no-ai-review)
+      CHECKS_ARGS+=("${CHECKS_PASSTHROUGH[@]}")
+      bash "$CHECKS_SCRIPT" "${CHECKS_ARGS[@]}"
+    else
+      echo "Git shim checks: no checks script found; skipping." >&2
+    fi
+  fi
+fi
+
+if [[ "$CHECKS_ONLY" = true ]]; then
+  exit 0
+fi
+
+REAL_BIN="${SHIM_GIT_REAL_BIN:-${GIT_REAL_BIN:-}}"
+if [[ -z "$REAL_BIN" ]]; then
+  REAL_BIN="$(command -v git || true)"
+fi
+if [[ -n "$REAL_BIN" ]] && { [[ "$REAL_BIN" == *"node_modules"* ]] || [[ "$REAL_BIN" == "$WRAPPER_DIR"* ]]; }; then
+  REAL_BIN=""
+fi
+
+if [[ -z "$REAL_BIN" ]]; then
+  for candidate in /usr/bin/git /usr/local/bin/git /opt/homebrew/bin/git; do
+    if [[ -x "$candidate" ]]; then
+      REAL_BIN="$candidate"
+      break
+    fi
+  done
+fi
+
+if [[ -z "$REAL_BIN" ]]; then
+  echo "Real git binary not found. Set SHIM_GIT_REAL_BIN." >&2
+  exit 1
+fi
+
+exec "$REAL_BIN" "${GIT_ARGS[@]}"

package/scripts/init.js

@@ -0,0 +1,341 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const cp = require('child_process');
+const readline = require('readline');
+
+const projectRoot = process.cwd();
+const pkgRoot = path.join(__dirname, '..');
+const templatesDir = path.join(pkgRoot, 'templates');
+const pkgJson = require('../package.json');
+
+function exists(p) {
+  try {
+    return fs.existsSync(p);
+  } catch {
+    return false;
+  }
+}
+
+function readJson(filePath) {
+  try {
+    const raw = fs.readFileSync(filePath, 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+function hasCommand(cmd) {
+  try {
+    cp.execSync(`command -v ${cmd}`, { stdio: 'ignore', shell: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function isGitRepo() {
+  try {
+    cp.execSync('git rev-parse --is-inside-work-tree', { stdio: 'ignore', shell: true });
+    return true;
+  } catch {
+    return exists(path.join(projectRoot, '.git'));
+  }
+}
+
+function ensureDir(dirPath) {
+  if (!exists(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+
+function copyTemplate(templateName, destPath, makeExecutable) {
+  const src = path.join(templatesDir, templateName);
+  ensureDir(path.dirname(destPath));
+  fs.copyFileSync(src, destPath);
+  if (makeExecutable) {
+    try {
+      fs.chmodSync(destPath, 0o755);
+    } catch {
+      // ignore chmod errors
+    }
+  }
+}
+
+function formatBool(val) {
+  return val ? 'ja' : 'nein';
+}
+
+async function main() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  const ask = (question) => new Promise((resolve) => rl.question(question, resolve));
+
+  const askYesNo = async (question, defaultYes) => {
+    const hint = defaultYes ? 'J/n' : 'j/N';
+    const answer = (await ask(`${question} [${hint}] `)).trim().toLowerCase();
+    if (!answer) return defaultYes;
+    return ['j', 'ja', 'y', 'yes'].includes(answer);
+  };
+
+  const askInput = async (question, def) => {
+    const answer = (await ask(`${question} [${def}] `)).trim();
+    return answer || def;
+  };
+
+  const packagePath = path.join(projectRoot, 'package.json');
+  const projectPackage = readJson(packagePath);
+
+  const hasSupabase = exists(path.join(projectRoot, 'supabase')) ||
+    exists(path.join(projectRoot, 'supabase', 'config.toml')) ||
+    exists(path.join(projectRoot, 'supabase', 'functions'));
+  const hasSupabaseFunctions = exists(path.join(projectRoot, 'supabase', 'functions'));
+  const hasSrc = exists(path.join(projectRoot, 'src'));
+  const hasGit = isGitRepo();
+  const hasPackageJson = !!projectPackage;
+  const hasHusky = exists(path.join(projectRoot, '.husky')) ||
+    (projectPackage && projectPackage.devDependencies && projectPackage.devDependencies.husky);
+
+  console.log('shimwrappercheck init');
+  console.log('Projekt:', projectRoot);
+  console.log('Gefundene Signale:');
+  let repoType = 'unbekannt';
+  if (hasSupabase && hasSrc) {
+    repoType = 'mixed (frontend + backend)';
+  } else if (hasSupabase) {
+    repoType = hasSupabaseFunctions ? 'backend (supabase functions)' : 'backend (supabase)';
+  } else if (hasSrc) {
+    repoType = 'frontend';
+  }
+
+  console.log(`- Supabase: ${formatBool(hasSupabase)}${hasSupabaseFunctions ? ' (functions)' : ''}`);
+  console.log(`- Frontend (src/): ${formatBool(hasSrc)}`);
+  console.log(`- Git Repo: ${formatBool(hasGit)}`);
+  console.log(`- package.json: ${formatBool(hasPackageJson)}`);
+  console.log(`- Husky: ${formatBool(hasHusky)}`);
+  console.log(`- Repo-Typ: ${repoType}`);
+  console.log('');
+
+  const enableSupabase = await askYesNo(
+    'Supabase-Shim aktivieren (Checks vor supabase CLI)?',
+    hasSupabase
+  );
+
+  const enableGitWrapper = await askYesNo(
+    'Git-Wrapper aktivieren (Checks vor git push)?',
+    hasGit
+  );
+
+  let enforceCommands = 'all';
+  let hookCommands = 'functions,db,migration';
+  let defaultFunction = hasSupabaseFunctions ? 'server' : '';
+  let autoPush = hasGit;
+  let gitEnforceCommands = 'push';
+  let disableAiByDefault = false;
+
+  if (enableSupabase) {
+    let defaultEnforce = 'all';
+    if (hasSupabaseFunctions) {
+      defaultEnforce = 'functions,db,migration';
+    } else if (hasSupabase) {
+      defaultEnforce = 'db,migration';
+    }
+    enforceCommands = (await askInput(
+      'Welche Supabase-Befehle sollen Checks erzwingen? (all | none | functions,db,migration)',
+      defaultEnforce
+    )).toLowerCase().replace(/\s+/g, '');
+
+    const defaultHooks = hasSupabaseFunctions ? 'functions,db,migration' : 'none';
+    hookCommands = (await askInput(
+      'Welche Befehle sollen Post-Deploy Hooks triggern? (functions,db,migration | all | none)',
+      defaultHooks
+    )).toLowerCase().replace(/\s+/g, '');
+
+    if (hasSupabaseFunctions) {
+      defaultFunction = await askInput('Default Function fuer Health/Logs', defaultFunction || 'server');
+    } else {
+      defaultFunction = '';
+    }
+    autoPush = await askYesNo('Nach erfolgreichem CLI-Lauf automatisch git push?', hasGit);
+  }
+
+  if (enableGitWrapper) {
+    gitEnforceCommands = (await askInput(
+      'Welche Git-Befehle sollen Checks erzwingen? (push,commit,merge,rebase,all,none)',
+      'push'
+    )).toLowerCase().replace(/\\s+/g, '');
+  }
+
+  const enableAiReview = await askYesNo(
+    'AI Review aktivieren (Codex default, Cursor fallback)?',
+    true
+  );
+  if (!enableAiReview) {
+    disableAiByDefault = await askYesNo('Standardmaessig --no-ai-review setzen?', true);
+  }
+
+  if (enableAiReview) {
+    const hasCodex = hasCommand('codex');
+    const hasAgent = hasCommand('agent');
+
+    if (hasCodex) {
+      const doLogin = await askYesNo('Jetzt in ChatGPT via codex login einloggen?', false);
+      if (doLogin) {
+        try {
+          cp.spawnSync('codex', ['login'], { stdio: 'inherit' });
+        } catch {
+          console.log('codex login fehlgeschlagen. Bitte manuell ausfuehren.');
+        }
+      }
+    } else if (hasAgent) {
+      const doLogin = await askYesNo('Codex nicht gefunden. Cursor agent login starten?', false);
+      if (doLogin) {
+        try {
+          cp.spawnSync('agent', ['login'], { stdio: 'inherit' });
+        } catch {
+          console.log('agent login fehlgeschlagen. Bitte manuell ausfuehren.');
+        }
+      }
+    } else {
+      console.log('Hinweis: Weder codex noch agent gefunden. Installiere/konfiguriere die CLI fuer AI Review.');
+    }
+  }
+
+  const runChecksPath = path.join(projectRoot, 'scripts', 'run-checks.sh');
+  if (!exists(runChecksPath)) {
+    const createChecks = await askYesNo('scripts/run-checks.sh aus Template anlegen?', true);
+    if (createChecks) {
+      copyTemplate('run-checks.sh', runChecksPath, true);
+    }
+  }
+
+  const aiReviewPath = path.join(projectRoot, 'scripts', 'ai-code-review.sh');
+  if (enableAiReview && !exists(aiReviewPath)) {
+    const createAiReview = await askYesNo('scripts/ai-code-review.sh aus Template anlegen?', true);
+    if (createAiReview) {
+      copyTemplate('ai-code-review.sh', aiReviewPath, true);
+    }
+  }
+
+  if (hasGit) {
+    let hookInstalled = false;
+    if (hasHusky) {
+      const useHusky = await askYesNo('Husky pre-push Hook installieren?', true);
+      if (useHusky) {
+        const huskyPath = path.join(projectRoot, '.husky', 'pre-push');
+        if (exists(huskyPath)) {
+          const overwrite = await askYesNo('Husky pre-push existiert. Ueberschreiben?', false);
+          if (!overwrite) {
+            hookInstalled = true;
+          } else {
+            copyTemplate('husky-pre-push', huskyPath, true);
+            hookInstalled = true;
+          }
+        } else {
+          copyTemplate('husky-pre-push', huskyPath, true);
+          hookInstalled = true;
+        }
+      }
+    }
+
+    if (!hookInstalled) {
+      const useGitHook = await askYesNo('Plain git pre-push Hook installieren?', true);
+      if (useGitHook) {
+        const hookPath = path.join(projectRoot, '.git', 'hooks', 'pre-push');
+        if (exists(hookPath)) {
+          const overwrite = await askYesNo('git pre-push Hook existiert. Ueberschreiben?', false);
+          if (!overwrite) {
+            // skip
+          } else {
+            copyTemplate('git-pre-push', hookPath, true);
+          }
+        } else {
+          copyTemplate('git-pre-push', hookPath, true);
+        }
+      }
+    }
+  }
+
+  if (hasPackageJson) {
+    const addScript = await askYesNo('package.json: Script "supabase:checked" eintragen?', true);
+    if (addScript) {
+      projectPackage.scripts = projectPackage.scripts || {};
+      if (!projectPackage.scripts['supabase:checked']) {
+        projectPackage.scripts['supabase:checked'] = 'supabase';
+      }
+      fs.writeFileSync(packagePath, JSON.stringify(projectPackage, null, 2) + '\n');
+    }
+
+    if (enableGitWrapper) {
+      const addGitScript = await askYesNo('package.json: Script "git:checked" eintragen?', true);
+      if (addGitScript) {
+        projectPackage.scripts = projectPackage.scripts || {};
+        if (!projectPackage.scripts['git:checked']) {
+          projectPackage.scripts['git:checked'] = 'git';
+        }
+        fs.writeFileSync(packagePath, JSON.stringify(projectPackage, null, 2) + '\n');
+      }
+    }
+  } else {
+    console.log('package.json nicht gefunden; Scripts wurden nicht angepasst.');
+  }
+
+  if (enableSupabase || enableGitWrapper || disableAiByDefault) {
+    const configPath = path.join(projectRoot, '.shimwrappercheckrc');
+    let writeConfig = true;
+    if (exists(configPath)) {
+      writeConfig = await askYesNo('Config .shimwrappercheckrc existiert. Ueberschreiben?', false);
+      if (!writeConfig) {
+        console.log('Config beibehalten.');
+      }
+    }
+    if (writeConfig) {
+      const lines = [];
+      lines.push('# shimwrappercheck config');
+      if (enableSupabase) {
+        lines.push(`SHIM_ENFORCE_COMMANDS="${enforceCommands}"`);
+        lines.push(`SHIM_HOOK_COMMANDS="${hookCommands}"`);
+        if (defaultFunction) {
+          lines.push(`SHIM_DEFAULT_FUNCTION="${defaultFunction}"`);
+        }
+        lines.push(`SHIM_AUTO_PUSH=${autoPush ? 1 : 0}`);
+      }
+      if (enableGitWrapper) {
+        lines.push(`SHIM_GIT_ENFORCE_COMMANDS="${gitEnforceCommands}"`);
+      }
+      if (disableAiByDefault) {
+        lines.push('SHIM_CHECKS_ARGS="--no-ai-review"');
+      }
+      fs.writeFileSync(configPath, lines.join('\n') + '\n');
+    }
+  }
+
+  console.log('');
+  console.log('Setup abgeschlossen. Naechste Schritte:');
+  if (enableSupabase) {
+    console.log('- nutze: npx supabase <args> oder npm run supabase:checked -- <args>');
+  }
+  if (enableGitWrapper) {
+    console.log('- nutze: npx git <args> oder npm run git:checked -- <args>');
+  }
+  console.log('- optional: npx shimwrappercheck install (globale PATH-Shims)');
+  if (enableAiReview) {
+    console.log('- optional: RUN_CURSOR_REVIEW=1 fuer zweiten Review-Durchlauf');
+  }
+  console.log('- pruefe ggf. scripts/run-checks.sh und passe die Checks an');
+  console.log('');
+  console.log('Einstellungen spaeter aendern: Dashboard starten mit');
+  console.log('  cd node_modules/shimwrappercheck/dashboard && npm install && npm run dev');
+  console.log('  dann http://localhost:3000 oeffnen (Presets, Checks, AGENTS.md).');
+
+  rl.close();
+}
+
+main().catch((err) => {
+  console.error('Init fehlgeschlagen:', err);
+  process.exit(1);
+});