geet-geet 0.1.0

package/lib/git.sh

@@ -0,0 +1,55 @@
+# git.sh — template git operations
+# Usage:
+#   source git.sh
+#   (exposed functions are used via geet.sh command dispatcher)
+#
+# Provides git wrapper functions for template repo operations
+
+
+
+# Helper: sync .geetinclude to .geetexclude
+sync_exclude() {
+  source "$GEET_LIB/sync.sh"
+  sync
+}
+
+# Helper: check if template git repo exists
+need_dotgit() {
+  [[ -d "$DOTGIT" && -f "$DOTGIT/HEAD" ]] || die "missing $DOTGIT (run: $GEET_ALIAS init)"
+}
+
+# Helper: block dangerous git commands
+block_footguns() {
+  case "${1-}" in
+    clean|reset|checkout|restore|rm)
+      brave_guard "git $1" "git $1 can be destructive and mess with your app's working directory"
+    ;;
+  esac
+}
+
+###############################################################################
+# CLONE - Simple git clone without init
+###############################################################################
+# Just clones a repository without running any post-install logic
+call_cmd() {
+  if [[ -z "$TEMPLATE_DIR" ]]; then
+    critical "We could not find your template repo anywhere in this project!"
+    warn "Are you sure you are somewhere inside a project which has a template repo?"
+    warn "The template repo is a hidden folder at the root of your working directory which contains a .geethier file inside it"
+    warn "To debug our search, run \`$GEET_ALIAS status --verbose --filter LOCATE\`"
+    warn "If you think we made a mistake, review the code at $GEET_LIB/digest-and-locate.sh detect_template_dir_from_cwd"
+    exit 1
+  fi
+  need_dotgit
+  sync_exclude
+  block_footguns "$@"
+  if [[ "$1" == "push" ]] && ! [[ "$(geet_git remote -v)" ]]; then
+      log "It looks like you have no remote setup yet. Would you like to publish on github?"
+      log "Just run \`$GEET_ALIAS pub\` to publish as a public repo or \`$GEET_ALIAS publish --private\`"
+      exit 1
+  fi
+  geet_git "$@"
+#  if [[ "$1" == "status" ]]; then
+#    log "Don't Panic! it is expected to see README.md and .gitignore show up as deleted, don't worry. read docs/AUTO_PROMOTE.md to understand why"
+#  fi
+}

package/lib/help.sh

@@ -0,0 +1,53 @@
+# help.sh — display overview of all geet commands
+# Usage:
+#   source help.sh
+#   help
+
+help() {
+
+# digest-and-locate.sh provides: GEET_ALIAS, TEMPLATE_NAME, die, log
+
+cat <<EOF
+$GEET_ALIAS — Git-based template layering system
+
+Usage: $GEET_ALIAS <command> [args...]
+
+TEMPLATE MANAGEMENT:
+  template <name> [desc]    Create a new template layer from current app
+  init                      Initialize a freshly-cloned template repo as your app
+  install <repo>            Clone a template repo and initialize it (clone + init)
+  clone <repo>              Clone a git repository (standard git clone)
+
+FILE MANAGEMENT:
+  tree [list|tracked|all]   Show what files the template includes
+  split <dest> [mode]       Export template files to external folder
+  sync                      Compile .geetinclude whitelist into .geetexclude
+  detach                    "Detach" a file, folder, or glob to always use "keep-ours" to resolve merge conflicts, essentially allowing you to overwrite a file's template
+  retach                    undo a detach command
+  detached                  list files that have been detached
+
+OPERATIONS:
+  session run [opts] -- cmd Run command in isolated template snapshot
+  publish [opts]            Publish template to GitHub (auto-detects repo name)
+  gh <subcommand> [...]     GitHub CLI integration (pr, issue, etc.)
+  doctor                    Run health checks on your geet setup
+
+GIT ACCESS:
+  git <command> [...]       Direct git access to template repo
+  <git-command> [...]       Any git command (auto-forwarded to template repo)
+
+Get help on any command:
+  $GEET_ALIAS <command> --help
+
+Examples:
+  $GEET_ALIAS template my-stack "A modern web stack"
+  $GEET_ALIAS install https://github.com/user/template-repo
+  $GEET_ALIAS tree list
+  $GEET_ALIAS publish --public
+  $GEET_ALIAS status
+  $GEET_ALIAS commit -m "Update template"
+
+Current layer: ${TEMPLATE_NAME:-none}
+EOF
+
+}  # end of help()

