gorig-cli 1.0.24 → 1.0.25

package/templates/skills/gorig-backend/references/service-lifecycle.md

@@ -0,0 +1,51 @@
+# Service Lifecycle
+
+## Built-in Startup
+
+Use one application entry point:
+
+```go
+func main() {
+	bootstrap.StartUp()
+}
+```
+
+In the verified baseline, `bootstrap.StartUp()` registers the built-in HTTP service, prints registered routes, and calls `serv.Running()`.
+
+Do not also register an application-specific service whose `Startup` and `Shutdown` are `httpx.Startup` and `httpx.Shutdown`; that creates duplicate lifecycle entries for one HTTP server.
+
+## Registration Through Imports
+
+Gorig projects commonly register routes, migrations, scheduled tasks, and services from package `init()` functions. Entry points use explicit blank imports to activate the intended packages:
+
+```go
+import _ "example.com/demo/domain"
+```
+
+Keep the import graph visible. Do not add a component import merely to make a package compile; every blank import changes application startup behavior.
+
+## Custom Service
+
+Register a distinct lifecycle component only when it owns a distinct resource:
+
+```go
+err := serv.RegisterService(serv.Service{
+	Code:     "WORKER",
+	Startup:  workerStartup,
+	Shutdown: workerShutdown,
+})
+```
+
+Requirements:
+
+- Use a unique stable code.
+- Return startup failures.
+- Honor the shutdown context.
+- Make shutdown idempotent.
+- Do not rely on service map iteration order.
+
+## Graceful Shutdown
+
+The verified baseline waits for `os.Interrupt`, then gives registered services a five-second shutdown context. Test graceful shutdown with `SIGINT` and require the process to exit successfully.
+
+Do not claim `SIGTERM` support without checking the resolved version; signal handling is version-specific.

package/templates/skills/gorig-backend/references/source-map.md

@@ -0,0 +1,43 @@
+# Source Map
+
+Prefer an exact version or commit over the moving `master` links below.
+
+## Core Framework
+
+- Repository: `https://github.com/jom-io/gorig`
+- Startup: `https://github.com/jom-io/gorig/blob/master/bootstrap/startup.go`
+- Service lifecycle: `https://github.com/jom-io/gorig/blob/master/serv/serv.go`
+- HTTP: `https://github.com/jom-io/gorig/tree/master/httpx`
+- API helpers: `https://github.com/jom-io/gorig/tree/master/apix`
+- Data access: `https://github.com/jom-io/gorig/tree/master/domainx`
+- dx facade: `https://github.com/jom-io/gorig/blob/master/domainx/dx/dx.go`
+- Cache: `https://github.com/jom-io/gorig/tree/master/cache`
+- Scheduled tasks: `https://github.com/jom-io/gorig/tree/master/cronx`
+- Messaging: `https://github.com/jom-io/gorig/tree/master/mid/messagex`
+- Authentication: `https://github.com/jom-io/gorig/tree/master/mid/tokenx`
+- Auth middleware: `https://github.com/jom-io/gorig/blob/master/httpx/mid.sign.go`
+- Security middleware: `https://github.com/jom-io/gorig/blob/master/httpx/mid.cors.go`, `https://github.com/jom-io/gorig/blob/master/httpx/mid.debounce.go`
+- Outbound HTTP: `https://github.com/jom-io/gorig/blob/master/httpx/http.go`
+- Tests: `https://github.com/jom-io/gorig/tree/master/test`
+
+To inspect a release, replace `/master/` with the tag, for example `/v0.0.52/`, after confirming the tag exists.
+
+## Ecosystem
+
+- Service registry: `https://github.com/jom-io/gorig-hub`
+- Service node/client: `https://github.com/jom-io/gorig-node`
+- Operations and deployment: `https://github.com/jom-io/gorig-om`
+
+Check each repository's `go.mod`; ecosystem projects may pin different Gorig versions.
+
+## Local Sibling Discovery
+
+When working inside a directory such as `<workspace>/gorig-cli`, check sibling directories only after resolving the target dependency:
+
+```sh
+find .. -maxdepth 2 -name go.mod -print
+git -C ../gorig branch --show-current
+git -C ../gorig log -1 --oneline
+```
+
+Useful local examples may exist in business repositories, but they are evidence of usage, not a replacement for the framework API source. Avoid copying product-specific dependencies, secrets, or architecture without evaluating fit.

