Nia

#!/usr/bin/env bash
# Nia Advisor — get AI code advice grounded in your indexed repos and docs
# Pass local files + a question; Nia searches your sources and returns a targeted answer.
# Usage: advisor.sh "query" <files...>
# Env: REPOS (csv), DOCS (csv), OUTPUT_FORMAT (explanation|checklist|diff|structured)
set -e
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
source "$SCRIPT_DIR/lib.sh"

if [ -z "$1" ]; then
  echo "Usage: advisor.sh 'query' file1.py [file2.ts ...]"
  echo ""
  echo "Environment variables:"
  echo "  REPOS           Comma-separated repos to search against"
  echo "  DOCS            Comma-separated doc sources to search against"
  echo "  OUTPUT_FORMAT   explanation|checklist|diff|structured (default: explanation)"
  exit 1
fi

QUERY="$1"
shift

# Build files object from remaining args
FILES_JSON="{}"
for FILE in "$@"; do
  if [ -f "$FILE" ]; then
    CONTENT=$(cat "$FILE")
    FILES_JSON=$(echo "$FILES_JSON" | jq --arg path "$FILE" --arg content "$CONTENT" '. + {($path): $content}')
  else
    echo "Warning: File not found: $FILE" >&2
  fi
done

# Build search scope
SCOPE="{}"
if [ -n "${REPOS:-}" ]; then
  SCOPE=$(echo "$SCOPE" | jq --arg r "$REPOS" '. + {repositories: ($r | split(","))}')
fi
if [ -n "${DOCS:-}" ]; then
  SCOPE=$(echo "$SCOPE" | jq --arg d "$DOCS" '. + {data_sources: ($d | split(","))}')
fi

DATA=$(jq -n \
  --arg q "$QUERY" \
  --argjson files "$FILES_JSON" \
  --argjson scope "$SCOPE" \
  --arg fmt "${OUTPUT_FORMAT:-explanation}" \
  '{query: $q, codebase: {files: $files}, output_format: $fmt}
  + (if ($scope | length) > 0 then {search_scope: $scope} else {} end)')

nia_post "$BASE_URL/advisor" "$DATA"

#!/usr/bin/env bash
# Nia Auth — programmatic signup and API key bootstrap/login
# Usage: auth.sh <command> [args...]
set -e

BASE_URL="https://apigcp.trynia.ai/v2"

request_raw() {
  local method="$1" path="$2" data="${3:-}"
  local args=(-s -X "$method" "$BASE_URL$path")
  if [ -n "$data" ]; then
    args+=(-H "Content-Type: application/json" -d "$data")
  fi
  curl "${args[@]}"
}

save_api_key_if_requested() {
  local json="$1"
  if [ "${SAVE_KEY:-false}" != "true" ]; then
    return 0
  fi
  local api_key
  api_key=$(echo "$json" | jq -r '.api_key // empty')
  if [ -z "$api_key" ]; then
    return 0
  fi
  mkdir -p ~/.config/nia
  printf '%s\n' "$api_key" > ~/.config/nia/api_key
}

print_json() {
  echo "$1" | jq '.'
}

# ─── signup — create account and return bootstrap token
cmd_signup() {
  if [ -z "$3" ]; then
    echo "Usage: auth.sh signup <email> <password> <organization_name> [first_name] [last_name]"
    echo "  Env: IDEMPOTENCY_KEY"
    return 1
  fi
  DATA=$(jq -n \
    --arg email "$1" --arg password "$2" --arg org "$3" \
    --arg first "${4:-}" --arg last "${5:-}" --arg idem "${IDEMPOTENCY_KEY:-}" \
    '{email: $email, password: $password, organization_name: $org}
    + (if $first != "" then {first_name: $first} else {} end)
    + (if $last != "" then {last_name: $last} else {} end)
    + (if $idem != "" then {idempotency_key: $idem} else {} end)')
  print_json "$(request_raw POST /auth/signup "$DATA")"
}

# ─── bootstrap-key — exchange one-time bootstrap token for an nk_ API key
cmd_bootstrap_key() {
  if [ -z "$1" ]; then
    echo "Usage: auth.sh bootstrap-key <bootstrap_token>"
    echo "  Env: SAVE_KEY=true to write ~/.config/nia/api_key"
    return 1
  fi
  DATA=$(jq -n --arg token "$1" '{bootstrap_token: $token}')
  RESULT=$(request_raw POST /auth/bootstrap-key "$DATA")
  save_api_key_if_requested "$RESULT"
  print_json "$RESULT"
}

# ─── login-key — authenticate with email/password and mint a new API key
cmd_login_key() {
  if [ -z "$2" ]; then
    echo "Usage: auth.sh login-key <email> <password> [organization_id]"
    echo "  Env: SAVE_KEY=true, IDEMPOTENCY_KEY"
    return 1
  fi
  DATA=$(jq -n \
    --arg email "$1" --arg password "$2" --arg org "${3:-}" --arg idem "${IDEMPOTENCY_KEY:-}" \
    '{email: $email, password: $password}
    + (if $org != "" then {organization_id: $org} else {} end)
    + (if $idem != "" then {idempotency_key: $idem} else {} end)')
  RESULT=$(request_raw POST /auth/login-key "$DATA")
  save_api_key_if_requested "$RESULT"
  print_json "$RESULT"
}

# ─── dispatch ─────────────────────────────────────────────────────────────────
case "${1:-}" in
  signup)        shift; cmd_signup "$@" ;;
  bootstrap-key) shift; cmd_bootstrap_key "$@" ;;
  login-key)     shift; cmd_login_key "$@" ;;
  *)
    echo "Usage: $(basename "$0") <command> [args...]"
    echo ""
    echo "Commands:"
    echo "  signup         Create account and get bootstrap token"
    echo "  bootstrap-key  Exchange bootstrap token for nk_ API key"
    echo "  login-key      Mint a fresh API key with email/password"
    echo ""
    echo "Set SAVE_KEY=true to write the returned api_key to ~/.config/nia/api_key."
    exit 1
    ;;
esac

#!/usr/bin/env bash
# Nia Categories — organize sources into categories
# Usage: categories.sh <command> [args...]
set -e
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
source "$SCRIPT_DIR/lib.sh"

# ─── list — list all categories you've created
cmd_list() {
  local limit="${1:-}" offset="${2:-}" url="$BASE_URL/categories" sep="?"
  if [ -n "$limit" ]; then url="${url}${sep}limit=${limit}"; sep="&"; fi
  if [ -n "$offset" ]; then url="${url}${sep}offset=${offset}"; fi
  nia_get "$url"
}

