@codeyam/codeyam-cli 0.1.0-staging.ae0de75 → 0.1.0-staging.b147f46

package/codeyam-cli/templates/skills/codeyam-memory/scripts/holistic-analysis/detect-deprecated-patterns.sh

@@ -1,108 +0,0 @@
-#!/usr/bin/env bash
-# Gathers deprecation signals from package.json, source markers, and git history.
-# Outputs structured JSON to /tmp/codeyam-memory/deprecated-scan.json
-
-set -euo pipefail
-
-OUTPUT_DIR="/tmp/codeyam-memory"
-OUTPUT_FILE="$OUTPUT_DIR/deprecated-scan.json"
-mkdir -p "$OUTPUT_DIR"
-
-# --- Dependency scan ---
-# Collect all dependency names from package.json files (root + workspace packages)
-deps_json="[]"
-while IFS= read -r pkg_file; do
-  # Extract dependency names from both dependencies and devDependencies
-  file_deps=$(jq -r '(.dependencies // {} | keys[]) , (.devDependencies // {} | keys[])' "$pkg_file" 2>/dev/null || true)
-  if [ -n "$file_deps" ]; then
-    deps_json=$(echo "$deps_json" | jq --arg d "$file_deps" '. + ($d | split("\n") | map(select(. != "")))')
-  fi
-done < <(find . -name "package.json" -not -path "*/node_modules/*" -not -path "*/dist/*" -not -path "*/.next/*" 2>/dev/null)
-
-# Deduplicate
-deps_json=$(echo "$deps_json" | jq 'unique')
-
-# --- Explicit marker scan ---
-markers_json="[]"
-marker_output=$(rg -n "@deprecated|// legacy|// deprecated|// old approach|TODO.*deprecat|FIXME.*deprecat" \
-  --type ts --type js \
-  --glob '!node_modules' --glob '!dist' --glob '!build' --glob '!.next' \
-  -C 2 2>/dev/null || true)
-
-if [ -n "$marker_output" ]; then
-  # Parse ripgrep output into JSON entries
-  markers_json=$(echo "$marker_output" | awk -F: '
-    /^[^-].*:[0-9]+:/ {
-      file = $1
-      line = $2
-      # Rejoin the rest as text (handles colons in content)
-      text = ""
-      for (i = 3; i <= NF; i++) {
-        text = (text == "" ? $i : text ":" $i)
-      }
-      gsub(/^[ \t]+/, "", text)
-      gsub(/"/, "\\\"", text)
-      gsub(/\t/, " ", text)
-      printf "{\"file\":\"%s\",\"line\":%s,\"text\":\"%s\"},\n", file, line, text
-    }
-  ' | sed '$ s/,$//' | awk 'BEGIN{print "["} {print} END{print "]"}')
-
-  # Validate JSON — fall back to empty array if malformed
-  if ! echo "$markers_json" | jq empty 2>/dev/null; then
-    markers_json="[]"
-  fi
-fi
-
-# --- Git recency comparison ---
-# Extract all import lines from git patches in two passes (recent + old), then count per-dep
-recency_json="{}"
-dep_count=$(echo "$deps_json" | jq length)
-
-if [ "$dep_count" -gt 0 ]; then
-  RECENT_IMPORTS="$OUTPUT_DIR/recent-imports.txt"
-  OLD_IMPORTS="$OUTPUT_DIR/old-imports.txt"
-
-  # Single git log pass per time window — extract only import lines
-  git log --since="3 months ago" -p -- '*.ts' '*.tsx' '*.js' '*.jsx' 2>/dev/null \
-    | grep -oE "from ['\"][^'\"]+['\"]" > "$RECENT_IMPORTS" 2>/dev/null || true
-  git log --since="12 months ago" --until="3 months ago" -p -- '*.ts' '*.tsx' '*.js' '*.jsx' 2>/dev/null \
-    | grep -oE "from ['\"][^'\"]+['\"]" > "$OLD_IMPORTS" 2>/dev/null || true
-
-  for dep in $(echo "$deps_json" | jq -r '.[]'); do
-    # Skip short names that would match too broadly
-    if [ ${#dep} -lt 3 ]; then
-      continue
-    fi
-
-    recent=$(grep -c "from ['\"]${dep}" "$RECENT_IMPORTS" 2>/dev/null || true)
-    recent=${recent:-0}
-    old=$(grep -c "from ['\"]${dep}" "$OLD_IMPORTS" 2>/dev/null || true)
-    old=${old:-0}
-
-    if [ "$recent" -gt 0 ] || [ "$old" -gt 0 ]; then
-      recency_json=$(echo "$recency_json" | jq \
-        --arg dep "$dep" \
-        --argjson recent "$recent" \
-        --argjson old "$old" \
-        '. + {($dep): {"recent_imports": $recent, "old_imports": $old}}')
-    fi
-  done
-
-  rm -f "$RECENT_IMPORTS" "$OLD_IMPORTS"
-fi
-
-# --- Assemble final output ---
-jq -n \
-  --argjson dependencies "$deps_json" \
-  --argjson explicit_markers "$markers_json" \
-  --argjson git_recency "$recency_json" \
-  '{
-    dependencies: $dependencies,
-    explicit_markers: $explicit_markers,
-    git_recency: $git_recency
-  }' > "$OUTPUT_FILE"
-
-echo "Deprecated pattern scan complete: $OUTPUT_FILE"
-echo "  Dependencies found: $(echo "$deps_json" | jq length)"
-echo "  Explicit markers found: $(echo "$markers_json" | jq length)"
-echo "  Deps with git activity: $(echo "$recency_json" | jq 'length')"

package/codeyam-cli/templates/skills/codeyam-memory/scripts/holistic-analysis/find-exports.sh

@@ -1,69 +0,0 @@
-#!/usr/bin/env bash
-# Indexes the project's public API surface by finding all exports.
-# Outputs structured JSON to /tmp/codeyam-memory/exports-scan.json
-
-set -euo pipefail
-
-OUTPUT_DIR="/tmp/codeyam-memory"
-OUTPUT_FILE="$OUTPUT_DIR/exports-scan.json"
-mkdir -p "$OUTPUT_DIR"
-
-# Find all export declarations, excluding noise directories and .d.ts files
-export_output=$(rg -n "^export (function|const|class|default|async function|type|interface|enum)" \
-  --type ts --type js \
-  --glob '!node_modules' --glob '!dist' --glob '!build' --glob '!.next' \
-  --glob '!*.d.ts' --glob '!*.map' \
-  2>/dev/null || true)
-
-if [ -z "$export_output" ]; then
-  # No exports found — output empty structure
-  jq -n '{files: {}, stats: {total_files: 0, total_exports: 0}}' > "$OUTPUT_FILE"
-  echo "Export scan complete: $OUTPUT_FILE (no exports found)"
-  exit 0
-fi
-
-# Parse ripgrep output into JSON grouped by file
-# Format: file:line:text
-files_json=$(echo "$export_output" | awk -F: '
-{
-  file = $1
-  line = $2
-  # Rejoin rest as text
-  text = ""
-  for (i = 3; i <= NF; i++) {
-    text = (text == "" ? $i : text ":" $i)
-  }
-  # Trim leading whitespace
-  gsub(/^[ \t]+/, "", text)
-  # Escape quotes for JSON
-  gsub(/"/, "\\\"", text)
-  gsub(/\t/, " ", text)
-  printf "%s\t%s\t%s\n", file, line, text
-}' | jq -Rsn '
-  [inputs | split("\n") | .[] | select(. != "") |
-    split("\t") | select(length >= 3) |
-    {file: .[0], line: (.[1] | tonumber), text: .[2]}
-  ] |
-  group_by(.file) |
-  reduce .[] as $group ({};
-    . + {($group[0].file): [$group[] | {line: .line, text: .text}]}
-  )
-')
-
-# Compute stats
-total_files=$(echo "$files_json" | jq 'length')
-total_exports=$(echo "$files_json" | jq '[.[] | length] | add // 0')
-
-# Assemble final output
-jq -n \
-  --argjson files "$files_json" \
-  --argjson total_files "$total_files" \
-  --argjson total_exports "$total_exports" \
-  '{
-    files: $files,
-    stats: {total_files: $total_files, total_exports: $total_exports}
-  }' > "$OUTPUT_FILE"
-
-echo "Export scan complete: $OUTPUT_FILE"
-echo "  Files with exports: $total_files"
-echo "  Total exports: $total_exports"

package/codeyam-cli/templates/skills/codeyam-memory/scripts/session-mining/cleanup.sh

@@ -1,12 +0,0 @@
-#!/usr/bin/env bash
-# Removes cached preprocessed session files.
-set -euo pipefail
-
-OUTPUT_DIR="/tmp/cc-session-analysis"
-
-if [ -d "$OUTPUT_DIR" ]; then
-  rm -rf "$OUTPUT_DIR"
-  echo "Cleaned up $OUTPUT_DIR"
-else
-  echo "Nothing to clean up ($OUTPUT_DIR does not exist)"
-fi

package/codeyam-cli/templates/skills/codeyam-memory/scripts/session-mining/filter.jq

@@ -1,45 +0,0 @@
-# Session log filter for codeyam-memory skill.
-# Strips progress/system/queue records, compresses tool inputs to 300 chars,
-# tool results to 500 chars, thinking to 1000 chars. Output is compact JSONL.
-
-select(.type == "user" or .type == "assistant") |
-if .type == "assistant" then
-  {
-    type: "assistant",
-    ts: .timestamp,
-    content: [
-      (.message.content[]? |
-        if .type == "text" then
-          {t: "text", text}
-        elif .type == "thinking" then
-          {t: "think", thinking: (.thinking // "" | if length > 1000 then (.[0:1000] + "...[truncated]") else . end)}
-        elif .type == "tool_use" then
-          {t: "tool", name, input: (.input | tostring | if length > 300 then .[0:300] + "..." else . end)}
-        else empty
-        end
-      )
-    ]
-  }
-elif .type == "user" then
-  {
-    type: "user",
-    ts: .timestamp,
-    content: (
-      if (.message.content | type) == "string" then
-        .message.content
-      elif (.message.content | type) == "array" then
-        [.message.content[]? |
-          if .type == "tool_result" then
-            {t: "result", id: .tool_use_id, err: (.is_error // false),
-             content: (.content | tostring | if length > 500 then .[0:500] + "...[truncated]" else . end)}
-          else
-            {t: "msg", text: (. | tostring | if length > 500 then .[0:500] + "...[truncated]" else . end)}
-          end
-        ]
-      else
-        (.message.content | tostring | if length > 500 then .[0:500] + "...[truncated]" else . end)
-      end
-    )
-  }
-else empty
-end

package/codeyam-cli/templates/skills/codeyam-memory/scripts/session-mining/preprocess.sh

@@ -1,139 +0,0 @@
-#!/usr/bin/env bash
-# Preprocesses Claude Code session logs for the codeyam-memory skill.
-#
-# - Finds JSONL session files (>=10KB, last 30 days)
-# - Excludes the current active session
-# - Runs jq filter for 5-50x compression
-# - Caches results in /tmp/cc-session-analysis/
-# - Prints filtered file paths to stdout (one per line)
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-FILTER="$SCRIPT_DIR/filter.jq"
-OUTPUT_DIR="/tmp/cc-session-analysis"
-MIN_SIZE=10240  # 10KB
-MAX_AGE_DAYS=30
-MAX_SESSIONS=30  # Diminishing returns past this; keeps agent fleet manageable
-JQ_TIMEOUT=30    # Seconds — skip files that take longer than this to filter
-
-# --- Dependency check ---
-if ! command -v jq &>/dev/null; then
-  echo "Error: jq is required but not installed." >&2
-  echo "  macOS:  brew install jq" >&2
-  echo "  Ubuntu: sudo apt-get install jq" >&2
-  echo "  Other:  https://jqlang.github.io/jq/download/" >&2
-  exit 1
-fi
-
-# --- Compute Claude project directory ---
-PROJECT_DIR="$PWD"
-# Claude Code replaces both / and . with - in the project hash
-PROJECT_HASH=$(echo "$PROJECT_DIR" | sed 's|[/.]|-|g')
-SESSION_DIR="$HOME/.claude/projects/$PROJECT_HASH"
-
-if [ ! -d "$SESSION_DIR" ]; then
-  echo "No Claude session directory found at $SESSION_DIR" >&2
-  echo "This project may not have any Claude Code session history." >&2
-  exit 0
-fi
-
-# --- Find session files ---
-mkdir -p "$OUTPUT_DIR"
-
-# Collect eligible session files: >=10KB, modified within last 30 days, .jsonl extension
-# Sort by mtime (newest first) so the cap keeps the most recent sessions
-ALL_SESSIONS=()
-while IFS= read -r file; do
-  ALL_SESSIONS+=("$file")
-done < <(find "$SESSION_DIR" -maxdepth 1 -name "*.jsonl" -size +"$MIN_SIZE"c -mtime -"$MAX_AGE_DAYS" -print0 2>/dev/null \
-  | xargs -0 stat -f "%m %N" 2>/dev/null \
-  | sort -rn \
-  | awk '{print $2}')
-
-if [ ${#ALL_SESSIONS[@]} -eq 0 ]; then
-  exit 0
-fi
-
-# Cap to most recent N sessions
-SESSIONS=("${ALL_SESSIONS[@]:0:$MAX_SESSIONS}")
-if [ ${#ALL_SESSIONS[@]} -gt "$MAX_SESSIONS" ]; then
-  echo "Note: ${#ALL_SESSIONS[@]} sessions found, capping to $MAX_SESSIONS most recent" >&2
-fi
-
-# --- Exclude current active session ---
-# The newest file by mtime is likely the current session.
-# If CLAUDE_SESSION_ID is set, use that for a more precise match.
-NEWEST_FILE=""
-NEWEST_MTIME=0
-for file in "${SESSIONS[@]}"; do
-  mtime=$(stat -f "%m" "$file" 2>/dev/null || stat -c "%Y" "$file" 2>/dev/null || echo "0")
-  if [ "$mtime" -gt "$NEWEST_MTIME" ]; then
-    NEWEST_MTIME="$mtime"
-    NEWEST_FILE="$file"
-  fi
-done
-
-ACTIVE_SESSION=""
-if [ -n "${CLAUDE_SESSION_ID:-}" ]; then
-  for file in "${SESSIONS[@]}"; do
-    if [[ "$(basename "$file" .jsonl)" == "$CLAUDE_SESSION_ID" ]]; then
-      ACTIVE_SESSION="$file"
-      break
-    fi
-  done
-fi
-# Fall back to newest file if no env var match
-if [ -z "$ACTIVE_SESSION" ]; then
-  ACTIVE_SESSION="$NEWEST_FILE"
-fi
-
-# --- Process each session ---
-for file in "${SESSIONS[@]}"; do
-  # Skip active session
-  if [ "$file" = "$ACTIVE_SESSION" ]; then
-    continue
-  fi
-
-  uuid=$(basename "$file" .jsonl)
-  filtered="$OUTPUT_DIR/${uuid}.filtered.jsonl"
-
-  # Check cache: skip if filtered file exists and has a valid sentinel
-  if [ -f "$filtered" ]; then
-    first_line=$(head -1 "$filtered" 2>/dev/null || true)
-    if echo "$first_line" | jq -e '.processed_at' &>/dev/null; then
-      echo "$filtered"
-      continue
-    fi
-  fi
-
-  # Run jq filter
-  source_size=$(stat -f "%z" "$file" 2>/dev/null || stat -c "%s" "$file" 2>/dev/null || echo "0")
-  sentinel=$(printf '{"processed_at":"%s","source_size":%s}' "$(date -u +"%Y-%m-%dT%H:%M:%SZ")" "$source_size")
-
-  # Write sentinel as first line, then filtered content (with timeout)
-  jq_exit=0
-  {
-    echo "$sentinel"
-    if command -v timeout &>/dev/null; then
-      timeout "$JQ_TIMEOUT" jq -c -f "$FILTER" "$file" 2>/dev/null
-    elif command -v gtimeout &>/dev/null; then
-      gtimeout "$JQ_TIMEOUT" jq -c -f "$FILTER" "$file" 2>/dev/null
-    else
-      jq -c -f "$FILTER" "$file" 2>/dev/null
-    fi
-  } > "$filtered" || jq_exit=$?
-
-  if [ "$jq_exit" -eq 124 ]; then
-    echo "Warning: jq timed out after ${JQ_TIMEOUT}s on $(basename "$file") — skipping" >&2
-    rm -f "$filtered"
-    continue
-  fi
-
-  # Only output if the file has content beyond the sentinel
-  line_count=$(wc -l < "$filtered" | tr -d ' ')
-  if [ "$line_count" -gt 1 ]; then
-    echo "$filtered"
-  else
-    rm -f "$filtered"
-  fi
-done