package/templates/skills/gorig-backend/references/source-policy.md

@@ -0,0 +1,58 @@
+# Source and Version Policy
+
+Use this policy before selecting any Gorig API or example.
+
+## Evidence Order
+
+1. Read the target project's `go.mod` and all `replace` directives.
+2. Prefer the exact resolved dependency source in the Go module cache.
+3. Use a local sibling Gorig checkout only when it matches the project version or the task explicitly targets that checkout.
+4. Use the matching public GitHub tag or commit for versioned work.
+5. Use GitHub `master` only for explicit latest-version, framework-development, or upgrade work.
+6. Use bundled examples only as offline fallbacks and re-check their signatures before editing.
+
+## Required Version Report
+
+Before a material change, report:
+
+- Target module name and Go version.
+- Required Gorig version or pseudo-version.
+- Active `replace` target, if any.
+- Source directory used for verification.
+- Whether the work preserves the current version or upgrades it.
+
+Do not silently run `go get ...@latest` in an existing project.
+
+## Source Resolution
+
+Run:
+
+```sh
+scripts/detect-gorig-context.sh /path/to/project
+```
+
+If the script cannot locate an exact source directory:
+
+1. Run `go env GOMODCACHE` from the target project.
+2. Use `go list -m -json github.com/jom-io/gorig` when dependencies are available.
+3. Inspect a compatible local checkout.
+4. Ask before downloading or upgrading dependencies when that changes external state.
+
+## Compatibility Decisions
+
+- Preserve the current dependency for feature work unless the user requests an upgrade or the requested capability is unavailable.
+- Treat a pseudo-version as commit-specific. Do not substitute the nearest release without comparison.
+- When local `master` differs from the resolved module, compare signatures and behavior explicitly.
+- Prefer APIs already used by the target repository when both legacy and newer APIs exist.
+- Mark version-dependent advice in code comments or delivery notes when future maintenance could otherwise misread it.
+
+## Capability Maturity
+
+Use these labels:
+
+- `verified`: Confirmed by source plus a compiling or behavioral test for the selected version.
+- `experimental`: Present in source but incomplete, risky, or lacking sufficient behavioral verification.
+- `deprecated`: Explicitly deprecated by source or replaced by a preferred API.
+- `unsupported`: Stubbed, absent, or known not to work for the required scenario.
+
+Never convert `experimental` or `unsupported` into a working example without first proving it.

package/templates/skills/gorig-backend/references/sse.md