# ─── create — create a new category with optional color and sort order
cmd_create() {
  if [ -z "$1" ]; then echo "Usage: categories.sh create <name> [color] [order]"; return 1; fi
  DATA=$(jq -n --arg name "$1" --arg color "${2:-}" --arg order "${3:-}" \
    '{name: $name}
    + (if $color != "" then {color: $color} else {} end)
    + (if $order != "" then {order: ($order | tonumber)} else {} end)')
  nia_post "$BASE_URL/categories" "$DATA"
}

# ─── update — change a category's name, color, or sort order
cmd_update() {
  if [ -z "$1" ]; then echo "Usage: categories.sh update <category_id> [name] [color] [order]"; return 1; fi
  local cid="$1"; shift
  DATA=$(jq -n --arg name "${1:-}" --arg color "${2:-}" --arg order "${3:-}" \
    '{} + (if $name != "" then {name: $name} else {} end)
       + (if $color != "" then {color: $color} else {} end)
       + (if $order != "" then {order: ($order | tonumber)} else {} end)')
  nia_patch "$BASE_URL/categories/${cid}" "$DATA"
}

# ─── delete — delete a category (does not delete assigned sources)
cmd_delete() {
  if [ -z "$1" ]; then echo "Usage: categories.sh delete <category_id>"; return 1; fi
  nia_delete "$BASE_URL/categories/$1"
}

# ─── assign — assign a category to a source, or pass 'null' to remove it
cmd_assign() {
  if [ -z "$1" ] || [ -z "$2" ]; then echo "Usage: categories.sh assign <source_id> <category_id|null>"; return 1; fi
  local sid=$(resolve_source_id "$1" "${TYPE:-}") cat_id="$2"
  if [ "$cat_id" = "null" ]; then DATA='{"category_id": null}'
  else DATA=$(jq -n --arg c "$cat_id" '{category_id: $c}'); fi
  local url="$BASE_URL/sources/${sid}"
  if [ -n "${TYPE:-}" ]; then url="${url}?type=${TYPE}"; fi
  nia_patch "$url" "$DATA"
}

# ─── dispatch ─────────────────────────────────────────────────────────────────
case "${1:-}" in
  list)   shift; cmd_list "$@" ;;
  create) shift; cmd_create "$@" ;;
  update) shift; cmd_update "$@" ;;
  delete) shift; cmd_delete "$@" ;;
  assign) shift; cmd_assign "$@" ;;
  *)
    echo "Usage: $(basename "$0") <command> [args...]"
    echo ""
    echo "Commands:"
    echo "  list     List categories [limit] [offset]"
    echo "  create   Create a category"
    echo "  update   Update a category"
    echo "  delete   Delete a category"
    echo "  assign   Assign category to a source (use 'null' to remove)"
    exit 1
    ;;
esac

#!/usr/bin/env bash
# Nia Connectors — generic connector management
# Usage: connectors.sh <command> [args...]
set -e
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
source "$SCRIPT_DIR/lib.sh"

# ─── list — list all available connector types
cmd_list() {
  nia_get "$BASE_URL/connectors"
}

# ─── installations — list all connector installations
cmd_installations() {
  nia_get "$BASE_URL/connectors/installations"
}

# ─── install — install a connector (store API key or start OAuth)
cmd_install() {
  if [ -z "$1" ]; then
    echo "Usage: connectors.sh install <connector_type>"
    return 1
  fi
  nia_post "$BASE_URL/connectors/$1/install" "{}"
}

# ─── delete — disconnect a connector installation
cmd_delete() {
  if [ -z "$1" ]; then echo "Usage: connectors.sh delete <installation_id>"; return 1; fi
  nia_delete "$BASE_URL/connectors/installations/$1"
}

# ─── index — trigger indexing for a connector installation
cmd_index() {
  if [ -z "$1" ]; then echo "Usage: connectors.sh index <installation_id>"; return 1; fi
  nia_post "$BASE_URL/connectors/installations/$1/index" "{}"
}

# ─── schedule — update sync schedule for a connector installation
cmd_schedule() {
  if [ -z "$1" ]; then echo "Usage: connectors.sh schedule <installation_id>"; return 1; fi
  nia_patch "$BASE_URL/connectors/installations/$1/schedule" "{}"
}

# ─── status — get sync status and health for a connector installation
cmd_status() {
  if [ -z "$1" ]; then echo "Usage: connectors.sh status <installation_id>"; return 1; fi
  nia_get "$BASE_URL/connectors/installations/$1/status"
}

# ─── dispatch ─────────────────────────────────────────────────────────────────
case "${1:-}" in
  list)          shift; cmd_list "$@" ;;
  installations) shift; cmd_installations "$@" ;;
  install)       shift; cmd_install "$@" ;;
  delete)        shift; cmd_delete "$@" ;;
  index)         shift; cmd_index "$@" ;;
  schedule)      shift; cmd_schedule "$@" ;;
  status)        shift; cmd_status "$@" ;;
  *)
    echo "Usage: $(basename "$0") <command> [args...]"
    echo ""
    echo "Generic connector management."
    echo ""
    echo "Commands:"
    echo "  list           List available connector types"
    echo "  installations  List connector installations"
    echo "  install        Install a connector by type"
    echo "  delete         Disconnect a connector installation"
    echo "  index          Trigger indexing for installation"
    echo "  schedule       Update sync schedule"
    echo "  status         Get installation sync status"
    exit 1
    ;;
esac

#!/usr/bin/env bash
# Nia Contexts — cross-agent conversation context sharing
# Usage: contexts.sh <command> [args...]
set -e
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
source "$SCRIPT_DIR/lib.sh"

