geet-geet 0.1.0

package/lib/session.sh

@@ -0,0 +1,111 @@
+# session.sh — run commands in isolated template snapshot
+# Usage:
+#   source session.sh
+#   session run [options] -- <command...>
+
+session() {
+
+# digest-and-locate.sh provides: APP_DIR, TEMPLATE_DIR, TEMPLATE_NAME, GEET_LIB, GEET_ALIAS, die, log
+
+usage() {
+  cat <<EOF
+$GEET_ALIAS session — run commands in isolated template snapshot
+
+This creates a temporary isolated copy of just the template files,
+runs your command there, and optionally copies results back.
+
+Usage:
+  $GEET_ALIAS session run [options] -- <command...>
+
+Options:
+  --mode tracked|all      split mode (default: tracked)
+  --tmp <dir>             use a specific temp dir (default: mktemp)
+  --keep                  do not delete temp dir after command
+  --copy-back A:B         copy tmp/A back to repo/B after command
+                           (repeatable)
+
+Use cases:
+  - Build template in isolation (avoid polluting app with artifacts)
+  - Test template without app-specific code interfering
+  - Generate files that should live only in the template
+
+Examples:
+  $GEET_ALIAS session run -- npm run build
+  $GEET_ALIAS session run --mode all -- npm test
+  $GEET_ALIAS session run --copy-back dist:dist -- npm run build
+  $GEET_ALIAS session run --keep -- npm run build
+EOF
+}
+
+sub="${1:-help}"; shift || true
+if [[ "$sub" == "help" || "$sub" == "-h" || "$sub" == "--help" ]]; then
+  usage
+  return 0
+fi
+[[ "$sub" == "run" ]] || { usage; return 1; }
+
+mode="tracked"
+tmp=""
+keep=0
+declare -a copy_back=()
+
+# Parse args until "--"
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --mode) mode="${2:-}"; shift 2 ;;
+    --tmp) tmp="${2:-}"; shift 2 ;;
+    --keep) keep=1; shift ;;
+    --copy-back) copy_back+=("${2:-}"); shift 2 ;;
+    --) shift; break ;;
+    -h|--help) usage; return 0 ;;
+    *) die "unknown option: $1 (use --help)" ;;
+  esac
+done
+
+[[ $# -gt 0 ]] || die "missing command (use -- <command...>)"
+
+# Decide temp dir
+if [[ -z "$tmp" ]]; then
+  tmp="$(mktemp -d -t "${TEMPLATE_NAME}-session-XXXXXX")"
+fi
+
+cleanup() {
+  if [[ "$keep" -eq 1 ]]; then
+    log "keeping temp dir: $tmp"
+    return 0
+  fi
+  rm -rf "$tmp"
+}
+trap cleanup EXIT
+
+log "splitting ($mode) to: $tmp"
+# Call split function from split.sh
+source "$GEET_LIB/split.sh"
+split "$tmp" "$mode"
+
+log "running in temp dir: $*"
+(
+  cd "$tmp"
+  "$@"
+)
+
+# Copy-back steps (optional)
+for spec in "${copy_back[@]}"; do
+  src="${spec%%:*}"
+  dst="${spec#*:}"
+  [[ -n "$src" && -n "$dst" ]] || die "--copy-back expects A:B, got: $spec"
+
+  if [[ ! -e "$tmp/$src" ]]; then
+    log "copy-back skipped (missing in temp): $src"
+    continue
+  fi
+
+  log "copying back: $src -> $dst"
+  rm -rf "$APP_DIR/$dst"
+  mkdir -p "$(dirname "$APP_DIR/$dst")"
+  cp -a "$tmp/$src" "$APP_DIR/$dst"
+done
+
+log "done"
+
+}  # end of session()

package/lib/split.sh

@@ -0,0 +1,120 @@
+# split.sh — export template files to external folder
+# Usage:
+#   source split.sh
+#   split <dest_dir> [tracked|all]
+
+split() {
+
+# digest-and-locate.sh provides: APP_DIR, TEMPLATE_DIR, DOTGIT, TEMPLATE_NAME,
+# TEMPLATE_GEETEXCLUDE, GEET_LIB, GEET_ALIAS, die, log
+
+usage() {
+  cat <<EOF
+$GEET_ALIAS split — export template files to external folder
+
+This creates a clean snapshot of your template files in a separate directory.
+Useful for inspecting, zipping, publishing, or comparing what's included.
+
+Usage:
+  $GEET_ALIAS split <dest_dir> [tracked|all]
+
+Modes:
+  tracked  Export only files tracked by template repo (default)
+  all      Export all files included by whitelist (may include untracked)
+
+Examples:
+  $GEET_ALIAS split /tmp/${TEMPLATE_NAME}-export
+  $GEET_ALIAS split ../exports/${TEMPLATE_NAME} all
+  $GEET_ALIAS split --help
+
+Safety:
+  - Destination directory must NOT exist (prevents accidental overwrites)
+  - This does NOT change git history, only copies files
+  - Creates .layer-export-manifest.txt for auditing
+
+Requirements:
+  - Layer must be initialized (dot-git exists)
+  - Whitelist must be compiled (.geetexclude exists)
+EOF
+}
+
+# Handle help
+if [[ "${1:-}" == "help" || "${1:-}" == "-h" || "${1:-}" == "--help" ]]; then
+  usage
+  return 0
+fi
+
+dest="${1:-}"
+mode="${2:-tracked}"
+
+[[ -n "$dest" ]] || { usage; return 1; }
+
+# Precondition checks
+[[ -d "$DOTGIT" && -f "$DOTGIT/HEAD" ]] || die "layer not initialized (run: $GEET_ALIAS init)"
+[[ -f "$TEMPLATE_DIR/.geetexclude" ]] || die "missing compiled exclude. Run: $GEET_ALIAS sync"
+
+# Safety: refuse to export into an existing directory to avoid accidental overwrites.
+if [[ -e "$dest" ]]; then
+  die "destination already exists: $dest"
+fi
+
+# Build file list
+tmp_list="$(mktemp)"
+cleanup() { rm -f "$tmp_list"; }
+trap cleanup EXIT
+
+case "$mode" in
+  tracked)
+    # Export what the template repo actually tracks
+    git --git-dir="$DOTGIT" --work-tree="$APP_DIR" ls-files > "$tmp_list"
+    ;;
+  all)
+    # Export anything the whitelist includes (even if untracked)
+    source "$GEET_LIB/tree.sh"
+    tree list all > "$tmp_list"
+    ;;
+  *)
+    die "unknown mode: $mode (use tracked|all)"
+    ;;
+esac
+
+# Ensure there is something to export
+if ! grep -q . "$tmp_list"; then
+  die "nothing to export in mode '$mode' (is your whitelist empty?)"
+fi
+
+log "exporting layer '$TEMPLATE_NAME' ($mode) to: $dest"
+mkdir -p "$dest"
+
+# Copy files preserving paths.
+# We use tar because it is:
+# - fast
+# - preserves directories
+# - handles lots of files well
+#
+# This avoids rsync dependency and avoids writing a bunch of mkdir/cp loops.
+(
+  cd "$APP_DIR"
+  # Use null delimiters to safely handle weird filenames
+  # Convert line-delimited list to null-delimited for tar
+  while IFS= read -r line; do
+    # Skip empty lines
+    [[ -n "$line" ]] && printf '%s\0' "$line"
+  done < "$tmp_list" | tar -cpf - --null -T - | (cd "$dest" && tar -xpf -)
+)
+
+# Write a small manifest for auditing
+{
+  echo "layer: $TEMPLATE_NAME"
+  echo "mode: $mode"
+  echo "source_root: $APP_DIR"
+  echo "exported_at: $(date -Is 2>/dev/null || date)"
+  echo
+  echo "files:"
+  cat "$tmp_list"
+} > "$dest/.layer-export-manifest.txt"
+
+log "done"
+log "wrote manifest: $dest/.layer-export-manifest.txt"
+
+}  # end of split()