@@ -0,0 +1,121 @@
+# Server-Sent Events
+
+Use this reference when a task needs SSE streaming, event/error payloads, GET-only stream routes, disconnect handling, or message-to-SSE composition.
+
+Always inspect the target project's resolved Gorig source first. The examples below reflect the locally inspected Gorig `master` commit `35bbefb`.
+
+## Route Setup
+
+Use `github.com/jom-io/gorig/httpx/ssex`.
+
+```go
+func init() {
+    httpx.RegisterRouter(func(root *gin.RouterGroup) {
+        root.GET("/orders/events", ssex.Mid(), streamOrderEvents)
+    })
+}
+```
+
+`ssex.Mid()`:
+
+- allows only `GET`,
+- returns HTTP `405` JSON for non-GET requests,
+- sets `Content-Type: text/event-stream`,
+- sets `Cache-Control: no-cache`,
+- sets `Connection: keep-alive`,
+- sets `Access-Control-Allow-Origin: *`,
+- flushes headers before calling the handler.
+
+## Sending Events
+
+```go
+func streamOrderEvents(ctx *gin.Context) {
+    if err := ssex.SendOK(ctx, "ready", map[string]any{"ok": true}); err != nil {
+        return
+    }
+    if err := ssex.SendError(ctx, "warning", "temporary degraded state"); err != nil {
+        return
+    }
+}
+```
+
+The wire format is:
+
+```text
+event: ready
+data: {"status":"ok","data":{"ok":true}}
+```
+
+Error events use:
+
+```json
+{"status":"error","message":"temporary degraded state"}
+```
+
+`SendOK` and `SendError` return ordinary Go errors from JSON encoding or response writing. Treat a write error as a disconnect or broken stream and stop sending.
+
+## Long-Lived Streams
+
+For long-lived streams, block on either application events or request cancellation:
+
+```go
+func stream(ctx *gin.Context) {
+    ticker := time.NewTicker(30 * time.Second)
+    defer ticker.Stop()
+
+    for {
+        select {
+        case <-ctx.Request.Context().Done():
+            return
+        case <-ticker.C:
+            if err := ssex.SendOK(ctx, "heartbeat", map[string]any{"ts": time.Now().Unix()}); err != nil {
+                return
+            }
+        }
+    }
+}
+```
+
+Rules:
+
+- SSE endpoints must be `GET`.
+- Do not call `apix.HandleData` after starting an SSE stream.
+- Do not write unrelated JSON responses to the same stream.
+- Always watch `ctx.Request.Context().Done()`.
+- Keep per-connection goroutines bounded and unregister subscribers on disconnect.
+
+## Message to SSE Composition
+
+When the event source is `messagex`, register a subscriber for the connection and unregister it on exit:
+
+```go
+func streamOrderUpdates(ctx *gin.Context) {
+    broker := messagex.Ins(messagex.Local)
+    subID, err := broker.RegisterTopic("order.updated", func(msg *messagex.Message) *errors.Error {
+        if sendErr := ssex.SendOK(ctx, "order.updated", msg.Content); sendErr != nil {
+            return errors.Sys(sendErr.Error())
+        }
+        return nil
+    })
+    if err != nil {
+        _ = ssex.SendError(ctx, "order.updated", err.Error())
+        return
+    }
+    defer broker.UnRegisterTopic("order.updated", subID)
+
+    <-ctx.Request.Context().Done()
+}
+```
+
+This simple pattern is appropriate for low-volume same-process streams. For high fan-out, backpressure, or cross-process delivery, design a bounded stream loop and verify Redis-backed messaging behavior.
+
+## Verification Checklist
+
+- Compile against the target project's resolved Gorig version.
+- Verify GET responses include SSE headers.
+- Verify non-GET requests return HTTP 405 with the framework error JSON.
+- Verify `SendOK` writes the expected `event:` and JSON `status:"ok"` payload.
+- Verify `SendError` writes `status:"error"` and message payload.
+- Verify long-lived handlers exit on `ctx.Request.Context().Done()`.
+- Verify write errors or disconnects stop the loop and unregister any message subscribers.
+- For message-to-SSE, verify publish -> receive -> SSE event output and cleanup.

package/templates/skills/gorig-backend/references/testing.md