# ─── save — persist a conversation context so other agents can retrieve it later
cmd_save() {
  if [ -z "$4" ]; then
    echo "Usage: contexts.sh save <title> <summary> <content> <agent_source>"
    echo "  Env: TAGS, MEMORY_TYPE, TTL_SECONDS, ORGANIZATION_ID,"
    echo "       METADATA_JSON, NIA_REFERENCES_JSON, EDITED_FILES_JSON, LINEAGE_JSON"
    return 1
  fi
  DATA=$(jq -n \
    --arg title "$1" --arg summary "$2" --arg content "$3" --arg agent "$4" \
    --arg tags "${TAGS:-}" --arg mt "${MEMORY_TYPE:-}" --arg ttl "${TTL_SECONDS:-}" \
    --arg org "${ORGANIZATION_ID:-}" --arg metadata "${METADATA_JSON:-}" \
    --arg refs "${NIA_REFERENCES_JSON:-}" --arg files "${EDITED_FILES_JSON:-}" \
    --arg lineage "${LINEAGE_JSON:-}" \
    '{title: $title, summary: $summary, content: $content, agent_source: $agent}
    + (if $tags != "" then {tags: ($tags | split(","))} else {} end)
    + (if $mt != "" then {memory_type: $mt} else {} end)
    + (if $ttl != "" then {ttl_seconds: ($ttl | tonumber)} else {} end)
    + (if $org != "" then {organization_id: $org} else {} end)
    + (if $metadata != "" then {metadata: ($metadata | fromjson)} else {} end)
    + (if $refs != "" then {nia_references: ($refs | fromjson)} else {} end)
    + (if $files != "" then {edited_files: ($files | fromjson)} else {} end)
    + (if $lineage != "" then {lineage: ($lineage | fromjson)} else {} end)')
  nia_post "$BASE_URL/contexts" "$DATA"
}

# ─── list — list saved contexts, filterable by tags/agent/memory type
cmd_list() {
  local limit="${1:-20}" offset="${2:-0}"
  local url="$BASE_URL/contexts?limit=${limit}&offset=${offset}"
  if [ -n "${TAGS:-}" ]; then url="${url}&tags=${TAGS}"; fi
  if [ -n "${AGENT_SOURCE:-}" ]; then url="${url}&agent_source=${AGENT_SOURCE}"; fi
  if [ -n "${MEMORY_TYPE:-}" ]; then url="${url}&memory_type=${MEMORY_TYPE}"; fi
  nia_get "$url"
}

# ─── search — keyword/text search across all saved contexts
cmd_search() {
  if [ -z "$1" ]; then echo "Usage: contexts.sh search <query> [limit]"; return 1; fi
  local q=$(echo "$1" | sed 's/ /%20/g') limit="${2:-20}"
  local url="$BASE_URL/contexts/search?q=${q}&limit=${limit}"
  if [ -n "${TAGS:-}" ]; then url="${url}&tags=${TAGS}"; fi
  if [ -n "${AGENT_SOURCE:-}" ]; then url="${url}&agent_source=${AGENT_SOURCE}"; fi
  nia_get "$url"
}

# ─── semantic-search — vector similarity search across saved contexts
cmd_semantic_search() {
  if [ -z "$1" ]; then echo "Usage: contexts.sh semantic-search <query> [limit]"; return 1; fi
  local q=$(echo "$1" | sed 's/ /%20/g') limit="${2:-20}"
  local url="$BASE_URL/contexts/semantic-search?q=${q}&limit=${limit}"
  if [ -n "${WORKSPACE_FILTER:-}" ]; then url="${url}&workspace_filter=${WORKSPACE_FILTER}"; fi
  if [ -n "${INCLUDE_HIGHLIGHTS:-}" ]; then url="${url}&include_highlights=${INCLUDE_HIGHLIGHTS}"; fi
  nia_get "$url"
}

# ─── get — retrieve a single context by its ID
cmd_get() {
  if [ -z "$1" ]; then echo "Usage: contexts.sh get <context_id>"; return 1; fi
  nia_get "$BASE_URL/contexts/$1"
}

# ─── update — modify an existing context's title, summary, content, or tags
cmd_update() {
  if [ -z "$1" ]; then
    echo "Usage: contexts.sh update <context_id> [title] [summary] [content]"
    echo "  Pass '' to skip a field. Env: TAGS, MEMORY_TYPE, TTL_SECONDS,"
    echo "       ORGANIZATION_ID, METADATA_JSON, NIA_REFERENCES_JSON, EDITED_FILES_JSON, LINEAGE_JSON"
    return 1
  fi
  DATA=$(jq -n \
    --arg title "${2:-}" --arg summary "${3:-}" --arg content "${4:-}" \
    --arg tags "${TAGS:-}" --arg mt "${MEMORY_TYPE:-}" --arg ttl "${TTL_SECONDS:-}" \
    --arg org "${ORGANIZATION_ID:-}" --arg metadata "${METADATA_JSON:-}" \
    --arg refs "${NIA_REFERENCES_JSON:-}" --arg files "${EDITED_FILES_JSON:-}" \
    --arg lineage "${LINEAGE_JSON:-}" \
    '{} + (if $title != "" then {title: $title} else {} end)
       + (if $summary != "" then {summary: $summary} else {} end)
       + (if $content != "" then {content: $content} else {} end)
       + (if $tags != "" then {tags: ($tags | split(","))} else {} end)
       + (if $mt != "" then {memory_type: $mt} else {} end)
       + (if $ttl != "" then {ttl_seconds: ($ttl | tonumber)} else {} end)
       + (if $org != "" then {organization_id: $org} else {} end)
       + (if $metadata != "" then {metadata: ($metadata | fromjson)} else {} end)
       + (if $refs != "" then {nia_references: ($refs | fromjson)} else {} end)
       + (if $files != "" then {edited_files: ($files | fromjson)} else {} end)
       + (if $lineage != "" then {lineage: ($lineage | fromjson)} else {} end)')
  nia_put "$BASE_URL/contexts/$1" "$DATA"
}

# ─── delete — permanently remove a saved context
cmd_delete() {
  if [ -z "$1" ]; then echo "Usage: contexts.sh delete <context_id>"; return 1; fi
  nia_delete "$BASE_URL/contexts/$1"
}

# ─── dispatch ─────────────────────────────────────────────────────────────────
case "${1:-}" in
  save)            shift; cmd_save "$@" ;;
  list)            shift; cmd_list "$@" ;;
  search)          shift; cmd_search "$@" ;;
  semantic-search) shift; cmd_semantic_search "$@" ;;
  get)             shift; cmd_get "$@" ;;
  update)          shift; cmd_update "$@" ;;
  delete)          shift; cmd_delete "$@" ;;
  *)
    echo "Usage: $(basename "$0") <command> [args...]"
    echo ""
    echo "Commands:"
    echo "  save             Save conversation context"
    echo "  list             List contexts [limit] [offset]"
    echo "  search           Text search contexts"
    echo "  semantic-search  Semantic search contexts"
    echo "  get              Get context by ID"
    echo "  update           Update a context"
    echo "  delete           Delete a context"
    exit 1
    ;;
esac

#!/usr/bin/env bash
# Nia Datasets — HuggingFace dataset management
# Usage: datasets.sh <command> [args...]
set -e
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
source "$SCRIPT_DIR/lib.sh"

# ─── index — index a HuggingFace dataset so it becomes searchable
cmd_index() {
  if [ -z "$1" ]; then
    echo "Usage: datasets.sh index <dataset_name_or_url> [config]"
    echo "  Accepts: dataset name, owner/dataset, or full HF URL"
    echo "  Env: ADD_GLOBAL (true/false)"
    return 1
  fi
  DATA=$(jq -n --arg u "$1" --arg cfg "${2:-}" --arg ag "${ADD_GLOBAL:-}" \
    '{type: "huggingface_dataset", url: $u}
    + (if $cfg != "" then {config: $cfg} else {} end)
    + (if $ag != "" then {add_as_global_source: ($ag == "true")} else {} end)')
  nia_post "$BASE_URL/sources" "$DATA"
}

# ─── list — list all indexed HuggingFace datasets
cmd_list() {
  nia_get "$BASE_URL/sources?type=huggingface_dataset"
}

# ─── dispatch ─────────────────────────────────────────────────────────────────
case "${1:-}" in
  index) shift; cmd_index "$@" ;;
  list)  shift; cmd_list "$@" ;;
  *)
    echo "Usage: $(basename "$0") <command> [args...]"
    echo ""
    echo "Commands:"
    echo "  index   Index a HuggingFace dataset"
    echo "  list    List indexed datasets"
    exit 1
    ;;
esac

#!/usr/bin/env bash
# Nia Dependencies — analyze and subscribe to dependency docs
# Usage: deps.sh <command> [args...]
set -e
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
source "$SCRIPT_DIR/lib.sh"

# ─── analyze — parse a manifest file and return its dependency list with docs links
cmd_analyze() {
  if [ -z "$1" ]; then echo "Usage: deps.sh analyze <manifest_file>"; return 1; fi
  if [ ! -f "$1" ]; then echo "Error: File not found: $1"; return 1; fi
  local content filename
  content=$(cat "$1")
  filename=$(basename "$1")
  DATA=$(jq -n --arg content "$content" --arg filename "$filename" \
    '{manifest_content: $content, filename: $filename}')
  nia_post "$BASE_URL/dependencies/analyze" "$DATA"
}

# ─── subscribe — auto-index documentation for every dependency in a manifest
cmd_subscribe() {
  if [ -z "$1" ]; then
    echo "Usage: deps.sh subscribe <manifest_file> [max_new_indexes]"
    echo "  Env: INCLUDE_DEV (true/false)"
    return 1
  fi
  if [ ! -f "$1" ]; then echo "Error: File not found: $1"; return 1; fi
  local content filename max_new
  content=$(cat "$1")
  filename=$(basename "$1")
  max_new="${2:-150}"
  DATA=$(jq -n --arg content "$content" --arg filename "$filename" \
    --argjson max "$max_new" --arg dev "${INCLUDE_DEV:-false}" \
    '{manifest_content: $content, filename: $filename, max_new_indexes: $max,
     include_dev_dependencies: ($dev == "true")}')
  nia_post "$BASE_URL/dependencies/subscribe" "$DATA"
}