package/lib/ignored.sh

@@ -0,0 +1,4 @@
+is_ignored(){
+  r="$(geet_git check-ignore -q -- "$1"  && echo ignored || echo included)"
+  printf '%s' "$r"
+}

package/lib/include.sh

@@ -0,0 +1,54 @@
+# git.sh — template git operations
+# Usage:
+#   source git.sh
+#   (exposed functions are used via geet.sh command dispatcher)
+#
+# Provides git wrapper functions for template repo operations
+
+
+
+# Helper: sync .geetinclude to .geetexclude
+sync_exclude() {
+  source "$GEET_LIB/sync.sh"
+  sync
+}
+
+# Helper: check if template git repo exists
+need_dotgit() {
+  [[ -d "$DOTGIT" && -f "$DOTGIT/HEAD" ]] || die "missing $DOTGIT (run: $GEET_ALIAS init)"
+}
+
+
+###############################################################################
+# CLONE - Simple git clone without init
+###############################################################################
+# Just clones a repository without running any post-install logic
+include() {
+  if [[ -z "$TEMPLATE_DIR" ]]; then
+    critical "We could not find your template repo anywhere in this project!"
+    warn "Are you sure you are somewhere inside a project which has a template repo?"
+    warn "The template repo is a hidden folder at the root of your working directory which contains a .geethier file inside it"
+    warn "To debug our search, run \`$GEET_ALIAS status --verbose --filter LOCATE\`"
+    warn "If you think we made a mistake, review the code at $GEET_LIB/digest-and-locate.sh detect_template_dir_from_cwd"
+    exit 1
+  fi
+  need_dotgit
+  sync_exclude
+  # first, modify .geetinclude
+  source "$GEET_LIB/ignored.sh"
+  for arg in "$@"; do
+    status="$(is_ignored $arg)"
+    debug "status of $arg is \"$status\""
+    if [[ "$status" == "ignored" ]]; then
+      echo "$arg" >> "$TEMPLATE_DIR/.geetinclude"
+      sync_exclude
+      status="$(is_ignored $arg)"
+      if [[ "$status" == "ignored" ]]; then
+          die "failed to unignore $arg"
+      fi
+    fi
+    geet_git add "$arg"
+  done
+
+
+}

package/lib/init.sh