@@ -0,0 +1,171 @@
+# Testing and Effect Verification
+
+Prefer repository-specific commands from `AGENTS.md`, CI, or existing scripts. Otherwise use the checks below.
+
+## Standard Go Gates
+
+```sh
+go fmt ./...
+go vet ./...
+go build ./...
+go test ./... -v -race -cover
+```
+
+Narrow the test command while iterating, then run the full applicable suite before delivery.
+
+## Test Placement
+
+Prefer the project-level `test/` package for Gorig feature tests because it centralizes configuration, database setup, cache setup, and framework initialization. Add package-local tests only when the target project already follows that convention or the code under test has no Gorig initialization dependency.
+
+## Effect Verification
+
+Match verification to the delivered behavior:
+
+- Business scenario: verify the observable business outcome, not only the framework primitive.
+- Project bootstrap: start the binary, request `/ping`, then stop it gracefully.
+- HTTP API: exercise success, required-parameter, invalid-parameter, not-found, and service-error responses.
+- Database: verify migration/index creation plus read/write/update/delete and pagination.
+- Cache: verify miss, hit, expiry, invalidation, and concurrency behavior.
+- Cron: verify execution count, timeout, panic recovery, deduplication, and shutdown.
+- Messaging: verify publish/consume, ordering, retry, DLQ, unsubscribe, and cross-process behavior when Redis-backed.
+- SSE: verify event shape, error event, timeout, disconnect, and cleanup.
+- Authentication and security: verify valid, missing, malformed, expired, refreshed, revoked/logout, and forbidden tokens; verify user and trace context, CORS preflight, debounce behavior, exception paths, and secret hygiene.
+- Outbound HTTP: verify GET, form, JSON, XML, headers, context/header propagation, timeout, bad responses, malformed payloads, and image fetching against a local server.
+- Deployment: verify startup, health, business endpoint, graceful stop, and rollback in a disposable target.
+
+## External Infrastructure
+
+Use disposable containers or explicitly supplied development services for MySQL, MongoDB, and Redis integration checks. Do not silently target shared or production infrastructure.
+
+If required infrastructure is unavailable, keep the capability unverified and report the exact missing check.
+
+## Business Scenario Tests
+
+For ordinary user requests, write tests around the business behavior first, then prove the selected Gorig component supports it.
+
+Examples:
+
+- A "customer follow-up reminder" test should prove a customer without follow-up becomes pending follow-up after the delay, while a customer already followed up is not changed.
+- A "send notification after order paid" test should prove the order-paid event triggers exactly the intended subscribers and is safe to retry.
+- A "live progress page" test should prove the browser stream receives the expected event and subscriber cleanup happens on disconnect.
+- A "speed up customer detail" test should prove cache miss, hit, invalidation after update, and fallback when cache is unavailable.
+
+When the selected solution requires Redis, MySQL, MongoDB, or another external service, split tests into:
+
+- ordinary tests for business decision logic and framework error paths, and
+- integration tests for runtime delivery against disposable or explicitly supplied infrastructure.
+
+Do not claim the business feature is verified when only the ordinary tests ran and the required integration service was unavailable.
+
+## Advanced Data Access Tests
+
+For advanced `domainx/dx` work:
+
+- Ordinary compile and unit tests must cover query construction and service validation without external services when possible.
+- MySQL and MongoDB behavior must be proven with tagged or container-backed integration tests before it is claimed verified.
+- Verify optional filters with empty values and intentional zero values.
+- Verify sorting, projection, count, sum, existence checks, pagination, update/delete guards, migrations, and indexes.
+- Verify list/page implementations use database-backed filtering, sorting, and pagination. Do not accept tests that pass only because a small fixture was loaded into memory and sliced.
+- Verify direct-driver escape hatches and transactions only against the backend where they are used.
+- Record backend-specific differences and unsupported operations in delivery notes or module documentation.
+
+## Cache Tests
+
+For cache work:
+
+- Memory, JSON, and SQLite cache behavior should run locally without Redis or database services.
+- Verify miss, hit, expiry, delete, invalidation, counter, flush, and persistence when the backend is persistent.
+- Verify multi-level cache by testing L1 miss, lower-layer hit backfill, full miss loader, delete across layers, and concurrent same-key loading.
+- Redis behavior must run only with disposable or explicitly supplied Redis configuration.
+- State whether cache is an acceleration layer or a source of state. Do not use cache as source of truth unless loss, expiry, and cross-process behavior are acceptable and tested.
+
+## Generated Persistent CRUD Tests
+
+For CLI-generated persistent CRUD modules:
+
+- Keep validation tests in `test/<module>_test.go`; ordinary `go test ./...` must not require a database.
+- Keep real database tests behind backend-specific build tags in `test/<module>_integration_test.go`.
+- Initialize only the selected backend in `test/init_mysql_integration_test.go` or `test/init_mongo_integration_test.go`.
+- Synchronize non-secret connection skeletons into `test/_bin/local.yaml`. Gorig tests normally read this file because the package working directory is `test/`.
+- Run `go test -tags=integration,mysql ./test/... -v` or `go test -tags=integration,mongo ./test/... -v` after local connection values are available.
+
+Never claim database behavior is verified merely because a tagged integration test compiles.
+
+## Scheduled Task Tests
+
+For `cronx` work:
+
+- Prefer short deterministic schedules such as `@every 1s` in tests; keep the test bounded with channel waits or deadlines.
+- Verify duplicate registration with a stable named function and the same spec.
+- Verify timeout by asserting the handler observes `ctx.Done()`.
+- Verify panic recovery by proving a later task still runs or the wrapper returns without terminating the process.
+- Verify delay and once jobs run exactly once.
+- Call `cronx.Shutdown("CRON", context.Background())` at the end of the test.
+- Verify `AddEveryTask` registration returns promptly and the interval task executes when the target version includes commit `92c28b5` or an equivalent fix.
+- For persistent delay tasks, verify handler registration rejects anonymous functions, scheduling rejects unregistered handlers, and non-JSON payloads fail before enqueue.
+- Run persistent delay/once runtime tests only with disposable or explicitly supplied Redis. Assert payload delivery, timeout/failure behavior when relevant, task key cleanup, and worker shutdown.
+
+## Messaging Tests
+
+For `messagex` work:
+
+- Use unique topic names per test and always unregister subscribers.
+- Verify local publish/consume with typed getters because payload keys are lowercased.
+- Verify multiple subscribers each receive the same published message.
+- Verify sequential subscribers preserve publish order.
+- Verify retry and DLQ behavior with `RegisterTopicSeq`.
+- Verify unsubscribe by publishing after unregister and asserting no new delivery occurs.
+- Verify local `ReplayDLQ` returns the expected store-not-initialized error; verify replay behavior only with Redis configured.
+- Run Redis broker checks only against disposable or explicitly supplied Redis configuration.
+
+## SSE Tests
+
+For SSE work:
+
+- Use `httptest` for header and payload verification.
+- Verify GET streams return `Content-Type: text/event-stream`.
+- Verify non-GET requests return HTTP 405 and the framework JSON body.
+- Verify `SendOK` and `SendError` event shapes.
+- For long-lived streams, cancel the request context and assert the handler exits.
+- For message-to-SSE composition, verify subscriber cleanup on disconnect.
+
+## Authentication and Security Tests
+
+For auth/security work:
+
+- Build a minimal login -> protected route -> logout flow in tests or smoke routes.
+- Use `tokenx.Get(tokenx.Jwt, tokenx.Memory)` for simple local single-process auth tests. Use `tokenx.Get(tokenx.Jwt, tokenx.Redis)` and `httpx.SignRedis()` when the target version includes `mid/tokenx/redis.manager.go` or an equivalent Redis manager implementation and the business needs Redis-backed token state.
+- For Gorig `master` and releases containing `test/tokenx_redis_test.go`, run `go test ./test -run TestRedisTokenManager -v` when Redis is configured. If the test skips with `redis is not configured`, report the missing Redis configuration and rerun after Redis is provided; do not downgrade the capability to memory token unless the user accepts that behavior change.
+- Verify valid token success and that protected handlers read user id from `apix.GetUserID`, not from request input.
+- Verify missing header, malformed `Authorization`, expired JWT through `IsNotExpired`/`IsEffective`, destroyed token, refreshed old token, refreshed new token, and forbidden role/attribute. Also verify protected-route behavior for manager-expired or unrecorded tokens according to the resolved version.
+- Verify middleware writes user id into both gin context and request context, and trace context remains available.
+- Verify CORS `OPTIONS` response status, origin, credentials, and allowed headers.
+- Verify debounce returns HTTP 429 for repeated requests within the window and allows whitelisted paths.
+- Scan generated examples and fixtures for real-looking secrets, raw bearer tokens, production hosts, and passwords.
+
+## Outbound HTTP Tests
+
+For outbound client work:
+
+- Use `httptest.Server` or a controlled local server, not a real third-party API.
+- Assert query parameters for `Get`/`GetHeader`.
+- Assert form body and content type for `PostForm`.
+- Assert JSON body and response parsing for `PostJSONResp` or `PostJSON`.
+- Assert XML body and parse behavior; wrap `ParseXML` when malformed XML is expected.
+- Assert custom headers and intentional `Authorization` forwarding through context-aware helpers.
+- Exercise timeout using a slow handler and a bounded client/helper.
+- Exercise non-success status and malformed JSON/XML response behavior.
+- Exercise `FetchImage` only with a controlled local image response, and document size/content-type/host boundaries when user URLs are accepted.
+
+## Delivery Evidence
+
+Report:
+
+- Exact command.
+- Exit status.
+- Important output or assertion.
+- Environment and dependency version.
+- Skipped checks and reason.
+- Known limitations discovered during verification.
+
+"Tests passed" without commands and effect evidence is insufficient.

