@tdk-landscape/tdk-cli-core 1.3.53 → 1.3.54

package/scripts/measure-idle-footprint.sh

@@ -1,58 +0,0 @@
-#!/usr/bin/env bash
-# Checks an idle generated backend container against the runtime footprint budget
-# (openspec: runtime-container-footprint): one Bun process, <= 64 MiB, < 2% CPU.
-#
-# Usage: scripts/measure-idle-footprint.sh <container> [sample_seconds]
-set -euo pipefail
-
-container="${1:?usage: $0 <container> [sample_seconds]}"
-sample_seconds="${2:-60}"
-max_mem_mib="${MAX_MEM_MIB:-64}"
-max_cpu_pct="${MAX_CPU_PCT:-2}"
-
-echo "Waiting for ${container} to be healthy..."
-for _ in $(seq 1 90); do
-  health="$(docker inspect --format '{{if .State.Health}}{{.State.Health.Status}}{{else}}none{{end}}' "$container")"
-  [ "$health" = "healthy" ] || [ "$health" = "none" ] && break
-  sleep 2
-done
-if [ "$health" != "healthy" ] && [ "$health" != "none" ]; then
-  echo "FAIL: ${container} is ${health}, not healthy" >&2
-  exit 1
-fi
-
-bun_processes="$(docker top "$container" -o args | tail -n +2 | grep -c '^bun ' || true)"
-echo "Bun processes: ${bun_processes}"
-docker top "$container" -o pid,rss,args | sed 's/^/  /'
-
-to_mib() {
-  awk -v v="$1" 'BEGIN {
-    n = v + 0
-    if (v ~ /GiB$/) n *= 1024
-    else if (v ~ /KiB$/) n /= 1024
-    else if (v ~ /[0-9]B$/) n /= 1048576
-    printf "%.2f", n
-  }'
-}
-
-samples=0 cpu_total=0 mem_peak=0
-end=$((SECONDS + sample_seconds))
-while [ "$SECONDS" -lt "$end" ]; do
-  line="$(docker stats --no-stream --format '{{.CPUPerc}} {{.MemUsage}}' "$container")"
-  cpu="${line%%\%*}"
-  mem="$(to_mib "$(echo "$line" | awk '{print $2}')")"
-  cpu_total="$(awk -v a="$cpu_total" -v b="$cpu" 'BEGIN { printf "%.4f", a + b }')"
-  mem_peak="$(awk -v a="$mem_peak" -v b="$mem" 'BEGIN { print (b > a ? b : a) }')"
-  samples=$((samples + 1))
-  sleep 5
-done
-cpu_avg="$(awk -v t="$cpu_total" -v n="$samples" 'BEGIN { printf "%.2f", t / n }')"
-
-echo "Samples: ${samples} over ${sample_seconds}s | peak memory: ${mem_peak} MiB (max ${max_mem_mib}) | avg CPU: ${cpu_avg}% (max <${max_cpu_pct}%)"
-
-failed=0
-[ "$bun_processes" -eq 1 ] || { echo "FAIL: expected 1 Bun process, found ${bun_processes}" >&2; failed=1; }
-awk -v m="$mem_peak" -v max="$max_mem_mib" 'BEGIN { exit !(m <= max) }' || { echo "FAIL: memory over budget" >&2; failed=1; }
-awk -v c="$cpu_avg" -v max="$max_cpu_pct" 'BEGIN { exit !(c < max) }' || { echo "FAIL: CPU over budget" >&2; failed=1; }
-[ "$failed" -eq 0 ] && echo "PASS: ${container} is within the idle footprint budget"
-exit "$failed"

package/scripts/record-demo.sh