package/lib/sync.sh

@@ -0,0 +1,98 @@
+sync() {
+  debug "running sync"
+  # Show help if requested
+  if [[ "${1:-}" == "help" || "${1:-}" == "-h" || "${1:-}" == "--help" ]]; then
+    cat <<EOF
+$GEET_ALIAS sync — compile .geetinclude whitelist into .geetexclude
+
+This command processes your .geetinclude file (whitelist) and compiles it
+into .geetexclude (gitignore-style format) between special markers.
+
+What it does:
+  1. Reads each line from .geetinclude
+  2. Converts whitelist patterns to gitignore format:
+     - 'foo' → '!foo' (include this)
+     - '!foo' → 'foo' (exclude this - removes the !)
+     - '!!foo' → '!foo' (literal ! prefix)
+  3. Inserts compiled rules between GEETINCLUDESTART and GEETINCLUDEEND markers
+  4. Preserves manual rules before/after the markers
+
+Usage:
+  $GEET_ALIAS sync
+
+When to run:
+  - After editing .geetinclude
+  - Before running git commands on the template
+  - Note: Most geet commands auto-sync, so manual sync is rarely needed
+
+File locations:
+  Source:   $TEMPLATE_DIR/.geetinclude
+  Output:   $TEMPLATE_DIR/.geetexclude
+
+Examples:
+  $GEET_ALIAS sync  # Compile whitelist rules
+EOF
+    return 0
+  fi
+
+  [[ -f "$TEMPLATE_DIR/.geetinclude" ]] || return 0
+
+  # Markers for the auto-populated section
+  local START_MARKER="# GEETINCLUDESTART"
+  local END_MARKER="# GEETINCLUDEEND"
+
+  # Generate compiled rules
+  local compiled_rules=""
+  # WHITELIST MODE: Process .geetinclude
+  while IFS= read -r line || [[ -n "$line" ]]; do
+    line="${line#"${line%%[![:space:]]*}"}"
+    line="${line%"${line##*[![:space:]]}"}"
+
+    [[ -z "$line" ]] && continue
+    [[ "$line" == \#* ]] && continue
+
+    if [[ "$line" == "!!"* ]]; then
+      compiled_rules+="!${line#!!}"$'\n'
+    elif [[ "$line" == "!"* ]]; then
+      compiled_rules+="${line#!}"$'\n'
+    else
+      compiled_rules+="!$line"$'\n'
+    fi
+  done < "$TEMPLATE_DIR/.geetinclude"
+
+  # Read existing .geetexclude or create default structure
+  local before_marker=""
+  local after_marker=""
+
+  if [[ -f "$TEMPLATE_DIR/.geetexclude" ]]; then
+    # File exists - extract parts before and after markers
+    local in_marker=0
+    while IFS= read -r line; do
+      if [[ "$line" == "$START_MARKER" ]]; then
+        in_marker=1
+        continue
+      elif [[ "$line" == "$END_MARKER" ]]; then
+        in_marker=2
+        continue
+      fi
+
+      if [[ $in_marker -eq 0 ]]; then
+        before_marker+="$line"$'\n'
+      elif [[ $in_marker -eq 2 ]]; then
+        after_marker+="$line"$'\n'
+      fi
+    done < "$TEMPLATE_DIR/.geetexclude"
+  else
+    die "$TEMPLATE_DIR/.geetexclude not found"
+  fi
+
+  # Write new .geetexclude with compiled rules between markers
+  {
+    printf "%s" "$before_marker"
+    echo "$START_MARKER"
+    echo "# Autopopulated from .geetinclude, do not modify"
+    printf "%s" "$compiled_rules"
+    echo "$END_MARKER"
+    printf "%s" "$after_marker"
+  } > "$TEMPLATE_DIR/.geetexclude"
+}