# ─── upload — upload a manifest file directly (multipart) and subscribe to deps
cmd_upload() {
  if [ -z "$1" ]; then
    echo "Usage: deps.sh upload <manifest_file> [max_new_indexes]"
    echo "  Env: INCLUDE_DEV (true/false)"
    return 1
  fi
  if [ ! -f "$1" ]; then echo "Error: File not found: $1"; return 1; fi
  local max_new="${2:-150}"
  curl -s -X POST "$BASE_URL/dependencies/upload" \
    -H "Authorization: Bearer $NIA_KEY" \
    -F "file=@$1" \
    -F "include_dev_dependencies=${INCLUDE_DEV:-false}" \
    -F "max_new_indexes=${max_new}" | jq '.'
}

# ─── dispatch ─────────────────────────────────────────────────────────────────
case "${1:-}" in
  analyze)   shift; cmd_analyze "$@" ;;
  subscribe) shift; cmd_subscribe "$@" ;;
  upload)    shift; cmd_upload "$@" ;;
  *)
    echo "Usage: $(basename "$0") <command> [args...]"
    echo ""
    echo "Commands:"
    echo "  analyze    Analyze a package manifest file"
    echo "  subscribe  Subscribe to docs for all dependencies"
    echo "  upload     Upload manifest and subscribe (multipart)"
    exit 1
    ;;
esac

#!/usr/bin/env bash
# Nia Document Agent — query indexed documents with AI
# Usage: document.sh <source_id> <query>
set -e
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
source "$SCRIPT_DIR/lib.sh"

if [ -z "$1" ] || [ -z "$2" ]; then
  echo "Usage: document.sh <source_id> <query>"
  echo ""
  echo "Query an indexed PDF or document with an AI agent that uses tools"
  echo "(search, read sections, read pages) to research and answer with citations."
  echo ""
  echo "Environment variables:"
  echo "  MODEL             Model to use (claude-opus-4-6-1m, claude-opus-4-6, claude-sonnet-4-5-20250929)"
  echo "  THINKING          Enable extended thinking (true/false, default: true)"
  echo "  THINKING_BUDGET   Token budget for thinking (1000-50000, default: 10000)"
  echo "  STREAM            Stream response as SSE (true/false, default: false)"
  echo "  JSON_SCHEMA       JSON schema string for structured output"
  echo "  JSON_SCHEMA_FILE  Path to JSON schema file for structured output"
  exit 1
fi

SID=$(resolve_source_id "$1")
QUERY="$2"

# Handle JSON schema from file or string
SCHEMA_JSON="null"
if [ -n "${JSON_SCHEMA_FILE:-}" ] && [ -f "$JSON_SCHEMA_FILE" ]; then
  SCHEMA_JSON=$(cat "$JSON_SCHEMA_FILE")
elif [ -n "${JSON_SCHEMA:-}" ]; then
  SCHEMA_JSON="$JSON_SCHEMA"
fi

DATA=$(jq -n \
  --arg sid "$SID" --arg q "$QUERY" \
  --argjson schema "$SCHEMA_JSON" \
  --arg model "${MODEL:-}" --arg thinking "${THINKING:-}" \
  --arg budget "${THINKING_BUDGET:-}" --arg stream "${STREAM:-}" \
  '{source_id: $sid, query: $q}
  + (if $schema != null then {json_schema: $schema} else {} end)
  + (if $model != "" then {model: $model} else {} end)
  + (if $thinking != "" then {thinking_enabled: ($thinking == "true")} else {} end)
  + (if $budget != "" then {thinking_budget: ($budget | tonumber)} else {} end)
  + (if $stream != "" then {stream: ($stream == "true")} else {} end)')

nia_post "$BASE_URL/document/agent" "$DATA"

#!/usr/bin/env bash
# Nia Extract — structured data extraction from documents
# Usage: extract.sh <command> [args...]
set -e
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
source "$SCRIPT_DIR/lib.sh"

# ─── start — start a table extraction with a JSON schema
cmd_start() {
  if [ -z "$1" ]; then
    echo "Usage: extract.sh start <json_schema_file_or_string>"
    echo "  Env: URL (document URL), SOURCE_ID, PAGE_RANGE (e.g. '1-5')"
    return 1
  fi
  local schema
  if [ -f "$1" ]; then
    schema=$(cat "$1")
  else
    schema="$1"
  fi
  DATA=$(jq -n \
    --argjson schema "$schema" \
    --arg url "${URL:-}" --arg sid "${SOURCE_ID:-}" --arg pages "${PAGE_RANGE:-}" \
    '{json_schema: $schema}
    + (if $url != "" then {url: $url} else {} end)
    + (if $sid != "" then {source_id: $sid} else {} end)
    + (if $pages != "" then {page_range: $pages} else {} end)')
  nia_post "$BASE_URL/extract" "$DATA"
}

# ─── get — get extraction status and results
cmd_get() {
  if [ -z "$1" ]; then echo "Usage: extract.sh get <extraction_id>"; return 1; fi
  nia_get "$BASE_URL/extract/$1"
}

# ─── engineering — start an engineering extraction
cmd_engineering() {
  if [ -z "${URL:-}${SOURCE_ID:-}" ]; then
    echo "Usage: extract.sh engineering"
    echo "  Env: URL (document URL) or SOURCE_ID, PAGE_RANGE, ACCURACY_MODE (fast|accurate)"
    return 1
  fi
  DATA=$(jq -n \
    --arg url "${URL:-}" --arg sid "${SOURCE_ID:-}" \
    --arg pages "${PAGE_RANGE:-}" --arg mode "${ACCURACY_MODE:-fast}" \
    '{accuracy_mode: $mode}
    + (if $url != "" then {url: $url} else {} end)
    + (if $sid != "" then {source_id: $sid} else {} end)
    + (if $pages != "" then {page_range: $pages} else {} end)')
  nia_post "$BASE_URL/extract/engineering" "$DATA"
}

# ─── engineering-get — get engineering extraction status and results
cmd_engineering_get() {
  if [ -z "$1" ]; then echo "Usage: extract.sh engineering-get <extraction_id>"; return 1; fi
  nia_get "$BASE_URL/extract/engineering/$1"
}

# ─── engineering-query — query an engineering extraction
cmd_engineering_query() {
  if [ -z "$1" ] || [ -z "$2" ]; then
    echo "Usage: extract.sh engineering-query <extraction_id> <query>"
    return 1
  fi
  DATA=$(jq -n --arg q "$2" '{query: $q}')
  nia_post "$BASE_URL/extract/engineering/$1/query" "$DATA"
}

# ─── list — list all extractions
cmd_list() {
  local url="$BASE_URL/extractions" sep="?"
  if [ -n "${EXTRACT_TYPE:-}" ]; then url="${url}${sep}type=${EXTRACT_TYPE}"; sep="&"; fi
  if [ -n "${1:-}" ]; then url="${url}${sep}limit=$1"; sep="&"; fi
  if [ -n "${2:-}" ]; then url="${url}${sep}offset=$2"; fi
  nia_get "$url"
}

# ─── dispatch ─────────────────────────────────────────────────────────────────
case "${1:-}" in
  start)             shift; cmd_start "$@" ;;
  get)               shift; cmd_get "$@" ;;
  engineering)       shift; cmd_engineering "$@" ;;
  engineering-get)   shift; cmd_engineering_get "$@" ;;
  engineering-query) shift; cmd_engineering_query "$@" ;;
  list)              shift; cmd_list "$@" ;;
  *)
    echo "Usage: $(basename "$0") <command> [args...]"
    echo ""
    echo "Structured data extraction from documents."
    echo ""
    echo "Commands:"
    echo "  start              Start table extraction with JSON schema"
    echo "  get                Get extraction status/results"
    echo "  engineering        Start engineering extraction"
    echo "  engineering-get    Get engineering extraction status/results"
    echo "  engineering-query  Query an engineering extraction"
    echo "  list               List all extractions [limit] [offset]"
    echo ""
    echo "Env: EXTRACT_TYPE (table|engineering) for list filtering"
    exit 1
    ;;