@@ -1,43 +0,0 @@
-#!/bin/bash
-# Re-record docs/demo.svg, the animated terminal demo shown in README.md.
-#
-# Needs `tdk` on PATH and termtosvg (pip install termtosvg). Run from the
-# repo root:  scripts/record-demo.sh
-# The demo runs real tdk commands in a temporary folder that is shown as
-# ~/my-shop. `tdk up` is only mentioned, because it needs Docker and Tilt.
-set -euo pipefail
-
-if [[ "${1:-}" != "--play" ]]; then
-  cast="$(mktemp -d)/demo.cast"
-  # `script` gives termtosvg a real terminal even when run from CI or an IDE.
-  script -qec "termtosvg record '$cast' -c '$0 --play' -g 92x30" /dev/null >/dev/null
-  termtosvg render "$cast" docs/demo.svg -t window_frame -M 3000
-  exit 0
-fi
-
-export FORCE_COLOR=1
-dir="$(mktemp -d)/my-shop"
-mkdir -p "$dir" && cd "$dir"
-
-tidy() { sed -u "s#$dir#~/my-shop#g"; }
-type_cmd() {
-  printf '\033[35m~/my-shop $\033[0m '
-  for ((i = 0; i < ${#1}; i++)); do printf '%s' "${1:$i:1}"; sleep 0.035; done
-  sleep 0.5; printf '\n'
-}
-
-clear; sleep 0.5
-type_cmd "tdk project --yes"
-tdk project --yes 2>&1 | tidy | grep --line-buffered -E "Initializing|✓ Created: .tdk/project|Generated: .tdk/.tdk-out/Tiltfile|docker-compose|✅"
-sleep 1.8
-type_cmd "tdk resource orders-api --type backend --stack shop"
-printf 'y\n' | tdk resource orders-api --type backend --stack shop 2>&1 | tidy | grep --line-buffered -E "Port:|Path:|Dockerfile|backend source|test file|✅"
-sleep 1.8
-type_cmd "tdk resource shop-web --type frontend --stack shop"
-printf 'y\n' | tdk resource shop-web --type frontend --stack shop 2>&1 | tidy | grep --line-buffered -E "Port:|Path:|✅"
-sleep 1.8
-type_cmd "tdk stacks --services"
-tdk stacks --services 2>&1 | tidy | grep -v '^\s*$'
-sleep 1.2
-printf '\n\033[2m# next: tdk up shop  (Tilt builds, runs and hot-reloads the whole stack)\033[0m\n'
-sleep 4

package/scripts/release-binaries.sh

@@ -1,97 +0,0 @@
-#!/usr/bin/env bash
-
-set -euo pipefail
-
-readonly ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-readonly RELEASE_REPOSITORY="tdk-landscape/tdk-cli-releases"
-readonly VERSION="$(node -p "require('${ROOT_DIR}/cli/package.json').version")"
-readonly RELEASE_TAG="v${VERSION}"
-readonly RELEASE_DIR="${ROOT_DIR}/release-dist-${RELEASE_TAG#v}"
-readonly PUBLISH="${1:-}"
-
-if ! command -v bun >/dev/null 2>&1; then
-  echo "bun is required to build release binaries" >&2
-  exit 1
-fi
-
-rm -rf "${RELEASE_DIR}"
-mkdir -p "${RELEASE_DIR}"
-
-build_target() {
-  local target="$1"
-  local output="$2"
-
-  bun build --compile --target="${target}" --outfile="${RELEASE_DIR}/${output}" "${ROOT_DIR}/cli/src/cli.ts"
-}
-
-build_target bun-linux-x64 tdk-linux-amd64
-build_target bun-linux-arm64 tdk-linux-arm64
-build_target bun-darwin-x64 tdk-darwin-amd64
-build_target bun-darwin-arm64 tdk-darwin-arm64
-
-# A compiled binary has no import.meta.dirname to walk up from, so it can't
-# find engine/ the way a source checkout can. template-engine.ts checks
-# exeDir/tdk-cli as a candidate - bundle the free engine (and the Handlebars
-# templates loadTemplate() reads at module init) there so a standalone binary
-# works the same as `tdk-cli-core` cloned from source.
-mkdir -p "${RELEASE_DIR}/tdk-cli"
-cp "${ROOT_DIR}/Tiltfile" "${RELEASE_DIR}/tdk-cli/Tiltfile"
-cp -R "${ROOT_DIR}/engine" "${RELEASE_DIR}/tdk-cli/engine"
-cp -R "${ROOT_DIR}/discovery" "${RELEASE_DIR}/tdk-cli/discovery"
-cp -R "${ROOT_DIR}/specs" "${RELEASE_DIR}/tdk-cli/specs"
-cp -R "${ROOT_DIR}/ext" "${RELEASE_DIR}/tdk-cli/ext"
-mkdir -p "${RELEASE_DIR}/tdk-cli/cli"
-cp -R "${ROOT_DIR}/cli/templates" "${RELEASE_DIR}/tdk-cli/cli/templates"
-
-(
-  cd "${RELEASE_DIR}"
-  # Fixed filename (no version/tag in the name) so install.sh can always
-  # find it via the stable /releases/latest/download/ URL, unlike the zip
-  # below whose name embeds the tag and changes every release.
-  tar -czf tdk-cli-engine.tar.gz tdk-cli
-  # install.sh and `tdk upgrade` verify the binary and the engine tarball
-  # against this file before installing them.
-  shasum -a 256 tdk-linux-amd64 tdk-linux-arm64 tdk-darwin-amd64 tdk-darwin-arm64 \
-    tdk-cli-engine.tar.gz > checksums.txt
-  zip -qr "tdk-cli-${RELEASE_TAG}-binaries.zip" \
-    tdk-linux-amd64 tdk-linux-arm64 tdk-darwin-amd64 tdk-darwin-arm64 \
-    tdk-cli checksums.txt
-)
-
-echo "Built release assets in ${RELEASE_DIR}"
-
-if [[ "${PUBLISH}" != "--publish" ]]; then
-  exit 0
-fi
-
-if ! command -v gh >/dev/null 2>&1; then
-  echo "gh is required to publish release binaries" >&2
-  exit 1
-fi
-
-# Upload actual files only - tdk-cli/ is a directory (the bundled engine),
-# already packed inside the zip, and `gh release upload` can't take a
-# directory as an asset.
-readonly ASSETS=(
-  "${RELEASE_DIR}/tdk-linux-amd64"
-  "${RELEASE_DIR}/tdk-linux-arm64"
-  "${RELEASE_DIR}/tdk-darwin-amd64"
-  "${RELEASE_DIR}/tdk-darwin-arm64"
-  "${RELEASE_DIR}/checksums.txt"
-  "${RELEASE_DIR}/tdk-cli-${RELEASE_TAG}-binaries.zip"
-  "${RELEASE_DIR}/tdk-cli-engine.tar.gz"
-)
-
-# Never mark a release latest until every asset is uploaded. `gh release create
-# --latest FILE...` publishes the tag first, then uploads binaries, so
-# /releases/latest/download/tdk-* 404s for a few minutes (install.sh hits this).
-if gh release view "${RELEASE_TAG}" --repo "${RELEASE_REPOSITORY}" >/dev/null 2>&1; then
-  gh release upload "${RELEASE_TAG}" --repo "${RELEASE_REPOSITORY}" --clobber "${ASSETS[@]}"
-else
-  gh release create "${RELEASE_TAG}" \
-    --repo "${RELEASE_REPOSITORY}" \
-    --title "TDK CLI ${RELEASE_TAG#v}" \
-    --draft \
-    "${ASSETS[@]}"
-fi
-gh release edit "${RELEASE_TAG}" --repo "${RELEASE_REPOSITORY}" --draft=false --latest

package/scripts/setup-pre-commit.sh

@@ -1,33 +0,0 @@
-#!/bin/bash
-# Setup script for TDK CLI development environment
-
-set -e
-
-echo "🚀 Setting up TDK CLI development environment..."
-
-# Check if pre-commit is installed
-if ! command -v pre-commit &> /dev/null; then
-    echo "📦 Installing pre-commit..."
-    pip install pre-commit
-fi
-
-# Install hooks
-echo "🔧 Installing pre-commit hooks..."
-pre-commit install
-
-# Run fast tests to verify everything works
-echo "🧪 Running fast tests to verify setup..."
-if python3 -m pytest -m fast --no-cov -q 2>/dev/null; then
-    echo "✅ Fast tests passed!"
-else
-    echo "⚠️  Some tests may need dependencies, but pre-commit is installed."
-fi
-
-echo ""
-echo "✅ Setup complete! Pre-commit hooks are now installed."
-echo ""
-echo "Usage:"
-echo "  git commit        # Runs fast tests automatically"
-echo "  make test-fast    # Run fast tests manually"
-echo "  make test-generator # Run generator-specific tests"
-echo "  pre-commit run --all-files  # Run all hooks manually"

package/scripts/stage-npm-engine.sh

@@ -1,36 +0,0 @@
-#!/usr/bin/env bash
-# Stages the free TDK Tilt extension (Tiltfile, engine/, discovery/, specs/,
-# ext/) into cli/ before `npm publish`.
-#
-# npm's `files` field can only package files inside the package directory
-# (cli/), but those directories live at the repo root - the same directories
-# scripts/release-binaries.sh bundles as tdk-cli/ next to the compiled
-# binaries. Staging them here lets findSelfContainedEngineRoot() in
-# template-engine.ts (vendorTdkExtension) find them for an npm/bun-installed
-# package the same way it already does for a plain git clone: Tiltfile and
-# engine/ sitting next to each other.
-#
-# Cleaned up by --clean (also gitignored, so a forgotten copy never lands in
-# a commit).
-set -euo pipefail
-
-readonly ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-readonly CLI_DIR="${ROOT_DIR}/cli"
-readonly DIRS=(engine discovery specs ext)
-
-if [[ "${1:-}" == "--clean" ]]; then
-  rm -f "${CLI_DIR}/Tiltfile"
-  for d in "${DIRS[@]}"; do
-    rm -rf "${CLI_DIR}/${d}"
-  done
-  echo "Cleaned staged engine files from cli/"
-  exit 0
-fi
-
-cp "${ROOT_DIR}/Tiltfile" "${CLI_DIR}/Tiltfile"
-for d in "${DIRS[@]}"; do
-  rm -rf "${CLI_DIR}/${d}"
-  cp -R "${ROOT_DIR}/${d}" "${CLI_DIR}/${d}"
-done
-
-echo "Staged Tiltfile, ${DIRS[*]} into cli/ for npm publish"

package/tests/tilt-engine/__init__.py

@@ -1,5 +0,0 @@
-"""
-Tilt Engine Test Suite.
-
-This package contains tests for the tilt-engine infrastructure.
-"""

package/tests/tilt-engine/conftest.py

@@ -1,182 +0,0 @@
-"""
-Pytest configuration and shared fixtures for tilt-engine tests.
-"""
-
-import json
-import os
-import pytest
-import tempfile
-import shutil
-from pathlib import Path
-from typing import Generator
-
-
-@pytest.fixture
-def temp_dir() -> Generator[Path, None, None]:
-    """Create a temporary directory for testing."""
-    with tempfile.TemporaryDirectory() as tmp_dir:
-        yield Path(tmp_dir)
-
-
-@pytest.fixture
-def mock_resources_dir(temp_dir: Path) -> Path:
-    """Create a mock resources directory structure with sample service.json files."""
-    resources_dir = temp_dir / "services" / "product"
-    resources_dir.mkdir(parents=True)
-    
-    # Create test resources
-    for stack in ["identity", "order"]:
-        stack_dir = resources_dir / stack
-        for resource in [f"{stack}-backend", f"{stack}-frontend"]:
-            resource_dir = stack_dir / resource
-            resource_dir.mkdir(parents=True)
-            resource_file = resource_dir / "service.json"
-            resource_file.write_text(json.dumps({
-                "name": resource,
-                "type": "backend" if "backend" in resource else "frontend",
-                "stack": stack,
-                "port": 4001 if "backend" in resource else 3001,
-                "path": str(resource_dir.relative_to(temp_dir))
-            }, indent=2))
-    
-    return resources_dir
-
-
-@pytest.fixture
-def mock_resource_json() -> dict:
-    """Return a sample valid service.json structure."""
-    return {
-        "name": "test-resource",
-        "appType": "backend",
-        "stack": "test",
-        "port": 4000,
-        "path": "services/product/test/test-resource",
-        "features": ["prisma", "nats"],
-        "replicas": 1
-    }
-
-
-@pytest.fixture
-def mock_invalid_resource_json() -> dict:
-    """Return an invalid service.json (missing required fields)."""
-    return {
-        "appType": "backend",
-        # Missing: name, stack, port, path
-    }
-
-
-@pytest.fixture
-def sample_snapshot() -> dict:
-    """Return a sample snapshot structure."""
-    return {
-        "timestamp": "2024-01-15T10:30:00Z",
-        "resources": [
-            "services/product/identity/identity-backend/service.json",
-            "services/product/identity/identity-frontend/service.json",
-        ],
-        "count": 2,
-        "hash": "abc123def456"
-    }
-
-
-@pytest.fixture
-def mock_health_response() -> dict:
-    """Return a sample health check response."""
-    return {
-        "status": "healthy",
-        "resource": "test-resource",
-        "version": "1.0.0",
-        "timestamp": "2024-01-15T10:30:00Z",
-        "uptime": 3600,
-        "dependencies": {
-            "database": "healthy",
-            "cache": "healthy"
-        }
-    }
-
-
-@pytest.fixture
-def mock_tilt_ui_status() -> dict:
-    """Return mock Tilt UI status for testing status colors."""
-    return {
-        "ready": {"indicator": "green", "status": "Ready"},
-        "starting": {"indicator": "yellow", "status": "Starting"},
-        "error": {"indicator": "red", "status": "Error"}
-    }
-
-
-@pytest.fixture
-def protected_volumes() -> list:
-    """Return list of protected volume patterns."""
-    return [
-        "verdaccio-storage",
-        "verdaccio-conf",
-        "verdaccio-plugins",
-        "infisical-db-data",
-        "infisical-redis-data"
-    ]
-
-
-@pytest.fixture
-def dangerous_commands() -> list:
-    """Return list of commands that should be blocked by code executor."""
-    return [
-        "rm -rf /",
-        "sudo rm -rf /",
-        "sudo su",
-        "passwd",
-        "mkfs",
-        "dd if=/dev/zero",
-    ]
-
-
-@pytest.fixture
-def safe_commands() -> list:
-    """Return list of commands that should be allowed by code executor."""
-    return [
-        "bun test",
-        "bun run dev",
-        "ls -la",
-        "cat package.json",
-        "git status",
-        "echo hello",
-    ]
-
-
-@pytest.fixture
-def resource_registry_cache() -> dict:
-    """Return an empty resource registry cache structure."""
-    return {
-        "initialized": False,
-        "app_resources": [],
-        "resource_dependencies": {},
-        "resource_aliases": {},
-        "resource_path_map": {}
-    }
-
-
-@pytest.fixture
-def mock_ide_server_port() -> int:
-    """Return mock port for IDE component testing."""
-    return 9999  # Non-standard port for testing
-
-
-@pytest.fixture
-def focus_mode_config() -> dict:
-    """Return focus mode configuration for testing."""
-    return {
-        "enabled": True,
-        "stacks": ["identity", "order"],
-        "excluded_paths": []
-    }
-
-
-def pytest_configure(config):
-    """Configure pytest with custom markers."""
-    config.addinivalue_line("markers", "snapshot: Tests for resource snapshot functionality")
-    config.addinivalue_line("markers", "daemon: Tests for discovery daemon")
-    config.addinivalue_line("markers", "health: Tests for health check endpoints")
-    config.addinivalue_line("markers", "ide: Tests for IDE components")
-    config.addinivalue_line("markers", "safety: Tests for safety guards")
-    config.addinivalue_line("markers", "cache: Tests for registry cache")
-    config.addinivalue_line("markers", "integration: Integration tests")

package/tests/tilt-engine/fixtures/appointment-frontend-service.json

@@ -1,11 +0,0 @@
-{
-  "name": "order-frontend",
-  "type": "frontend",
-  "stack": "order",
-  "port": 3001,
-  "path": "services/product/order/order-frontend",
-  "backendName": "order-backend",
-  "basePath": "/orders",
-  "featuresEnabled": ["vite"],
-  "replicas": 1
-}

package/tests/tilt-engine/fixtures/identity-backend-service.json

@@ -1,12 +0,0 @@
-{
-  "name": "identity-backend",
-  "type": "backend",
-  "stack": "identity",
-  "port": 4001,
-  "path": "services/product/identity/identity-backend",
-  "databaseName": "{project}_identity",
-  "featuresEnabled": ["prisma", "nats", "health-check"],
-  "replicas": 2,
-  "healthCheck": true,
-  "healthCheckPath": "/health"
-}

package/tests/tilt-engine/fixtures/invalid-service.json

@@ -1,4 +0,0 @@
-{
-  "type": "backend",
-  "port": 4000
-}