@gurulu/cli 0.4.7 → 1.0.1

package/scripts/gurulu-scan.mjs

@@ -1,91 +0,0 @@
-#!/usr/bin/env node
-// gurulu-scan.mjs — standalone repo scanner CLI (Phase 13 B2).
-//
-// Detection logic lives in `scripts/gurulu-scan.lib.cjs` so it can be reused
-// by ts-jest tests via `require()`. This wrapper exposes the same API as an
-// ESM module and, when invoked directly, runs the CLI.
-//
-// Usage:
-//   node scripts/gurulu-scan.mjs <repo-path> [--output <file>] [--quiet]
-
-import { createRequire } from 'node:module';
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const require = createRequire(import.meta.url);
-const lib = require('./gurulu-scan.lib.cjs');
-
-export const SCAN_VERSION = lib.SCAN_VERSION;
-export const detectFramework = lib.detectFramework;
-export const detectORM = lib.detectORM;
-export const detectAuth = lib.detectAuth;
-export const detectRoutes = lib.detectRoutes;
-export const detectMutations = lib.detectMutations;
-export const scanRepo = lib.scanRepo;
-// Phase 18.6 A1
-export const extractSchemaTables = lib.extractSchemaTables;
-export const extractDependencyFingerprint = lib.extractDependencyFingerprint;
-export const extractUiStrings = lib.extractUiStrings;
-export const extractI18nKeys = lib.extractI18nKeys;
-export const extractFolderStructureHints = lib.extractFolderStructureHints;
-export const extractEnvVarHints = lib.extractEnvVarHints;
-export const extractCommentBlockHints = lib.extractCommentBlockHints;
-
-// ---------------------------------------------------------------------------
-// CLI entry
-// ---------------------------------------------------------------------------
-function parseArgs(argv) {
-  const args = { _: [], output: null, quiet: false };
-  for (let i = 0; i < argv.length; i++) {
-    const a = argv[i];
-    if (a === '--output' || a === '-o' || a === '--out') {
-      args.output = argv[++i];
-    } else if (a === '--quiet' || a === '-q') {
-      args.quiet = true;
-    } else if (a === '--help' || a === '-h') {
-      args.help = true;
-    } else {
-      args._.push(a);
-    }
-  }
-  return args;
-}
-
-async function main() {
-  const args = parseArgs(process.argv.slice(2));
-  if (args.help || args._.length === 0) {
-    process.stdout.write(
-      'Usage: node scripts/gurulu-scan.mjs <repo-path> [--output <file>] [--quiet]\n',
-    );
-    process.exit(args.help ? 0 : 1);
-  }
-  const rootPath = args._[0];
-  const log = args.quiet ? () => {} : (m) => process.stderr.write(m + '\n');
-  const plan = await scanRepo(rootPath, { log });
-  const json = JSON.stringify(plan, null, 2);
-  if (args.output) {
-    await fs.writeFile(args.output, json + '\n', 'utf8');
-    if (!args.quiet) process.stderr.write(`[scan] wrote ${args.output}\n`);
-  } else {
-    process.stdout.write(json + '\n');
-  }
-}
-
-const invokedDirectly =
-  typeof process !== 'undefined' &&
-  process.argv[1] &&
-  (() => {
-    try {
-      return fileURLToPath(import.meta.url) === path.resolve(process.argv[1]);
-    } catch {
-      return false;
-    }
-  })();
-
-if (invokedDirectly) {
-  main().catch((err) => {
-    process.stderr.write(`[scan] ERROR: ${err.stack || err.message || err}\n`);
-    process.exit(1);
-  });
-}

package/scripts/gurulu-verify-install.lib.cjs