esac

#!/usr/bin/env bash
# Nia Local Folders — private file storage and search
# Usage: folders.sh <command> [args...]
set -e
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
source "$SCRIPT_DIR/lib.sh"

# helper: scan local dir into JSON files array
_scan_folder() {
  local folder_path="$1"
  local files_json="[]"
  while IFS= read -r -d '' file; do
    local rel="${file#$folder_path/}"
    if file "$file" | grep -q "text"; then
      local content
      content=$(cat "$file" 2>/dev/null || echo "")
      if [ -n "$content" ]; then
        files_json=$(echo "$files_json" | jq --arg p "$rel" --arg c "$content" '. + [{path: $p, content: $c}]')
      fi
    fi
  done < <(find "$folder_path" -type f -not -path '*/\.*' -not -name '*.pyc' -not -name '*.o' -not -name '*.so' -print0 2>/dev/null)
  echo "$files_json"
}

# ─── create — upload a local directory to Nia as a private, searchable folder
cmd_create() {
  if [ -z "$1" ]; then echo "Usage: folders.sh create /path/to/folder [display_name]"; return 1; fi
  if [ ! -d "$1" ]; then echo "Error: Directory not found: $1"; return 1; fi
  local folder_name="$(basename "$1")"
  local display_name="${2:-${DISPLAY_NAME:-}}"
  local files_json
  files_json=$(_scan_folder "$1")
  local count
  count=$(echo "$files_json" | jq 'length')
  echo "Found $count text files to index"
  if [ "$count" -eq 0 ]; then echo "Error: No indexable files"; return 1; fi
  DATA=$(jq -n --arg folder_name "$folder_name" --arg path "$1" --argjson files "$files_json" --arg display_name "$display_name" \
    '{type: "local_folder", folder_name: $folder_name, folder_path: $path, files: $files}
    + (if $display_name != "" then {display_name: $display_name} else {} end)')
  nia_post "$BASE_URL/sources" "$DATA"
}

# ─── create-db — upload a database file as a private local source
cmd_create_db() {
  if [ -z "$1" ]; then
    echo "Usage: folders.sh create-db <database_file> [display_name]"
    return 1
  fi
  if [ ! -f "$1" ]; then echo "Error: File not found: $1"; return 1; fi
  local filename display_name encoded
  filename="$(basename "$1")"
  display_name="${2:-${DISPLAY_NAME:-$filename}}"
  encoded=$(base64 < "$1" | tr -d '\n')
  DATA=$(jq -n --arg name "$display_name" --arg filename "$filename" --arg content "$encoded" \
    '{type: "local_folder", folder_name: $name, display_name: $name, database: {filename: $filename, content: $content}}')
  nia_post "$BASE_URL/sources" "$DATA"
}

# ─── list — list all local folders, optionally filtered by status/query/category
cmd_list() {
  local limit="${1:-50}" offset="${2:-0}"
  local url="$BASE_URL/sources?type=local_folder&limit=${limit}&offset=${offset}"
  if [ -n "${STATUS:-}" ]; then url="${url}&status=$(echo "$STATUS" | jq -Rr @uri)"; fi
  if [ -n "${QUERY:-}" ]; then url="${url}&query=$(echo "$QUERY" | jq -Rr @uri)"; fi
  if [ -n "${CATEGORY_ID:-}" ]; then url="${url}&category_id=$(echo "$CATEGORY_ID" | jq -Rr @uri)"; fi
  nia_get "$url"
}

# ─── get — fetch details for a single local folder by ID
cmd_get() {
  if [ -z "$1" ]; then echo "Usage: folders.sh get <folder_id>"; return 1; fi
  local sid
  sid=$(resolve_source_id "$1" local_folder)
  nia_get "$BASE_URL/sources/${sid}?type=local_folder"
}

# ─── delete — remove a local folder and its indexed content
cmd_delete() {
  if [ -z "$1" ]; then echo "Usage: folders.sh delete <folder_id>"; return 1; fi
  local sid
  sid=$(resolve_source_id "$1" local_folder)
  nia_delete "$BASE_URL/sources/${sid}?type=local_folder"
}

# ─── rename — change the display name of a local folder
cmd_rename() {
  if [ -z "$1" ] || [ -z "$2" ]; then echo "Usage: folders.sh rename <folder_id> <new_name>"; return 1; fi
  local sid
  sid=$(resolve_source_id "$1" local_folder)
  DATA=$(jq -n --arg name "$2" '{display_name: $name}')
  nia_patch "$BASE_URL/sources/${sid}?type=local_folder" "$DATA"
}

# ─── tree — print the file tree of a local folder
cmd_tree() {
  if [ -z "$1" ]; then echo "Usage: folders.sh tree <folder_id>"; return 1; fi
  local sid
  sid=$(resolve_source_id "$1" local_folder)
  local url="$BASE_URL/sources/${sid}/tree?type=local_folder&max_depth=${MAX_DEPTH:-10}"
  nia_get_raw "$url" | jq '.tree_string // .formatted_tree // .'
}

# ─── ls — list files and subdirectories at a path in a local folder
cmd_ls() {
  if [ -z "$1" ]; then echo "Usage: folders.sh ls <folder_id>"; return 1; fi
  if [ -n "${2:-}" ]; then
    echo "Error: path-scoped ls is not exposed by the unified /sources tree endpoint. Use tree, read, or grep."
    return 1
  fi
  MAX_DEPTH="${MAX_DEPTH:-2}" cmd_tree "$1"
}

# ─── read — read file content from a local folder by path and optional line range
cmd_read() {
  if [ -z "$1" ] || [ -z "$2" ]; then
    echo "Usage: folders.sh read <folder_id> <file_path>"
    echo "  Env: LINE_START, LINE_END, MAX_LENGTH"
    return 1
  fi
  local sid fpath url
  sid=$(resolve_source_id "$1" local_folder)
  fpath=$(urlencode "$2")
  url="$BASE_URL/sources/${sid}/content?type=local_folder&path=${fpath}"
  if [ -n "${LINE_START:-}" ]; then url="${url}&line_start=${LINE_START}"; fi
  if [ -n "${LINE_END:-}" ]; then url="${url}&line_end=${LINE_END}"; fi
  if [ -n "${MAX_LENGTH:-}" ]; then url="${url}&max_length=${MAX_LENGTH}"; fi
  nia_get_raw "$url" | jq -r '.content // .'
}

# ─── grep — regex search across all files in a local folder
cmd_grep() {
  if [ -z "$1" ] || [ -z "$2" ]; then
    echo "Usage: folders.sh grep <folder_id> <pattern> [path_prefix]"
    echo "  Env: CASE_SENSITIVE, WHOLE_WORD, FIXED_STRING, OUTPUT_MODE,"
    echo "       HIGHLIGHT, EXHAUSTIVE, LINES_AFTER, LINES_BEFORE, MAX_PER_FILE, MAX_TOTAL"
    return 1
  fi
  local sid
  sid=$(resolve_source_id "$1" local_folder)
  DATA=$(build_grep_json "$2" "${3:-}")
  nia_post "$BASE_URL/sources/${sid}/grep?type=local_folder" "$DATA"
}

# ─── classify — auto-classify folder files into your categories using AI
cmd_classify() {
  if [ -z "$1" ]; then
    echo "Usage: folders.sh classify <folder_id> [categories_csv]"
    echo "  categories_csv  Comma-separated category names (uses existing categories if omitted)"
    return 1
  fi
  local cats="${2:-}"
  if [ -n "$cats" ]; then
    DATA=$(jq -n --arg c "$cats" '{categories: ($c | split(","))}')
  else
    # Fetch existing categories and pass them
    local existing
    existing=$(nia_get_raw "$BASE_URL/categories" | jq -r '[.items[]?.name // empty] | join(",")')
    if [ -z "$existing" ]; then
      echo "Error: No categories found. Create some first with: categories.sh create <name>"
      return 1
    fi
    DATA=$(jq -n --arg c "$existing" '{categories: ($c | split(","))}')
  fi
  if [ -n "${INCLUDE_UNCATEGORIZED:-}" ]; then
    DATA=$(echo "$DATA" | jq --arg iu "$INCLUDE_UNCATEGORIZED" '. + {include_uncategorized: ($iu == "true")}')
  fi
  local sid
  sid=$(resolve_source_id "$1" local_folder)
  nia_patch "$BASE_URL/sources/${sid}/classification?type=local_folder" "$DATA"
}

# ─── classification — get the current classification result for a folder
cmd_classification() {
  if [ -z "$1" ]; then echo "Usage: folders.sh classification <folder_id>"; return 1; fi
  local sid
  sid=$(resolve_source_id "$1" local_folder)
  nia_get "$BASE_URL/sources/${sid}/classification?type=local_folder"
}

# ─── sync — re-upload local files to an existing folder to pick up changes
cmd_sync() {
  if [ -z "$1" ] || [ -z "$2" ]; then echo "Usage: folders.sh sync <folder_id> /path/to/folder"; return 1; fi
  if [ ! -d "$2" ]; then echo "Error: Directory not found: $2"; return 1; fi
  local sid
  sid=$(resolve_source_id "$1" local_folder)
  local files_json
  files_json=$(_scan_folder "$2")
  local count
  count=$(echo "$files_json" | jq 'length')
  echo "Syncing $count text files"
  DATA=$(jq -n --arg path "$2" --argjson files "$files_json" '{folder_path: $path, files: $files}')
  nia_post "$BASE_URL/sources/${sid}/sync?type=local_folder" "$DATA"
}

# ─── assign-category — assign or remove a category for a local folder
cmd_assign_category() {
  if [ -z "$1" ] || [ -z "$2" ]; then echo "Usage: folders.sh assign-category <folder_id> <category_id|null>"; return 1; fi
  local sid
  sid=$(resolve_source_id "$1" local_folder)
  if [ "$2" = "null" ]; then
    DATA='{"category_id": null}'
  else
    DATA=$(jq -n --arg c "$2" '{category_id: $c}')
  fi
  nia_patch "$BASE_URL/sources/${sid}?type=local_folder" "$DATA"
}

# ─── dispatch ─────────────────────────────────────────────────────────────────
case "${1:-}" in
  create)          shift; cmd_create "$@" ;;
  create-db)       shift; cmd_create_db "$@" ;;
  list)            shift; cmd_list "$@" ;;
  get)             shift; cmd_get "$@" ;;
  delete)          shift; cmd_delete "$@" ;;
  rename)          shift; cmd_rename "$@" ;;
  tree)            shift; cmd_tree "$@" ;;
  ls)              shift; cmd_ls "$@" ;;
  read)            shift; cmd_read "$@" ;;
  grep)            shift; cmd_grep "$@" ;;
  classify)        shift; cmd_classify "$@" ;;
  classification)  shift; cmd_classification "$@" ;;
  sync)            shift; cmd_sync "$@" ;;
  assign-category) shift; cmd_assign_category "$@" ;;
  *)
    echo "Usage: $(basename "$0") <command> [args...]"
    echo ""
    echo "Commands:"
    echo "  create          Create folder from local directory"
    echo "  create-db       Create local source from database file"
    echo "  list            List local folders"
    echo "  get             Get folder details"
    echo "  delete          Delete a folder"
    echo "  rename          Rename a folder"
    echo "  tree            Get folder file tree"
    echo "  ls              List directory in folder"
    echo "  read            Read file from folder"
    echo "  grep            Search folder content with regex"
    echo "  classify        Auto-classify folder into categories"
    echo "  classification  Get folder classification"
    echo "  sync            Re-sync folder from local path"
    echo "  assign-category Assign/remove category"
    exit 1
    ;;
