@jskit-ai/create-app 0.1.47 → 0.1.49

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/create-app",
-  "version": "0.1.47",
+  "version": "0.1.49",
   "description": "Scaffold minimal JSKIT app shells.",
   "type": "module",
   "files": [

package/templates/base-shell/AGENTS.md

@@ -1,12 +1,10 @@
 # App Agent Wrapper
 
-Primary instructions live in:
+Read and follow:
 
-- `node_modules/@jskit-ai/agent-docs/DISTR_AGENT.md`
+- `node_modules/@jskit-ai/agent-docs/templates/app/AGENTS.md`
 
-Read that file first and follow the workflow docs it references before planning, scaffolding, or editing code.
-
-Fallback if the package is not installed yet:
+If that file does not exist yet:
 
 - install dependencies so `node_modules/@jskit-ai/agent-docs/` exists
 - inspect the workspace before assuming a JSKIT app already exists

package/templates/base-shell/gitignore

@@ -2,6 +2,7 @@ node_modules/
 dist/
 coverage/
 test-results/
+.jskit/WORKBOARD.md
 .env
 .env.*
 !.env.example

package/templates/base-shell/package.json

@@ -12,7 +12,7 @@
     "server:all": "node ./bin/server.js",
     "server:home": "SERVER_SURFACE=home node ./bin/server.js",
     "start": "node ./bin/server.js",
-    "devlinks": "bash ./scripts/link-local-jskit-packages.sh",
+    "devlinks": "jskit app link-local-packages",
     "dev": "vite",
     "dev:all": "vite",
     "dev:home": "VITE_SURFACE=home vite",
@@ -23,9 +23,9 @@
     "lint": "eslint .",
     "test": "node --test",
     "test:client": "vitest run tests/client",
-    "verify": "npm run lint && npm run test && npm run test:client && npm run build && npx jskit doctor",
-    "release": "bash ./scripts/release.sh",
-    "jskit:update": "bash ./scripts/update-jskit-packages.sh"
+    "verify": "jskit app verify && npm run --if-present verify:app",
+    "release": "jskit app release",
+    "jskit:update": "jskit app update-packages"
   },
   "dependencies": {
     "@local/main": "file:packages/main",

package/templates/base-shell/scripts/link-local-jskit-packages.sh

@@ -1,206 +0,0 @@
-#!/usr/bin/env bash
-# Link all local @jskit-ai packages from a jskit-ai monorepo checkout into node_modules.
-# Run this AFTER `npm install` when you want live local development without publishing packages.
-#
-# Usage:
-#   npm run link:local:jskit
-#   JSKIT_REPO_ROOT=/abs/path/to/jskit-ai npm run link:local:jskit
-set -euo pipefail
-
-APP_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-SCOPE_DIR="$APP_ROOT/node_modules/@jskit-ai"
-VITE_CACHE_DIR="$APP_ROOT/node_modules/.vite"
-
-is_valid_jskit_repo_root() {
-  local candidate_root="$1"
-  [[ -d "$candidate_root/packages" && -d "$candidate_root/packages/kernel" && -d "$candidate_root/tooling" ]]
-}
-
-to_absolute_dir() {
-  local candidate_dir="$1"
-  (cd "$candidate_dir" && pwd)
-}
-
-resolve_local_repo_root() {
-  if [[ -n "${JSKIT_REPO_ROOT:-}" ]]; then
-    if [[ -d "$JSKIT_REPO_ROOT" ]]; then
-      to_absolute_dir "$JSKIT_REPO_ROOT"
-      return 0
-    fi
-    echo "$JSKIT_REPO_ROOT"
-    return 0
-  fi
-
-  local current_dir
-  current_dir="$(dirname "$APP_ROOT")"
-  while true; do
-    local candidate_root="$current_dir/jskit-ai"
-    if is_valid_jskit_repo_root "$candidate_root"; then
-      to_absolute_dir "$candidate_root"
-      return 0
-    fi
-    if [[ "$current_dir" == "/" ]]; then
-      return 1
-    fi
-    current_dir="$(dirname "$current_dir")"
-  done
-}
-
-JSKIT_REPO_ROOT="$(resolve_local_repo_root || true)"
-
-if [[ ! -d "$SCOPE_DIR" ]]; then
-  echo "[link-local] @jskit-ai scope not found at $SCOPE_DIR (run npm install first)." >&2
-  exit 1
-fi
-
-if [[ -z "$JSKIT_REPO_ROOT" ]]; then
-  echo "[link-local] no JSKIT repository found." >&2
-  echo "[link-local] set JSKIT_REPO_ROOT to a local jskit-ai checkout path." >&2
-  exit 1
-fi
-
-if ! is_valid_jskit_repo_root "$JSKIT_REPO_ROOT"; then
-  echo "[link-local] JSKIT_REPO_ROOT is not a valid jskit-ai checkout: $JSKIT_REPO_ROOT" >&2
-  exit 1
-fi
-
-discover_local_package_map() {
-  node - "$JSKIT_REPO_ROOT" <<'NODE'
-const fs = require("node:fs");
-const path = require("node:path");
-
-const repoRoot = process.argv[2];
-const parentDirectories = [
-  path.join(repoRoot, "packages"),
-  path.join(repoRoot, "tooling")
-];
-const packageMap = new Map();
-
-for (const parentDirectory of parentDirectories) {
-  if (!fs.existsSync(parentDirectory) || !fs.statSync(parentDirectory).isDirectory()) {
-    continue;
-  }
-
-  for (const entry of fs.readdirSync(parentDirectory, { withFileTypes: true })) {
-    if (!entry.isDirectory() || entry.name.startsWith(".")) {
-      continue;
-    }
-
-    const packageRoot = path.join(parentDirectory, entry.name);
-    const packageJsonPath = path.join(packageRoot, "package.json");
-    if (!fs.existsSync(packageJsonPath)) {
-      continue;
-    }
-
-    let packageJson = {};
-    try {
-      packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
-    } catch {
-      continue;
-    }
-
-    const packageId = String(packageJson?.name || "").trim();
-    if (!packageId.startsWith("@jskit-ai/")) {
-      continue;
-    }
-    const packageDirName = packageId.slice("@jskit-ai/".length);
-    if (!packageDirName || packageDirName.includes("/")) {
-      continue;
-    }
-
-    if (!packageMap.has(packageDirName)) {
-      packageMap.set(packageDirName, packageRoot);
-    }
-  }
-}
-
-for (const [packageDirName, packageRoot] of packageMap.entries()) {
-  process.stdout.write(`${packageDirName}\t${packageRoot}\n`);
-}
-NODE
-}
-
-link_package_bin_entries() {
-  local package_dir_name="$1"
-  local source_dir="$2"
-
-  node - "$APP_ROOT" "$package_dir_name" "$source_dir" <<'NODE'
-const fs = require("node:fs");
-const path = require("node:path");
-
-const appRoot = process.argv[2];
-const packageDirName = process.argv[3];
-const sourceDir = process.argv[4];
-
-const packageJsonPath = path.join(sourceDir, "package.json");
-if (!fs.existsSync(packageJsonPath)) {
-  process.exit(0);
-}
-
-let packageJson = {};
-try {
-  packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
-} catch {
-  process.exit(0);
-}
-
-const rawBin = packageJson?.bin;
-let binEntries = [];
-if (typeof rawBin === "string") {
-  binEntries = [[packageDirName, rawBin]];
-} else if (rawBin && typeof rawBin === "object" && !Array.isArray(rawBin)) {
-  binEntries = Object.entries(rawBin);
-}
-
-if (binEntries.length < 1) {
-  process.exit(0);
-}
-
-const binDir = path.join(appRoot, "node_modules", ".bin");
-const packageRoot = path.join(appRoot, "node_modules", "@jskit-ai", packageDirName);
-fs.mkdirSync(binDir, { recursive: true });
-
-for (const [rawBinName, rawBinTarget] of binEntries) {
-  const binName = String(rawBinName || "").trim();
-  const binTarget = String(rawBinTarget || "").trim();
-  if (!binName || !binTarget) {
-    continue;
-  }
-
-  const absoluteTarget = path.join(packageRoot, binTarget);
-  if (!fs.existsSync(absoluteTarget)) {
-    continue;
-  }
-
-  const binPath = path.join(binDir, binName);
-  fs.rmSync(binPath, { force: true, recursive: true });
-
-  const relativeTarget = path.relative(binDir, absoluteTarget) || absoluteTarget;
-  fs.symlinkSync(relativeTarget, binPath);
-  process.stdout.write(`[link-local] linked bin ${binName} -> ${relativeTarget}\n`);
-}
-NODE
-}
-
-linked_count=0
-
-mkdir -p "$SCOPE_DIR"
-while IFS=$'\t' read -r package_dir_name source_dir; do
-  if [[ -z "$package_dir_name" || -z "$source_dir" ]]; then
-    continue
-  fi
-
-  target_path="$SCOPE_DIR/$package_dir_name"
-  rm -rf "$target_path"
-  ln -s "$source_dir" "$target_path"
-  echo "[link-local] linked @jskit-ai/$package_dir_name -> $source_dir"
-  link_package_bin_entries "$package_dir_name" "$source_dir"
-  linked_count=$((linked_count + 1))
-done < <(discover_local_package_map)
-
-if [[ -d "$VITE_CACHE_DIR" ]]; then
-  rm -rf "$VITE_CACHE_DIR"
-  echo "[link-local] cleared Vite cache at $VITE_CACHE_DIR"
-fi
-
-echo "[link-local] done. linked=$linked_count"

package/templates/base-shell/scripts/release.sh

@@ -1,95 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-APP_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-
-require_command() {
-  local name="$1"
-  if ! command -v "$name" >/dev/null 2>&1; then
-    echo "[release] required command not found: $name" >&2
-    exit 1
-  fi
-}
-
-ensure_clean_worktree() {
-  if [[ -n "$(git status --porcelain)" ]]; then
-    echo "[release] worktree is not clean. Commit/stash first." >&2
-    exit 1
-  fi
-}
-
-ensure_on_main() {
-  local current_branch
-  current_branch="$(git rev-parse --abbrev-ref HEAD)"
-  if [[ "$current_branch" != "main" ]]; then
-    echo "[release] current branch is \"$current_branch\". Switch to main first." >&2
-    exit 1
-  fi
-}
-
-main() {
-  require_command git
-  require_command npm
-  require_command gh
-
-  cd "$APP_ROOT"
-
-  if ! gh auth status >/dev/null 2>&1; then
-    echo "[release] gh is not authenticated. Run: gh auth login" >&2
-    exit 1
-  fi
-
-  ensure_clean_worktree
-  ensure_on_main
-
-  echo "[release] syncing local main..."
-  git fetch origin main
-  git pull --ff-only origin main
-
-  echo "[release] running package refresh..."
-  npm run jskit:update
-
-  if [[ -z "$(git status --porcelain)" ]]; then
-    echo "[release] no changes produced by jskit:update. Nothing to release."
-    exit 0
-  fi
-
-  local timestamp
-  local pretty_time
-  local branch
-  local commit_message
-  local pr_title
-  local pr_url
-
-  timestamp="$(date -u +%Y%m%d-%H%M%S)"
-  pretty_time="$(date -u +'%Y-%m-%d %H:%M UTC')"
-  branch="release/${timestamp}"
-  commit_message="chore: release ${pretty_time}"
-  pr_title="Release ${pretty_time}"
-
-  echo "[release] creating branch ${branch}..."
-  git checkout -b "$branch"
-
-  git add -A
-  git commit -m "$commit_message"
-  git push -u origin "$branch"
-
-  pr_url="$(
-    gh pr create \
-      --base main \
-      --head "$branch" \
-      --title "$pr_title" \
-      --body "Automated release commit generated by \`npm run release\`."
-  )"
-
-  echo "[release] created PR: $pr_url"
-  gh pr merge "$pr_url" --merge --delete-branch
-
-  echo "[release] merged. syncing local main..."
-  git checkout main
-  git pull --ff-only origin main
-
-  echo "[release] done."
-}
-
-main "$@"