@@ -0,0 +1,234 @@
+# init.sh — layer initializer / bootstrapper (IDEMPOTENT)
+# Usage:
+#   source init.sh
+#   init [args...]
+#
+# Turns a freshly-cloned TEMPLATE REPO into a normal APP REPO,
+# while preserving the template repo as a "layer view" in dot-git/
+
+init() {
+
+###############################################################################
+# HELP
+###############################################################################
+if [[ "${1:-}" == "help" || "${1:-}" == "-h" || "${1:-}" == "--help" ]]; then
+  cat <<EOF
+$GEET_ALIAS init — initialize a freshly-cloned template repo as your app
+
+This command turns a freshly-cloned TEMPLATE REPO into a normal APP REPO,
+while preserving the template repo as a "layer view" in dot-git/
+
+What it does:
+  1. Moves .git → .$APP_NAME/dot-git (or whatever the layer is called)
+     This "captures" the cloned template repo's git database
+  2. Creates a brand new app repo at .git
+     Your new app starts with a clean slate
+  3. Syncs whitelist rules (.geetinclude → .geetexclude)
+  4. Ensures .gitignore excludes **/dot-git/
+  5. Optionally runs post-init hook if present
+
+Usage:
+  $GEET_ALIAS init [post-init-args...]
+
+  Note: Usually called automatically by '$GEET_ALIAS install'
+
+Arguments:
+  post-init-args  Optional arguments passed to the post-init hook
+                  (if .geet/post-init.sh exists and is executable)
+
+Key Idea (two repos, one working tree):
+  - App repo:       $DD_APP_NAME/.git              (your normal development)
+  - Template layer: $DD_APP_NAME/.geet/dot-git     (tracks whitelisted files only)
+
+  Both repos share the same working tree ($DD_APP_NAME/), but have separate gitdirs.
+
+Idempotency:
+  - If already initialized, prints status and exits successfully
+  - Safe to run multiple times
+
+Environment Variables:
+  GEET_RUN_POST_INIT  Set to 0 to skip post-init hook (default: 1)
+
+Examples:
+  cd MyNewApp && $GEET_ALIAS init
+  cd MyNewApp && $GEET_ALIAS init --app-name "My Cool App"
+  GEET_RUN_POST_INIT=0 $GEET_ALIAS init  # Skip post-init hook
+EOF
+  return 0
+fi
+
+
+has_flag --skip-post SKIP_POST_INIT
+
+###############################################################################
+# SETUP
+###############################################################################
+# digest-and-locate.sh provides: GEET_LIB, APP_DIR, TEMPLATE_DIR, DOTGIT,
+# TEMPLATE_GEET_CMD, die, log, debug
+
+# App repo git directory (normal repo)
+APP_GIT="$APP_DIR/.git"
+
+###############################################################################
+# PRECONDITIONS
+###############################################################################
+
+# Sanity check: git.sh should exist
+if [[ ! -f "$GEET_LIB/git.sh" ]]; then
+  log "warning: missing $GEET_LIB/git.sh (will skip post-init exclude sync)"
+fi
+
+###############################################################################
+# IDEMPOTENCY CHECK
+###############################################################################
+
+# If the layer dot-git already exists, we've already initialized this layer
+# for this working tree. Do not attempt to re-run conversion.
+if [[ -d "$DOTGIT" && -f "$DOTGIT/HEAD" ]]; then
+  log "already initialized"
+  log "layer gitdir: $DOTGIT"
+  log "app gitdir:   $APP_GIT"
+  return 0
+fi
+
+###############################################################################
+# MAIN CONVERSION LOGIC
+###############################################################################
+
+# The expected "fresh clone" state for THIS layer is:
+#   - APP_GIT exists (because you just cloned a template repo)
+#   - DOTGIT does not exist yet
+#
+# Example:
+#   - user clones $GEET_ALIAS template to MyApp2
+#   - MyApp2/.git exists
+#   - MyApp2/.geet/dot-git does not
+#
+# Another example:
+#   - user clones sk2 template to MyApp3
+#   - MyApp3/.git exists
+#   - MyApp3/.sk2/dot-git does not
+#
+# If APP_GIT doesn't exist, we do NOT know what to do (maybe user didn't clone).
+if [[ ! -d "$APP_GIT" ]]; then
+  die "expected $APP_GIT to exist (did you run this in a freshly cloned template repo?)"
+fi
+
+# Create layer directory if missing (should exist because this script is inside it)
+log "making $TEMPLATE_DIR"
+mkdir -p "$TEMPLATE_DIR"
+
+log "moving $APP_GIT to $DOTGIT"
+mv "$APP_GIT" "$DOTGIT"
+
+
+###############################################################################
+# CREATE NEW APP REPO
+###############################################################################
+
+# After the move:
+# - APP_DIR/.git no longer exists
+# - DOTGIT contains the template git database
+#
+# Now we create a fresh app repo at APP_DIR/.git
+log "initializing new app repo at $APP_GIT"
+git -C "$APP_DIR" init >/dev/null
+
+###############################################################################
+# ENSURE APP .geetexclude IGNORES dot-git/
+###############################################################################
+
+# Critical safety: dot-git/ contains git internals and must NEVER be committed
+# to the app repo. Ensure it's in .gitignore.
+APP_GITIGNORE="$APP_DIR/.gitignore"
+DOTGIT_PATTERN="**/dot-git/"
+UNTRACKED_PATTERN="**/untracked-template-config.env"
+if [[ -f "$APP_GITIGNORE" ]]; then
+  # Check if any form of dot-git ignore already exists
+  if ! grep -Eq '(^|[[:space:]])((\*\*/)?dot-git/|\.geet/dot-git/)([[:space:]]|$)' "$APP_GITIGNORE"; then
+    log "adding $DOTGIT_PATTERN to app .gitignore"
+    echo "$DOTGIT_PATTERN" >> "$APP_GITIGNORE"
+  else
+    log "app .gitignore already ignores dot-git/"
+  fi
+  if ! grep -Eq 'untracked-template-config.env' "$APP_GITIGNORE"; then
+      log "adding $UNTRACKED_PATTERN to app .gitignore"
+      echo "$UNTRACKED_PATTERN" >> "$APP_GITIGNORE"
+    else
+      log "app .gitignore already ignores untracked/"
+    fi
+else
+  log "creating app .gitignore with $DOTGIT_PATTERN"
+  echo "$DOTGIT_PATTERN" > "$APP_GITIGNORE"
+fi
+
+
+git add .
+git commit -m "initial commit"
+###############################################################################
+# FINAL OUTPUT
+###############################################################################
+log "done"
+log "layer initialized:"
+log "  layer:  $TEMPLATE_NAME"
+log "  worktree: $APP_DIR"
+log "  layer gitdir: $DOTGIT"
+log "  app gitdir:   $APP_GIT"
+log
+log "next steps:"
+log "  - develop normally with: git ..."
+log "  - update this layer with: $GEET_ALIAS pull"
+log "  - see included files with: $GEET_ALIAS tree"
+
+
+if  ! [[ "$SKIP_POST_INIT" ]]; then
+  ###############################################################################
+  # OPTIONAL POST-INIT HOOK
+  ###############################################################################
+  # Some templates want to do a one-time setup step after init, e.g.:
+  # - create .env from .env.sample
+  # - rename package name / bundle id
+  # - install dependencies
+  # - print “next steps” instructions
+  #
+  # geet itself should not become a framework-specific scaffold tool, so we keep
+  # this mechanism very small and template-owned:
+  #
+  #   - If <layer>/post-init.sh exists AND is executable, we run it.
+  #   - Otherwise, we do nothing.
+  #
+  # Security note:
+  # - This is code from the template you just cloned.
+  # - Running it is equivalent to "running a script from the internet".
+  # - Keep it simple and obvious, and consider requiring an env var gate later.
+  POST_INIT_SH="$TEMPLATE_DIR/post-init.sh"
+
+  if [[ -f "$POST_INIT_SH" ]]; then
+    if [[ ! -x "$POST_INIT_SH" ]]; then
+      die "found post-init hook but it is not executable: $POST_INIT_SH (run: chmod +x $POST_INIT_SH)"
+    fi
+
+    log "running post-init hook:"
+    log "  $POST_INIT_SH"
+
+    # Provide some context to the hook.
+    # The hook can use these to make decisions without re-discovering paths.
+    export GEET_LAYER_DIR="$TEMPLATE_DIR"
+    export GEET_LAYER_NAME="$TEMPLATE_NAME"
+    export GEET_ROOT="$APP_DIR"
+    export GEET_DOTGIT="$DOTGIT"
+
+    # Run from the project root so relative paths behave naturally.
+    # Pass through any arguments that were provided to init.sh (from install command).
+    (
+      cd "$APP_DIR"
+      "$POST_INIT_SH" "$@"
+    )
+
+    log "post-init hook complete"
+    log "enjoy developing!"
+  fi
+
+fi
+
+}  # end of init()