esac

#!/usr/bin/env bash
# Nia FS — filesystem operations on indexed sources
# Usage: fs.sh <command> [args...]
set -e
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
source "$SCRIPT_DIR/lib.sh"

# ─── info — get filesystem info for a source
cmd_info() {
  if [ -z "$1" ]; then echo "Usage: fs.sh info <source_id>"; return 1; fi
  local sid=$(resolve_source_id "$1")
  nia_get "$BASE_URL/fs/${sid}/info"
}

# ─── tree — get the file tree of a source
cmd_tree() {
  if [ -z "$1" ]; then echo "Usage: fs.sh tree <source_id> [path]"; return 1; fi
  local sid=$(resolve_source_id "$1")
  local url="$BASE_URL/fs/${sid}/tree"
  if [ -n "${2:-}" ]; then url="${url}?path=$(urlencode "$2")"; fi
  nia_get "$url"
}

# ─── ls — list directory contents
cmd_ls() {
  if [ -z "$1" ]; then echo "Usage: fs.sh ls <source_id> [path]"; return 1; fi
  local sid=$(resolve_source_id "$1")
  local path="${2:-/}"
  nia_get "$BASE_URL/fs/${sid}/ls?path=$(urlencode "$path")"
}

# ─── read — read a file from an indexed source
cmd_read() {
  if [ -z "$1" ] || [ -z "$2" ]; then
    echo "Usage: fs.sh read <source_id> <path> [line_start] [line_end]"
    return 1
  fi
  local sid=$(resolve_source_id "$1")
  local url="$BASE_URL/fs/${sid}/read?path=$(urlencode "$2")"
  if [ -n "${3:-}" ]; then url="${url}&line_start=$3"; fi
  if [ -n "${4:-}" ]; then url="${url}&line_end=$4"; fi
  nia_get "$url"
}

# ─── find — find files matching a glob pattern
cmd_find() {
  if [ -z "$1" ] || [ -z "$2" ]; then
    echo "Usage: fs.sh find <source_id> <glob_pattern>"
    echo "  pattern: e.g. '**/*.ts', 'src/*.py'"
    return 1
  fi
  local sid=$(resolve_source_id "$1")
  nia_get "$BASE_URL/fs/${sid}/find?pattern=$(urlencode "$2")"
}

# ─── grep — regex search in source files
cmd_grep() {
  if [ -z "$1" ] || [ -z "$2" ]; then
    echo "Usage: fs.sh grep <source_id> <pattern> [path]"
    echo "  Env: CASE_SENSITIVE, WHOLE_WORD, FIXED_STRING, OUTPUT_MODE,"
    echo "       HIGHLIGHT, LINES_AFTER, LINES_BEFORE, MAX_PER_FILE, MAX_TOTAL,"
    echo "       CONTEXT_LINES, MULTILINE, INCLUDE_LINE_NUMBERS"
    return 1
  fi
  local sid=$(resolve_source_id "$1")
  DATA=$(build_grep_json "$2" "${3:-}")
  nia_post "$BASE_URL/fs/${sid}/grep" "$DATA"
}