package/templates/base-shell/scripts/update-jskit-packages.sh

@@ -1,120 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-APP_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-PACKAGE_JSON_PATH="$APP_ROOT/package.json"
-JSKIT_REGISTRY="${JSKIT_REGISTRY:-}"
-NPM_DRY_RUN="${npm_config_dry_run:-}"
-
-dry_run_enabled=false
-normalized_npm_dry_run="$(printf "%s" "$NPM_DRY_RUN" | tr '[:upper:]' '[:lower:]')"
-if [[ "$normalized_npm_dry_run" == "1" || "$normalized_npm_dry_run" == "true" ]]; then
-  dry_run_enabled=true
-fi
-
-for arg in "$@"; do
-  if [[ "$arg" == "--dry-run" ]]; then
-    dry_run_enabled=true
-  elif [[ "$arg" == "--no-dry-run" ]]; then
-    dry_run_enabled=false
-  fi
-done
-
-install_args=()
-if [[ "$dry_run_enabled" == "true" ]]; then
-  install_args+=(--dry-run)
-  echo "[jskit:update] dry-run mode enabled."
-fi
-
-if [[ ! -f "$PACKAGE_JSON_PATH" ]]; then
-  echo "[jskit:update] package.json not found: $PACKAGE_JSON_PATH" >&2
-  exit 1
-fi
-
-readarray -t runtime_packages < <(
-  node -e '
-    const fs = require("node:fs");
-    const packageJson = JSON.parse(fs.readFileSync(process.argv[1], "utf8"));
-    const dependencies = packageJson?.dependencies || {};
-    const names = Object.keys(dependencies).filter((name) => name.startsWith("@jskit-ai/")).sort();
-    for (const name of names) {
-      process.stdout.write(`${name}\n`);
-    }
-  ' "$PACKAGE_JSON_PATH"
-)
-
-readarray -t dev_packages < <(
-  node -e '
-    const fs = require("node:fs");
-    const packageJson = JSON.parse(fs.readFileSync(process.argv[1], "utf8"));
-    const dependencies = packageJson?.devDependencies || {};
-    const names = Object.keys(dependencies).filter((name) => name.startsWith("@jskit-ai/")).sort();
-    for (const name of names) {
-      process.stdout.write(`${name}\n`);
-    }
-  ' "$PACKAGE_JSON_PATH"
-)
-
-registry_args=()
-if [[ -n "$JSKIT_REGISTRY" ]]; then
-  registry_args+=(--registry "$JSKIT_REGISTRY")
-fi
-
-if (( ${#runtime_packages[@]} == 0 && ${#dev_packages[@]} == 0 )); then
-  echo "[jskit:update] no @jskit-ai packages found in dependencies."
-  exit 0
-fi
-
-resolve_major_range() {
-  local package_name="$1"
-  local latest_version
-  if ! latest_version="$(npm view "${registry_args[@]}" "$package_name" version)"; then
-    echo "[jskit:update] failed to resolve latest version for $package_name." >&2
-    exit 1
-  fi
-  latest_version="$(printf "%s" "$latest_version" | tr -d '[:space:]')"
-
-  if [[ ! "$latest_version" =~ ^([0-9]+)\.[0-9]+\.[0-9]+([.+-][0-9A-Za-z.-]+)?$ ]]; then
-    echo "[jskit:update] invalid latest version for $package_name: $latest_version" >&2
-    exit 1
-  fi
-
-  local major="${BASH_REMATCH[1]}"
-  printf "%s.x" "$major"
-}
-
-runtime_specs=()
-for package_name in "${runtime_packages[@]}"; do
-  runtime_specs+=("${package_name}@$(resolve_major_range "$package_name")")
-done
-
-dev_specs=()
-for package_name in "${dev_packages[@]}"; do
-  dev_specs+=("${package_name}@$(resolve_major_range "$package_name")")
-done
-
-if (( ${#runtime_specs[@]} > 0 )); then
-  echo "[jskit:update] updating runtime packages: ${runtime_specs[*]}"
-  (
-    cd "$APP_ROOT"
-    npm install --save-exact "${registry_args[@]}" "${install_args[@]}" "${runtime_specs[@]}"
-  )
-fi
-
-if (( ${#dev_specs[@]} > 0 )); then
-  echo "[jskit:update] updating dev packages: ${dev_specs[*]}"
-  (
-    cd "$APP_ROOT"
-    npm install --save-dev --save-exact "${registry_args[@]}" "${install_args[@]}" "${dev_specs[@]}"
-  )
-fi
-
-if [[ "$dry_run_enabled" != "true" ]]; then
-  echo "[jskit:update] generating managed migrations for changed packages."
-  (
-    cd "$APP_ROOT"
-    npx jskit migrations changed
-  )
-fi
-
-echo "[jskit:update] done."