@@ -1,334 +0,0 @@
-// gurulu-verify-install.lib.cjs
-//
-// Pure-CJS library used by both the `.mjs` CLI wrapper and the ts-jest
-// test suite. Contains the entire verification loop implementation so
-// no jest runtime has to pull in ESM.
-//
-// See scripts/gurulu-verify-install.mjs for the CLI front-end.
-
-'use strict';
-
-const { createServer } = require('node:http');
-const { spawn } = require('node:child_process');
-const fs = require('node:fs');
-const path = require('node:path');
-
-// ---------------------------------------------------------------------------
-// Argv parsing
-// ---------------------------------------------------------------------------
-
-function parseArgs(argv) {
-  const args = {
-    path: null,
-    framework: null,
-    siteId: null,
-    tenantId: null,
-    ingestUrl: null,
-    port: 3000,
-    timeout: 30000,
-    dryRun: false,
-  };
-  const positional = [];
-  for (let i = 0; i < argv.length; i++) {
-    const a = argv[i];
-    if (a === '--framework') args.framework = argv[++i];
-    else if (a === '--site-id') args.siteId = argv[++i];
-    else if (a === '--tenant-id') args.tenantId = argv[++i];
-    else if (a === '--ingest-url') args.ingestUrl = argv[++i];
-    else if (a === '--port') args.port = Number(argv[++i]);
-    else if (a === '--timeout') args.timeout = Number(argv[++i]);
-    else if (a === '--dry-run') args.dryRun = true;
-    else if (!a.startsWith('--')) positional.push(a);
-  }
-  if (positional.length > 0) args.path = positional[0];
-  return args;
-}
-
-// ---------------------------------------------------------------------------
-// Package manager detection (inline, mirrors the CLI helper)
-// ---------------------------------------------------------------------------
-
-function detectPackageManager(repoRoot) {
-  if (fs.existsSync(path.join(repoRoot, 'pnpm-lock.yaml'))) return 'pnpm';
-  if (fs.existsSync(path.join(repoRoot, 'yarn.lock'))) return 'yarn';
-  return 'npm';
-}
-
-// ---------------------------------------------------------------------------
-// Dev command resolution
-// ---------------------------------------------------------------------------
-
-function resolveDevCommand(framework, repoRoot, pm = 'npm') {
-  const fw = (framework || '').toLowerCase();
-  if (fw.startsWith('next') || fw === 'nextjs' || fw === 'nextjs-app' || fw === 'nextjs-pages') {
-    return { cmd: pm, args: ['run', 'dev'] };
-  }
-  if (fw === 'vite' || fw === 'vite-react' || fw === 'vite-vue') {
-    return { cmd: pm, args: ['run', 'dev'] };
-  }
-  if (fw === 'express' || fw === 'node') {
-    let entry = 'index.js';
-    const pkgPath = path.join(repoRoot, 'package.json');
-    if (fs.existsSync(pkgPath)) {
-      try {
-        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-        if (pkg.main) entry = pkg.main;
-        else if (pkg.scripts && pkg.scripts.start) {
-          const m = /node\s+([^\s]+)/.exec(pkg.scripts.start);
-          if (m) entry = m[1];
-        } else if (fs.existsSync(path.join(repoRoot, 'app.js'))) entry = 'app.js';
-        else if (fs.existsSync(path.join(repoRoot, 'server.js'))) entry = 'server.js';
-      } catch {
-        // ignore
-      }
-    }
-    return { cmd: 'node', args: [entry] };
-  }
-  return { cmd: pm, args: ['run', 'dev'] };
-}
-
-function healthPathFor(framework) {
-  const fw = (framework || '').toLowerCase();
-  if (fw === 'express' || fw === 'node') return '/health';
-  return '/';
-}
-
-// ---------------------------------------------------------------------------
-// Capture server
-// ---------------------------------------------------------------------------
-
-function startCaptureServer() {
-  return new Promise((resolve, reject) => {
-    const events = [];
-    const server = createServer((req, res) => {
-      if (req.method === 'POST' && req.url && req.url.startsWith('/api/ingest/v1/collect')) {
-        let body = '';
-        req.on('data', (chunk) => (body += chunk.toString()));
-        req.on('end', () => {
-          let parsed = null;
-          try {
-            parsed = JSON.parse(body);
-          } catch {
-            parsed = { _raw: body };
-          }
-          if (Array.isArray(parsed)) {
-            for (const ev of parsed) events.push(ev);
-          } else if (parsed && Array.isArray(parsed.events)) {
-            for (const ev of parsed.events) events.push(ev);
-          } else if (parsed) {
-            events.push(parsed);
-          }
-          res.writeHead(200, { 'content-type': 'application/json' });
-          res.end(JSON.stringify({ ok: true }));
-        });
-        return;
-      }
-      if (req.method === 'POST' && req.url && req.url.startsWith('/api/ingest/v1/health')) {
-        res.writeHead(200, { 'content-type': 'application/json' });
-        res.end(JSON.stringify({ ok: true }));
-        return;
-      }
-      res.writeHead(404);
-      res.end();
-    });
-    server.on('error', reject);
-    server.listen(0, '127.0.0.1', () => {
-      const addr = server.address();
-      const port = typeof addr === 'object' && addr ? addr.port : 0;
-      resolve({
-        url: `http://127.0.0.1:${port}`,
-        port,
-        events,
-        close: () => new Promise((r) => server.close(() => r())),
-      });
-    });
-  });
-}
-
-// ---------------------------------------------------------------------------
-// Polling
-// ---------------------------------------------------------------------------
-
-function defaultSleep(ms) {
-  return new Promise((r) => setTimeout(r, ms));
-}
-
-async function waitForUrl(url, timeoutMs, fetchImpl = globalThis.fetch, sleep = defaultSleep) {
-  const deadline = Date.now() + timeoutMs;
-  let lastErr = null;
-  while (Date.now() < deadline) {
-    try {
-      const res = await fetchImpl(url);
-      if (res && res.status && res.status < 500) return true;
-    } catch (err) {
-      lastErr = err;
-    }
-    await sleep(250);
-  }
-  throw new Error(`Timeout waiting for ${url}${lastErr ? `: ${lastErr.message || lastErr}` : ''}`);
-}
-
-// ---------------------------------------------------------------------------
-// Event assertion
-// ---------------------------------------------------------------------------
-
-function findPageViewEvent(events, siteId, tenantId) {
-  for (const ev of events) {
-    if (!ev) continue;
-    const name = ev.event_name || ev.eventName || ev.name || ev.type;
-    if (name !== '$page_view') continue;
-    const sid = ev.site_id || ev.siteId || (ev.context && ev.context.site_id);
-    const tid = ev.tenant_id || ev.tenantId || (ev.context && ev.context.tenant_id);
-    if (sid !== siteId) continue;
-    if (tid !== tenantId) continue;
-    return ev;
-  }
-  return null;
-}
-
-// ---------------------------------------------------------------------------
-// Main verifier
-// ---------------------------------------------------------------------------
-
-async function runVerify(args, deps) {
-  const result = {
-    ok: false,
-    framework: args.framework,
-    capturedEventCount: 0,
-    pageViewSeen: false,
-    reason: null,
-    dryRun: !!args.dryRun,
-  };
-
-  if (!args.path) {
-    result.reason = 'missing repo path';
-    return result;
-  }
-  if (!args.siteId || !args.tenantId) {
-    result.reason = 'missing --site-id / --tenant-id';
-    return result;
-  }
-  if (!args.framework) {
-    result.reason = 'missing --framework';
-    return result;
-  }
-
-  const repoRoot = path.resolve(args.path);
-  const pm = detectPackageManager(repoRoot);
-  const dev = resolveDevCommand(args.framework, repoRoot, pm);
-  const healthPath = healthPathFor(args.framework);
-
-  if (args.dryRun) {
-    result.ok = true;
-    result.reason = 'dry-run';
-    result.plan = {
-      pm,
-      dev,
-      healthPath,
-      port: args.port,
-      timeout: args.timeout,
-    };
-    if (deps.log && deps.log.info) {
-      deps.log.info(
-        `[verify] dry-run plan: ${dev.cmd} ${dev.args.join(' ')} in ${repoRoot} ` +
-          `(pm=${pm}, port=${args.port}, health=${healthPath})`,
-      );
-    }
-    return result;
-  }
-
-  const capture = await deps.startCapture();
-  if (deps.log && deps.log.info) {
-    deps.log.info(`[verify] capture server listening at ${capture.url}`);
-  }
-
-  let child = null;
-  let browser = null;
-  try {
-    const envOverrides = {
-      NEXT_PUBLIC_GURULU_INGEST_URL: capture.url,
-      GURULU_INGEST_URL: capture.url,
-      VITE_GURULU_INGEST_URL: capture.url,
-      NEXT_PUBLIC_GURULU_SITE_ID: args.siteId,
-      NEXT_PUBLIC_GURULU_TENANT_ID: args.tenantId,
-      PORT: String(args.port),
-    };
-    child = deps.spawnDev({
-      cmd: dev.cmd,
-      args: dev.args,
-      cwd: repoRoot,
-      env: Object.assign({}, process.env, envOverrides),
-    });
-
-    const targetUrl = `http://127.0.0.1:${args.port}${healthPath}`;
-    await deps.waitForUrl(targetUrl, args.timeout);
-
-    browser = await deps.launchBrowser();
-    const context = await browser.newContext();
-    const page = await context.newPage();
-    await page.goto(`http://127.0.0.1:${args.port}/`, { waitUntil: 'networkidle' });
-    await new Promise((r) => setTimeout(r, 50));
-
-    result.capturedEventCount = capture.events.length;
-    const hit = findPageViewEvent(capture.events, args.siteId, args.tenantId);
-    if (!hit) {
-      result.reason = 'no page_view received';
-      return result;
-    }
-    result.pageViewSeen = true;
-    result.ok = true;
-    return result;
-  } catch (err) {
-    result.reason = err && err.message ? err.message : String(err);
-    return result;
-  } finally {
-    try {
-      if (browser && typeof browser.close === 'function') await browser.close();
-    } catch {}
-    try {
-      if (child && typeof child.kill === 'function') child.kill('SIGTERM');
-    } catch {}
-    try {
-      await capture.close();
-    } catch {}
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Default deps (real implementations)
-// ---------------------------------------------------------------------------
-
-function createDefaultDeps() {
-  return {
-    startCapture: startCaptureServer,
-    spawnDev: ({ cmd, args, cwd, env }) =>
-      spawn(cmd, args, {
-        cwd,
-        env,
-        stdio: ['ignore', 'pipe', 'pipe'],
-        shell: process.platform === 'win32',
-      }),
-    waitForUrl: (url, timeout) => waitForUrl(url, timeout),
-    launchBrowser: async () => {
-      const { chromium } = require('playwright-core');
-      return chromium.launch({ headless: true });
-    },
-    log: {
-      info: (m) => process.stderr.write(`${m}\n`),
-      warn: (m) => process.stderr.write(`${m}\n`),
-      error: (m) => process.stderr.write(`${m}\n`),
-    },
-  };
-}
-
-module.exports = {
-  parseArgs,
-  detectPackageManager,
-  resolveDevCommand,
-  healthPathFor,
-  startCaptureServer,
-  waitForUrl,
-  findPageViewEvent,
-  runVerify,
-  createDefaultDeps,
-};

package/scripts/gurulu-verify-install.mjs

@@ -1,59 +0,0 @@
-#!/usr/bin/env node
-// gurulu-verify-install.mjs — standalone post-install smoke test CLI
-// (Phase 16 A3).
-//
-// Verification logic lives in `scripts/gurulu-verify-install.lib.cjs` so
-// it can be reused by ts-jest tests via `require()`. This wrapper exposes
-// the same API as an ESM module and, when invoked directly, runs the CLI.
-//
-// Usage:
-//   node scripts/gurulu-verify-install.mjs <repo-path> \
-//     --framework nextjs-app --site-id demo --tenant-id demo \
-//     [--ingest-url <url>] [--port 3000] [--timeout 30000] [--dry-run]
-
-import { createRequire } from 'node:module';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const require = createRequire(import.meta.url);
-const lib = require('./gurulu-verify-install.lib.cjs');
-
-export const parseArgs = lib.parseArgs;
-export const detectPackageManager = lib.detectPackageManager;
-export const resolveDevCommand = lib.resolveDevCommand;
-export const healthPathFor = lib.healthPathFor;
-export const startCaptureServer = lib.startCaptureServer;
-export const waitForUrl = lib.waitForUrl;
-export const findPageViewEvent = lib.findPageViewEvent;
-export const runVerify = lib.runVerify;
-export const createDefaultDeps = lib.createDefaultDeps;
-
-const isMain = (() => {
-  try {
-    const thisFile = fileURLToPath(import.meta.url);
-    return process.argv[1] && path.resolve(process.argv[1]) === path.resolve(thisFile);
-  } catch {
-    return false;
-  }
-})();
-
-if (isMain) {
-  const args = lib.parseArgs(process.argv.slice(2));
-  const deps = lib.createDefaultDeps();
-  lib
-    .runVerify(args, deps)
-    .then((result) => {
-      process.stdout.write(`VERIFY_RESULT ${JSON.stringify(result)}\n`);
-      process.exit(result.ok ? 0 : 1);
-    })
-    .catch((err) => {
-      process.stderr.write(`[verify] fatal: ${err && err.stack ? err.stack : err}\n`);
-      process.stdout.write(
-        `VERIFY_RESULT ${JSON.stringify({
-          ok: false,
-          reason: String(err && err.message ? err.message : err),
-        })}\n`,
-      );
-      process.exit(2);
-    });
-}

package/scripts/init-ssl.sh

@@ -1,26 +0,0 @@
-#!/bin/bash
-set -e
-
-DOMAIN="${DOMAIN:-gurulu.io}"
-EMAIL="${SSL_EMAIL:-admin@gurulu.io}"
-
-echo "[ssl] Initializing SSL for ${DOMAIN}..."
-
-# Create certbot webroot
-mkdir -p /var/www/certbot
-
-# Request certificate
-docker run --rm \
-  -v "$(pwd)/certbot/conf:/etc/letsencrypt" \
-  -v "$(pwd)/certbot/www:/var/www/certbot" \
-  certbot/certbot certonly \
-    --webroot \
-    --webroot-path=/var/www/certbot \
-    --email "$EMAIL" \
-    --agree-tos \
-    --no-eff-email \
-    -d "$DOMAIN" \
-    -d "www.${DOMAIN}"
-
-echo "[ssl] Certificate obtained for ${DOMAIN}"
-echo "[ssl] Files at: certbot/conf/live/${DOMAIN}/"

package/scripts/migrate-flow-graph-enums.sh

@@ -1,86 +0,0 @@
-#!/usr/bin/env bash
-# =============================================================================
-# Migration: flow-graph enum extension (W2.1)
-#
-# Extends ClickHouse enums on gurulu.flow_nodes.node_type and
-# gurulu.flow_edges.edge_type with new values needed by the flow-graph
-# processor rework in W2.2.
-#
-# flow_nodes.node_type: + 'step'=9, 'state_change'=10, 'drawer'=11, 'tab'=12
-# flow_edges.edge_type: + 'advances_to'=9, 'interacts_with'=10, 'verifies_as'=11
-#
-# Idempotent: checks DESCRIBE TABLE output for the new enum values before
-# running; if already present, exits 0. Existing rows are untouched.
-# =============================================================================
-set -euo pipefail
-
-CONTAINER="${CLICKHOUSE_CONTAINER:-gurulu-clickhouse}"
-DB="${CLICKHOUSE_DB:-gurulu}"
-
-ch_query() {
-  docker exec "$CONTAINER" clickhouse-client --query "$1"
-}
-
-log() { printf '[migrate-flow-graph-enums] %s\n' "$*"; }
-die() { printf '[migrate-flow-graph-enums] ERROR: %s\n' "$*" >&2; exit 1; }
-
-# --- Preflight ---------------------------------------------------------------
-if ! docker ps --format '{{.Names}}' | grep -q "^${CONTAINER}$"; then
-  die "ClickHouse container '${CONTAINER}' is not running"
-fi
-
-log "Inspecting current enum definitions..."
-NODE_DESC=$(ch_query "DESCRIBE TABLE ${DB}.flow_nodes FORMAT TSVRaw" | awk -F'\t' '$1=="node_type"{print $2}')
-EDGE_DESC=$(ch_query "DESCRIBE TABLE ${DB}.flow_edges FORMAT TSVRaw" | awk -F'\t' '$1=="edge_type"{print $2}')
-
-if [[ -z "$NODE_DESC" ]]; then die "Could not read flow_nodes.node_type definition"; fi
-if [[ -z "$EDGE_DESC" ]]; then die "Could not read flow_edges.edge_type definition"; fi
-
-log "flow_nodes.node_type = ${NODE_DESC}"
-log "flow_edges.edge_type = ${EDGE_DESC}"
-
-NODE_NEEDED=("'step' = 9" "'state_change' = 10" "'drawer' = 11" "'tab' = 12")
-EDGE_NEEDED=("'advances_to' = 9" "'interacts_with' = 10" "'verifies_as' = 11")
-
-node_has_all=true
-for v in "${NODE_NEEDED[@]}"; do
-  if [[ "$NODE_DESC" != *"$v"* ]]; then node_has_all=false; break; fi
-done
-
-edge_has_all=true
-for v in "${EDGE_NEEDED[@]}"; do
-  if [[ "$EDGE_DESC" != *"$v"* ]]; then edge_has_all=false; break; fi
-done
-
-if $node_has_all && $edge_has_all; then
-  log "already migrated — new enum values are present on both tables"
-  log "flow_nodes count: $(ch_query "SELECT count() FROM ${DB}.flow_nodes")"
-  log "flow_edges count: $(ch_query "SELECT count() FROM ${DB}.flow_edges")"
-  exit 0
-fi
-
-# --- Apply ALTERs ------------------------------------------------------------
-NODE_ENUM="Enum8('page' = 1, 'modal' = 2, 'form' = 3, 'action' = 4, 'api_call' = 5, 'success' = 6, 'error' = 7, 'milestone' = 8, 'step' = 9, 'state_change' = 10, 'drawer' = 11, 'tab' = 12)"
-EDGE_ENUM="Enum8('navigates' = 1, 'opens' = 2, 'submits' = 3, 'triggers' = 4, 'resolves' = 5, 'fails' = 6, 'completes' = 7, 'abandons' = 8, 'advances_to' = 9, 'interacts_with' = 10, 'verifies_as' = 11)"
-
-if ! $node_has_all; then
-  log "ALTER flow_nodes.node_type -> extended enum"
-  ch_query "ALTER TABLE ${DB}.flow_nodes MODIFY COLUMN node_type ${NODE_ENUM} DEFAULT 'page'"
-fi
-
-if ! $edge_has_all; then
-  log "ALTER flow_edges.edge_type -> extended enum"
-  ch_query "ALTER TABLE ${DB}.flow_edges MODIFY COLUMN edge_type ${EDGE_ENUM} DEFAULT 'navigates'"
-fi
-
-# --- Verify ------------------------------------------------------------------
-log "Post-migration DESCRIBE:"
-ch_query "DESCRIBE TABLE ${DB}.flow_nodes" | awk -F'\t' '$1=="node_type"{print "  node_type: "$2}'
-ch_query "DESCRIBE TABLE ${DB}.flow_edges" | awk -F'\t' '$1=="edge_type"{print "  edge_type: "$2}'
-
-NODE_COUNT=$(ch_query "SELECT count() FROM ${DB}.flow_nodes")
-EDGE_COUNT=$(ch_query "SELECT count() FROM ${DB}.flow_edges")
-
-log "Sanity check — flow_nodes count: ${NODE_COUNT}"
-log "Sanity check — flow_edges count: ${EDGE_COUNT}"
-log "Migration complete."

package/scripts/monitor-disk.sh

@@ -1,24 +0,0 @@
-#!/bin/bash
-# Disk usage monitor — runs via cron every 6 hours
-# Logs to /data/backups/monitor.log
-# Exit codes: 0=OK, 1=WARNING, 2=CRITICAL
-
-THRESHOLD_WARN=80
-THRESHOLD_CRIT=90
-
-USAGE=$(df / | tail -1 | awk '{print $5}' | tr -d '%')
-DATA_USAGE=$(df /data | tail -1 | awk '{print $5}' | tr -d '%' 2>/dev/null || echo "0")
-
-TIMESTAMP=$(date -u '+%Y-%m-%d %H:%M:%S UTC')
-
-if [ "$USAGE" -ge "$THRESHOLD_CRIT" ] || [ "$DATA_USAGE" -ge "$THRESHOLD_CRIT" ]; then
-  echo "[$TIMESTAMP] CRITICAL: Disk usage root=${USAGE}% data=${DATA_USAGE}%"
-  # TODO: send alert (Discord webhook or email)
-  exit 2
-elif [ "$USAGE" -ge "$THRESHOLD_WARN" ] || [ "$DATA_USAGE" -ge "$THRESHOLD_WARN" ]; then
-  echo "[$TIMESTAMP] WARNING: Disk usage root=${USAGE}% data=${DATA_USAGE}%"
-  exit 1
-else
-  echo "[$TIMESTAMP] OK: Disk usage root=${USAGE}% data=${DATA_USAGE}%"
-  exit 0
-fi

package/scripts/patches/astro.patch.cjs

@@ -1,74 +0,0 @@
-// astro.patch.cjs — Phase 18.7 A1
-//
-// Detects an Astro project by the presence of a layout or index page
-// `.astro` file. Astro processes `<script>` tags by default (Vite bundle);
-// we use the `is:inline` directive so Astro emits our tracker tag exactly
-// as written, without touching it.
-
-const fs = require('fs');
-const path = require('path');
-
-const NAME = 'astro';
-const CANDIDATES = [
-  'src/layouts/Layout.astro',
-  'src/layouts/BaseLayout.astro',
-  'src/layouts/MainLayout.astro',
-  'src/pages/index.astro',
-];
-
-const MARKER = 'data-gurulu-install="1"';
-
-function detect(repoRoot) {
-  for (const rel of CANDIDATES) {
-    if (fs.existsSync(path.join(repoRoot, rel))) {
-      return { framework: NAME, files: [rel] };
-    }
-  }
-  return null;
-}
-
-function buildScriptTag(injection) {
-  const pkAttr = injection.publishableKey
-    ? ` data-gurulu-publishable-key="${injection.publishableKey}"`
-    : '';
-  return (
-    `    <script\n` +
-    `      is:inline\n` +
-    `      src="${injection.scriptSrc}"\n` +
-    `      data-gurulu-site-id="${injection.siteId}"\n` +
-    `      data-gurulu-tenant-id="${injection.tenantId}"${pkAttr}\n` +
-    `      data-features="errors,replay,advanced"\n` +
-    `      ${MARKER}\n` +
-    `      async\n` +
-    `    ></script>\n`
-  );
-}
-
-function injectScriptTag(source, injection) {
-  if (source.includes(MARKER)) return source;
-  const tag = buildScriptTag(injection);
-  if (/<\/body>/.test(source)) {
-    return source.replace(/<\/body>/, `${tag}  </body>`);
-  }
-  if (/<\/head>/.test(source)) {
-    return source.replace(/<\/head>/, `${tag}  </head>`);
-  }
-  return source + '\n' + tag;
-}
-
-function plan(ctx) {
-  const detection = detect(ctx.repoRoot);
-  if (!detection) return { changes: [], notes: ['no-astro-layout'] };
-  const changes = [];
-  for (const rel of detection.files) {
-    const abs = path.join(ctx.repoRoot, rel);
-    const before = fs.readFileSync(abs, 'utf8');
-    const after = injectScriptTag(before, ctx.injection);
-    if (after !== before) {
-      changes.push({ relPath: rel, before, after, reason: 'inject-script-tag' });
-    }
-  }
-  return { changes, notes: [] };
-}
-
-module.exports = { name: NAME, detect, plan };