# ─── write — write a file to an indexed source
cmd_write() {
  if [ -z "$1" ] || [ -z "$2" ]; then
    echo "Usage: fs.sh write <source_id> <path> [local_file]"
    echo "  Reads content from local_file or stdin"
    echo "  Env: LANGUAGE, ENCODING (default: utf8)"
    return 1
  fi
  local sid=$(resolve_source_id "$1")
  local path="$2" body
  if [ -n "${3:-}" ] && [ -f "$3" ]; then
    body=$(cat "$3")
  else
    body=$(cat)
  fi
  DATA=$(jq -n \
    --arg path "$path" --arg body "$body" \
    --arg lang "${LANGUAGE:-}" --arg enc "${ENCODING:-utf8}" \
    '{path: $path, body: $body, encoding: $enc}
    + (if $lang != "" then {language: $lang} else {} end)')
  nia_put "$BASE_URL/fs/${sid}/files" "$DATA"
}

# ─── write-batch — write multiple files at once
cmd_write_batch() {
  if [ -z "$1" ] || [ -z "$2" ]; then
    echo "Usage: fs.sh write-batch <source_id> <files_json>"
    echo '  files_json: [{"path":"a.txt","body":"content"}, ...]'
    return 1
  fi
  local sid=$(resolve_source_id "$1")
  DATA=$(jq -n --argjson files "$2" '{files: $files}')
  nia_put "$BASE_URL/fs/${sid}/files/batch" "$DATA"
}

# ─── delete — delete a file from an indexed source
cmd_delete() {
  if [ -z "$1" ] || [ -z "$2" ]; then
    echo "Usage: fs.sh delete <source_id> <path>"
    return 1
  fi
  local sid=$(resolve_source_id "$1")
  nia_curl DELETE "$BASE_URL/fs/${sid}/files?path=$(urlencode "$2")" | jq '.'
}

# ─── mkdir — create a directory in an indexed source
cmd_mkdir() {
  if [ -z "$1" ] || [ -z "$2" ]; then
    echo "Usage: fs.sh mkdir <source_id> <path>"
    return 1
  fi
  local sid=$(resolve_source_id "$1")
  DATA=$(jq -n --arg path "$2" '{path: $path}')
  nia_post "$BASE_URL/fs/${sid}/mkdir" "$DATA"
}

# ─── mv — move/rename a file in an indexed source
cmd_mv() {
  if [ -z "$1" ] || [ -z "$2" ] || [ -z "$3" ]; then
    echo "Usage: fs.sh mv <source_id> <old_path> <new_path>"
    return 1
  fi
  local sid=$(resolve_source_id "$1")
  DATA=$(jq -n --arg old "$2" --arg new "$3" '{old_path: $old, new_path: $new}')
  nia_post "$BASE_URL/fs/${sid}/mv" "$DATA"
}

# ─── dispatch ─────────────────────────────────────────────────────────────────
case "${1:-}" in
  info)        shift; cmd_info "$@" ;;
  tree)        shift; cmd_tree "$@" ;;
  ls)          shift; cmd_ls "$@" ;;
  read)        shift; cmd_read "$@" ;;
  find)        shift; cmd_find "$@" ;;
  grep)        shift; cmd_grep "$@" ;;
  write)       shift; cmd_write "$@" ;;
  write-batch) shift; cmd_write_batch "$@" ;;
  delete)      shift; cmd_delete "$@" ;;
  mkdir)       shift; cmd_mkdir "$@" ;;
  mv)          shift; cmd_mv "$@" ;;
  *)
    echo "Usage: $(basename "$0") <command> [args...]"
    echo ""
    echo "Filesystem operations on indexed sources."
    echo ""
    echo "Commands:"
    echo "  info         Get source filesystem info"
    echo "  tree         Get file tree [path]"
    echo "  ls           List directory contents [path]"
    echo "  read         Read a file [line_start] [line_end]"
    echo "  find         Find files by glob pattern"
    echo "  grep         Regex search in files"
    echo "  write        Write a file (from file or stdin)"
    echo "  write-batch  Write multiple files at once"
    echo "  delete       Delete a file"
    echo "  mkdir        Create a directory"
    echo "  mv           Move/rename a file"
    exit 1
    ;;
esac

#!/usr/bin/env bash
# Nia GitHub — live GitHub search and repository exploration (no indexing required)
# Usage: github.sh <command> [args...]
set -e
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
source "$SCRIPT_DIR/lib.sh"

# ─── glob — find files matching a glob pattern in a repo
cmd_glob() {
  if [ -z "$1" ] || [ -z "$2" ]; then
    echo "Usage: github.sh glob <owner/repo> <pattern> [ref]"
    echo "  pattern: glob (e.g., '*.py', 'src/**/*.ts')"
    return 1
  fi
  DATA=$(jq -n --arg repo "$1" --arg pat "$2" --arg ref "${3:-HEAD}" \
    '{repository: $repo, pattern: $pat, ref: $ref}')
  nia_post "$BASE_URL/github/glob" "$DATA"
}

# ─── read — read a file from a GitHub repo with optional line range
cmd_read() {
  if [ -z "$1" ] || [ -z "$2" ]; then
    echo "Usage: github.sh read <owner/repo> <path> [ref] [start_line] [end_line]"
    return 1
  fi
  DATA=$(jq -n --arg repo "$1" --arg path "$2" --arg ref "${3:-HEAD}" \
    --arg sl "${4:-}" --arg el "${5:-}" \
    '{repository: $repo, path: $path, ref: $ref}
    + (if $sl != "" then {start_line: ($sl | tonumber)} else {} end)
    + (if $el != "" then {end_line: ($el | tonumber)} else {} end)')
  nia_post "$BASE_URL/github/read" "$DATA"
}

# ─── search — code search using GitHub's Code Search API
cmd_search() {
  if [ -z "$1" ] || [ -z "$2" ]; then
    echo "Usage: github.sh search <owner/repo> <query> [per_page] [page]"
    return 1
  fi
  DATA=$(jq -n --arg repo "$1" --arg q "$2" \
    --argjson pp "${3:-30}" --argjson pg "${4:-1}" \
    '{query: $q, repository: $repo, per_page: $pp, page: $pg}')
  nia_post "$BASE_URL/github/search" "$DATA"
}

# ─── tree — get the file tree of a GitHub repo or subdirectory
cmd_tree() {
  if [ -z "$1" ]; then
    echo "Usage: github.sh tree <owner/repo> [ref] [path]"
    return 1
  fi
  local owner repo
  owner="${1%%/*}"
  repo="${1#*/}"
  local url="$BASE_URL/github/tree/${owner}/${repo}"
  local params=""
  if [ -n "${2:-}" ]; then params="${params}&ref=$2"; fi
  if [ -n "${3:-}" ]; then params="${params}&path=$3"; fi
  if [ -n "$params" ]; then url="${url}?${params#&}"; fi
  nia_get "$url"
}

# ─── dispatch ─────────────────────────────────────────────────────────────────
case "${1:-}" in
  glob)   shift; cmd_glob "$@" ;;
  read)   shift; cmd_read "$@" ;;
  search) shift; cmd_search "$@" ;;
  tree)   shift; cmd_tree "$@" ;;
  *)
    echo "Usage: $(basename "$0") <command> [args...]"
    echo ""
    echo "Live GitHub search and exploration — no indexing required."
    echo "Rate limited to 10 req/min by GitHub for code search."
    echo ""
    echo "Commands:"
    echo "  glob    Find files matching a glob pattern"
    echo "  read    Read a file (with optional line range)"
    echo "  search  Code search (GitHub Code Search API)"
    echo "  tree    Get repository file tree"
    echo ""
    echo "For indexed repo operations, use repos.sh instead."
    echo "For autonomous repo research, use tracer.sh."
    exit 1
    ;;