package/lib/install.sh

@@ -0,0 +1,166 @@
+# install.sh — clone and init
+# Usage:
+#   source install.sh
+#   (exposed functions are used via geet.sh command dispatcher)
+
+
+###############################################################################
+# INSTALL - Clone a template repo and run init
+###############################################################################
+# This is a convenience command for first-time users:
+#
+#   $GEET_ALIAS install <repo> [dir] [--recurse-submodules]
+#
+# It:
+#  1) runs `git clone`
+#  2) cd's into the directory
+#  3) runs this layer's init.sh to convert the clone into an app + layer
+#
+install() {
+  local INIT_SH="$GEET_LIB/init.sh"
+  [[ -f "$INIT_SH" ]] || die "missing init script: $INIT_SH"
+
+  # Check for help first
+  if [[ "${1:-}" == "help" || "${1:-}" == "-h" || "${1:-}" == "--help" ]]; then
+    cat <<EOF
+Usage:
+  $GEET_ALIAS install <repo> <dir> [options] [-- post-init-args...]
+
+Options:
+  --recurse-submodules, -r   Clone with submodules
+  --pub, --public            Publish app as public GitHub repo after install
+  --pri, --private           Publish app as private GitHub repo after install
+  --int, --internal          Publish app as internal GitHub repo after install
+
+Examples:
+  $GEET_ALIAS install git@github.com:$GH_USER/template.git MyApp
+  $GEET_ALIAS install mytemplate MyApp --pub
+  $GEET_ALIAS install modularizer/geet MyGeetApp --private
+  $GEET_ALIAS install --recurse-submodules git@github.com:$GH_USER/template.git MyApp -- --app-name "My Cool App"
+
+Notes:
+  - <dir> is required and must be different from the template repo name
+  - After cloning, this runs init automatically
+  - Arguments after '--' are passed to the post-init hook (if present)
+  - Publish flags create a NEW GitHub repo for the app (not the template)
+EOF
+    return 0
+  fi
+
+  # Extract flags using has_flag
+  local RECURSE=""
+  local PUB_APP=""
+  local PRI_APP=""
+  local INT_APP=""
+
+  has_flag --recurse-submodules RECURSE
+  has_flag --public PUB_APP
+  has_flag --private PRI_APP
+  has_flag --internal INT_APP
+
+  # Determine publish visibility
+  local publish_visibility=""
+  if [[ -n "$PUB_APP" ]]; then
+    publish_visibility="public"
+  elif [[ -n "$PRI_APP" ]]; then
+    publish_visibility="private"
+  elif [[ -n "$INT_APP" ]]; then
+    publish_visibility="internal"
+  fi
+
+  # Separate positional args from post-init args
+  local -a args=()
+  local -a post_init_args=()
+  local parsing_post_init=0
+
+  for arg in "${GEET_ARGS[@]}"; do
+    if [[ "$arg" == "--" ]]; then
+      parsing_post_init=1
+      continue
+    fi
+
+    if [[ "$parsing_post_init" -eq 1 ]]; then
+      post_init_args+=("$arg")
+    else
+      args+=("$arg")
+    fi
+  done
+
+  [[ ${#args[@]} -ge 2 ]] || die "install requires both <repo> and <dir> arguments"
+
+  local repo="${args[0]}"
+  local dir="${args[1]}"
+
+  # repo supports 5 possibilities
+  # OPTION 1: resolves to a path on your own computer which already exists
+  # OPTION 2: startswith http, treat as a git remote. add ".git" to the end if it isn't there already
+  # OPTION 3: startswith git@, treat as a git ssh remote. add ".git" to the end if it isn't there already
+  # OPTION 4: in format or username/name, e.g. "modularizer/geet" or "modularizer/geet/", convert to "https://github.com/modularizer/geet.git"
+  # OPTION 5: just a repo name, e.g. "mytemplate", use get_gh_user then convert to "$GH_USER/mytemplate"
+
+  if [[ -e "$repo" ]]; then
+    # OPTION 1: local path exists, use as-is
+    :
+  elif [[ "$repo" == http* ]]; then
+    # OPTION 2: HTTP URL
+    if [[ "$repo" != *.git ]]; then
+      repo="${repo}.git"
+    fi
+  elif [[ "$repo" == git@* ]]; then
+    # OPTION 3: SSH URL
+    if [[ "$repo" != *.git ]]; then
+      repo="${repo}.git"
+    fi
+  elif [[ "$repo" =~ ^[a-zA-Z0-9_-]+/[a-zA-Z0-9_.-]+/?$ ]]; then
+    # OPTION 4: username/repo format
+    repo="${repo%/}"  # remove trailing slash if present
+    repo="git@github.com:${repo}.git"
+  elif [[ "$repo" =~ ^[a-zA-Z0-9_.-]+$ ]]; then
+    # OPTION 5: just a repo name
+    get_gh_user
+    repo="git@github.com:${GH_USER}/${repo}.git"
+  fi
+
+  # Extract repo name for validation
+  local repo_name="$(basename "$repo")"
+  repo_name="${repo_name%.git}"
+
+  # Ensure dir is different from repo name to avoid confusion
+  # (template repo vs new app directory)
+  if [[ "$dir" == "$repo_name" ]]; then
+    die "dir must be different from repo name ('$repo_name'). The dir is your NEW app, not the template."
+  fi
+
+  local -a clone_args=()
+  if [[ -n "$RECURSE" ]]; then
+    clone_args+=(--recurse-submodules)
+  fi
+
+  log "cloning template repo:"
+  log "  repo: $repo"
+  log "  dir:  $dir"
+  git clone "${clone_args[@]}" "$repo" "$dir"
+  log "calling \`cd \"$dir\"\`"
+  cd "$dir" || exit
+  log "pwd: $(pwd)"
+
+  GEET_CMD="${BASH_SOURCE[-1]}"
+  log "geet_cmd=$GEET_CMD"
+
+  log "running init in cloned directory"
+  (
+   "$GEET_CMD" init "${post_init_args[@]}"
+  )
+  log "pwd: $(pwd)"
+  log "publish_visibility=$publish_visibility"
+
+  # Publish the app as a GitHub repo if requested
+  if [[ -n "$publish_visibility" ]]; then
+    log "Calling \`$GEET_CMD publish app\`"
+    (
+       "$GEET_CMD" publish app "--${publish_visibility}"
+    )
+  fi
+
+  log "install complete"
+}