package/templates/skills/gorig-backend/scripts/check-source-links.sh

@@ -0,0 +1,48 @@
+#!/bin/sh
+set -eu
+
+skill_dir=$(CDPATH= cd -- "$(dirname "$0")/.." && pwd)
+online=${1:-}
+
+required_files="
+$skill_dir/SKILL.md
+$skill_dir/references/source-policy.md
+$skill_dir/references/onboarding-files.md
+$skill_dir/references/capability-matrix.md
+$skill_dir/references/framework-api.md
+$skill_dir/references/project-bootstrap.md
+$skill_dir/references/configuration.md
+$skill_dir/references/service-lifecycle.md
+$skill_dir/references/testing.md
+$skill_dir/references/source-map.md
+$skill_dir/assets/api-doc-template.md
+$skill_dir/assets/module-readme-template.md
+$skill_dir/scripts/detect-gorig-context.sh
+$skill_dir/scripts/verify-basic-project.sh
+"
+
+for file in $required_files; do
+  if [ ! -f "$file" ]; then
+    echo "missing=$file" >&2
+    exit 1
+  fi
+done
+
+echo "local_sources=ok"
+
+if [ "$online" != "--online" ]; then
+  echo "online_sources=skipped"
+  exit 0
+fi
+
+if ! command -v curl >/dev/null 2>&1; then
+  echo "error=curl is required for --online" >&2
+  exit 1
+fi
+
+urls=$(sed -n 's/.*`\(https:\/\/github\.com\/[^`]*\)`.*/\1/p' "$skill_dir/references/source-map.md")
+printf '%s\n' "$urls" | xargs -n 1 -P 4 sh -c '
+  url=$1
+  curl --fail --silent --show-error --location --range 0-0 --connect-timeout 10 --max-time 20 "$url" >/dev/null
+  echo "online_source=ok $url"
+' _