esac

#!/usr/bin/env bash
# Nia Google Drive — installation management and Drive indexing
# Usage: google-drive.sh <command> [args...]
set -e
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
source "$SCRIPT_DIR/lib.sh"

# ─── install — generate a Google Drive OAuth authorization URL
cmd_install() {
  DATA=$(jq -n --arg redirect "${1:-${REDIRECT_URI:-}}" --arg scopes "${SCOPES:-}" \
    '{}
    + (if $redirect != "" then {redirect_uri: $redirect} else {} end)
    + (if $scopes != "" then {scopes: ($scopes | split(","))} else {} end)')
  nia_post "$BASE_URL/google-drive/install" "$DATA"
}

# ─── callback — exchange OAuth code for tokens and create the installation
cmd_callback() {
  if [ -z "$1" ]; then
    echo "Usage: google-drive.sh callback <code> [redirect_uri]"
    return 1
  fi
  DATA=$(jq -n --arg code "$1" --arg redirect "${2:-${REDIRECT_URI:-}}" \
    '{code: $code}
    + (if $redirect != "" then {redirect_uri: $redirect} else {} end)')
  nia_post "$BASE_URL/google-drive/install/callback" "$DATA"
}

# ─── list — list all Google Drive installations
cmd_list() {
  nia_get "$BASE_URL/google-drive/installations"
}

# ─── get — get details for a specific Google Drive installation
cmd_get() {
  if [ -z "$1" ]; then echo "Usage: google-drive.sh get <installation_id>"; return 1; fi
  nia_get "$BASE_URL/google-drive/installations/$1"
}

# ─── delete — disconnect a Google Drive installation
cmd_delete() {
  if [ -z "$1" ]; then echo "Usage: google-drive.sh delete <installation_id>"; return 1; fi
  nia_delete "$BASE_URL/google-drive/installations/$1"
}

# ─── browse — browse Drive files/folders before selecting what to index
cmd_browse() {
  if [ -z "$1" ]; then
    echo "Usage: google-drive.sh browse <installation_id> [folder_id] [query] [page_token] [page_size]"
    return 1
  fi
  local installation_id="$1"
  local folder_id="${2:-}"
  local query="${3:-}"
  local page_token="${4:-}"
  local page_size="${5:-${PAGE_SIZE:-100}}"
  local url="$BASE_URL/google-drive/installations/${installation_id}/browse?page_size=${page_size}"
  if [ -n "$folder_id" ]; then url="${url}&folder_id=$(echo "$folder_id" | jq -Rr @uri)"; fi
  if [ -n "$query" ]; then url="${url}&q=$(echo "$query" | jq -Rr @uri)"; fi
  if [ -n "$page_token" ]; then url="${url}&page_token=$(echo "$page_token" | jq -Rr @uri)"; fi
  nia_get "$url"
}

# ─── index — trigger Drive indexing for explicit file/folder IDs
cmd_index() {
  if [ -z "$1" ]; then
    echo "Usage: google-drive.sh index <installation_id> [file_ids_csv] [folder_ids_csv] [display_name]"
    echo "  Env: FILE_IDS, FOLDER_IDS, DISPLAY_NAME"
    return 1
  fi
  local file_ids_csv="${2:-${FILE_IDS:-}}"
  local folder_ids_csv="${3:-${FOLDER_IDS:-}}"
  local display_name="${4:-${DISPLAY_NAME:-}}"
  DATA=$(jq -n \
    --arg f "$file_ids_csv" --arg d "$folder_ids_csv" --arg n "$display_name" \
    '{} + (if $f != "" then {file_ids: ($f | split(","))} else {} end)
       + (if $d != "" then {folder_ids: ($d | split(","))} else {} end)
       + (if $n != "" then {display_name: $n} else {} end)')
  nia_post "$BASE_URL/google-drive/installations/$1/index" "$DATA"
}

# ─── selection — fetch the current selected Drive scope
cmd_selection() {
  if [ -z "$1" ]; then echo "Usage: google-drive.sh selection <installation_id>"; return 1; fi
  nia_get "$BASE_URL/google-drive/installations/$1/selection"
}

# ─── update-selection — replace the Drive selection with file/folder IDs
cmd_update_selection() {
  if [ -z "$1" ] || [ -z "${2:-${ITEM_IDS:-}}" ]; then
    echo "Usage: google-drive.sh update-selection <installation_id> <item_ids_csv> [display_name]"
    echo "  Env: ITEM_IDS, DISPLAY_NAME"
    return 1
  fi
  local item_ids_csv="${2:-${ITEM_IDS:-}}"
  local display_name="${3:-${DISPLAY_NAME:-}}"
  DATA=$(jq -n --arg ids "$item_ids_csv" --arg n "$display_name" \
    '{item_ids: ($ids | split(","))}
    + (if $n != "" then {display_name: $n} else {} end)')
  nia_post "$BASE_URL/google-drive/installations/$1/selection" "$DATA"
}

# ─── status — get Drive indexing/sync status
cmd_status() {
  if [ -z "$1" ]; then echo "Usage: google-drive.sh status <installation_id>"; return 1; fi
  nia_get "$BASE_URL/google-drive/installations/$1/status"
}

# ─── sync — trigger incremental or full sync for an installation
cmd_sync() {
  if [ -z "$1" ]; then
    echo "Usage: google-drive.sh sync <installation_id> [scope_ids_csv]"
    echo "  Env: FORCE_FULL=true"
    return 1
  fi
  local scope_ids_csv="${2:-${SCOPE_IDS:-}}"
  DATA=$(jq -n --arg scopes "$scope_ids_csv" --arg full "${FORCE_FULL:-}" \
    '{} + (if $full != "" then {force_full: ($full == "true")} else {} end)
       + (if $scopes != "" then {scope_ids: ($scopes | split(","))} else {} end)')
  nia_post "$BASE_URL/google-drive/installations/$1/sync" "$DATA"
}

# ─── dispatch ─────────────────────────────────────────────────────────────────
case "${1:-}" in
  install)           shift; cmd_install "$@" ;;
  callback)          shift; cmd_callback "$@" ;;
  list)              shift; cmd_list "$@" ;;
  get)               shift; cmd_get "$@" ;;
  delete)            shift; cmd_delete "$@" ;;
  browse)            shift; cmd_browse "$@" ;;
  index)             shift; cmd_index "$@" ;;
  selection)         shift; cmd_selection "$@" ;;
  update-selection)  shift; cmd_update_selection "$@" ;;
  status)            shift; cmd_status "$@" ;;
  sync)              shift; cmd_sync "$@" ;;
  *)
    echo "Usage: $(basename "$0") <command> [args...]"
    echo ""
    echo "Commands:"
    echo "  install           Generate Google Drive OAuth URL"
    echo "  callback          Exchange OAuth code for tokens"
    echo "  list              List Google Drive installations"
    echo "  get               Get installation details"
    echo "  delete            Disconnect installation"
    echo "  browse            Browse Drive files/folders"
    echo "  index             Trigger indexing for file/folder IDs"
    echo "  selection         Get current Drive selection"
    echo "  update-selection  Update selected Drive items"
    echo "  status            Get indexing/sync status"
    echo "  sync              Trigger incremental/full sync"
    exit 1
    ;;
esac