package/templates/skills/gorig-backend/scripts/detect-gorig-context.sh

@@ -0,0 +1,67 @@
+#!/bin/sh
+set -eu
+
+project_root=${1:-.}
+
+if [ ! -d "$project_root" ]; then
+  echo "error=project directory not found: $project_root" >&2
+  exit 1
+fi
+
+project_root=$(cd "$project_root" && pwd)
+go_mod="$project_root/go.mod"
+
+if [ ! -f "$go_mod" ]; then
+  printf 'project_root=%s\n' "$project_root"
+  echo "go_mod=missing"
+  exit 2
+fi
+
+module_name=$(awk '$1 == "module" { print $2; exit }' "$go_mod")
+go_version=$(awk '$1 == "go" { print $2; exit }' "$go_mod")
+gorig_version=$(awk '$1 == "github.com/jom-io/gorig" { print $2; exit }' "$go_mod")
+replace_target=$(awk '
+  $1 == "replace" && $2 == "github.com/jom-io/gorig" && $3 == "=>" { print $4; exit }
+  in_replace && $1 == "github.com/jom-io/gorig" && $2 == "=>" { print $3; exit }
+  $1 == "replace" && $2 == "(" { in_replace = 1; next }
+  in_replace && $1 == ")" { in_replace = 0 }
+' "$go_mod")
+
+source_kind=unresolved
+source_dir=
+
+case "$replace_target" in
+  ./*|../*|/*)
+    if [ "${replace_target#/}" != "$replace_target" ]; then
+      candidate=$replace_target
+    else
+      candidate="$project_root/$replace_target"
+    fi
+    if [ -d "$candidate" ]; then
+      source_kind=replace
+      source_dir=$(cd "$candidate" && pwd)
+    fi
+    ;;
+esac
+
+if [ -z "$source_dir" ] && [ -n "$gorig_version" ] && command -v go >/dev/null 2>&1; then
+  module_cache=$(cd "$project_root" && go env GOMODCACHE 2>/dev/null || true)
+  candidate="$module_cache/github.com/jom-io/gorig@$gorig_version"
+  if [ -d "$candidate" ]; then
+    source_kind=module_cache
+    source_dir=$candidate
+  fi
+fi
+
+if [ -z "$source_dir" ] && [ -d "$project_root/../gorig" ]; then
+  source_kind=sibling
+  source_dir=$(cd "$project_root/../gorig" && pwd)
+fi
+
+printf 'project_root=%s\n' "$project_root"
+printf 'module=%s\n' "${module_name:-unknown}"
+printf 'go_version=%s\n' "${go_version:-unknown}"
+printf 'gorig_version=%s\n' "${gorig_version:-not_required}"
+printf 'replace=%s\n' "${replace_target:-none}"
+printf 'source_kind=%s\n' "$source_kind"
+printf 'source_dir=%s\n' "${source_dir:-not_found}"

package/templates/skills/gorig-backend/scripts/verify-basic-project.sh

@@ -0,0 +1,108 @@
+#!/bin/sh
+set -eu
+
+project_root=${1:-.}
+mode=${2:-local}
+
+case "$mode" in
+  local|dev|prod) ;;
+  *)
+    echo "error=mode must be local, dev, or prod" >&2
+    exit 1
+    ;;
+esac
+
+project_root=$(cd "$project_root" && pwd)
+config="$project_root/_bin/$mode.yaml"
+
+if [ ! -f "$project_root/go.mod" ] || [ ! -f "$config" ]; then
+  echo "error=not a generated Gorig project or configuration missing" >&2
+  exit 1
+fi
+
+port=$(sed -n 's/^[[:space:]]*addr:[[:space:]]*":\([0-9][0-9]*\)"[[:space:]]*$/\1/p' "$config" | head -n 1)
+if [ -z "$port" ]; then
+  echo "error=unable to read api.rest.addr from $config" >&2
+  exit 1
+fi
+
+cache_root=${GOCACHE:-/tmp/gorig-skill-go-cache}
+binary="$project_root/.cache/verify-basic-project"
+log_file="$project_root/.cache/verify-basic-project-$mode.log"
+pid=
+
+cleanup() {
+  status=$?
+  if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
+    kill -INT "$pid" 2>/dev/null || true
+    wait "$pid" 2>/dev/null || true
+  fi
+  return "$status"
+}
+trap cleanup EXIT INT TERM
+
+mkdir -p "$project_root/.cache"
+
+unformatted=$(cd "$project_root" && gofmt -l .)
+if [ -n "$unformatted" ]; then
+  echo "error=unformatted Go files" >&2
+  echo "$unformatted" >&2
+  exit 1
+fi
+
+(cd "$project_root" && GOCACHE="$cache_root" go vet ./...)
+(cd "$project_root" && GOCACHE="$cache_root" go build -o "$binary" ./_cmd)
+(cd "$project_root" && GOCACHE="$cache_root" go test ./... -v)
+
+previous_dir=$(pwd)
+cd "$project_root"
+GORIG_SYS_MODE="$mode" "$binary" >"$log_file" 2>&1 &
+pid=$!
+cd "$previous_dir"
+
+base_url="http://127.0.0.1:$port"
+ready=false
+ping_response=
+attempt=0
+while [ "$attempt" -lt 40 ]; do
+  if ping_response=$(curl --fail --silent --max-time 2 "$base_url/ping" 2>/dev/null); then
+    ready=true
+    break
+  fi
+  if ! kill -0 "$pid" 2>/dev/null; then
+    echo "error=project exited before becoming ready" >&2
+    cat "$log_file" >&2
+    exit 1
+  fi
+  attempt=$((attempt + 1))
+  sleep 0.25
+done
+
+if [ "$ready" != true ]; then
+  echo "error=project did not become ready on $base_url" >&2
+  cat "$log_file" >&2
+  exit 1
+fi
+
+hello_response=$(curl --fail --silent --max-time 5 "$base_url/hello?name=Gorig")
+
+echo "$ping_response" | grep '"code":200' > /dev/null
+echo "$hello_response" | grep '"code":200' > /dev/null
+echo "$hello_response" | grep "\"mode\":\"$mode\"" > /dev/null
+echo "$hello_response" | grep '"message":"hello Gorig"' > /dev/null
+
+kill -INT "$pid"
+if ! wait "$pid"; then
+  echo "error=project did not shut down cleanly" >&2
+  cat "$log_file" >&2
+  exit 1
+fi
+pid=
+
+grep 'Shutting down the system \[OK\]' "$log_file" > /dev/null
+
+echo "mode=$mode"
+echo "base_url=$base_url"
+echo "ping=$ping_response"
+echo "hello=$hello_response"
+echo "graceful_shutdown=ok"