Sem Integration

# sem Detection and Installation

## Detection Logic

1. Check session cache at
   `$CLAUDE_CODE_TMPDIR/sem-available`
2. If cache exists, use cached value
3. If no cache, run `command -v sem`
4. Write result to cache

## Install-on-First-Use

When sem is not detected, present installation options
in priority order:

**Rust toolchain (preferred, works on all platforms):**

```bash
cargo install --locked sem-cli
```

**macOS (Homebrew, if formula exists):**

```bash
brew search sem-cli && brew install sem-cli
```

Note: the Homebrew formula may not exist. If `brew search`
returns no results, fall back to `cargo install` above.

**Linux (binary download):**

```bash
mkdir -p ~/.local/bin && curl -fsSL https://github.com/Ataraxy-Labs/sem/releases/latest/download/sem-x86_64-unknown-linux-gnu -o ~/.local/bin/sem && chmod +x ~/.local/bin/sem
```

## Prompt Template

When sem is missing, say:

> sem (semantic diff tool) can provide entity-level diffs
> instead of line-level diffs. Install it?
>
> - `cargo install --locked sem-cli` (any platform with Rust)
> - `brew install sem-cli` (macOS, if formula available)
> - Linux binary: `mkdir -p ~/.local/bin && curl -fsSL
>   https://github.com/Ataraxy-Labs/sem/releases/latest/download/sem-x86_64-unknown-linux-gnu
>   -o ~/.local/bin/sem && chmod +x ~/.local/bin/sem`
> - Or skip to use standard git diff

If the user declines, write `0` to the cache and
proceed with fallback for the rest of the session.

## Cache Invalidation

The cache file is in `$CLAUDE_CODE_TMPDIR` which is
per-session. No explicit invalidation needed: each new
Claude Code session starts fresh.


---
name: fallback
description: Output normalization for git diff fallback path
parent_skill: leyline:sem-integration
estimated_tokens: 250
---

# Fallback Output Normalization

When sem is unavailable, produce entity-like output from
standard git commands.

## Entity Schema

sem produces raw output with these fields:

```json
{
  "entityId": "module::Class.method",
  "entityType": "function|class|method",
  "entityName": "method",
  "changeType": "added|modified|deleted|renamed",
  "filePath": "path/to/file.py"
}
```

The normalization layer maps these to a common schema
used by consumer skills:

```json
{
  "name": "entity_or_filename",
  "kind": "function|class|file",
  "change_type": "added|modified|deleted|renamed",
  "file": "path/to/file.py"
}
```

Mapping: `entityName` to `name`, `entityType` to `kind`,
`changeType` to `change_type`, `filePath` to `file`.
Fallback uses `file` as the kind since git diff
operates at file level.

## Fallback Commands

```bash
# Collect changes by type
added=$(git diff --name-only --diff-filter=A <baseline>)
modified=$(git diff --name-only --diff-filter=M <baseline>)
deleted=$(git diff --name-only --diff-filter=D <baseline>)
renamed=$(git diff --name-only --diff-filter=R <baseline>)
```

## Entity Extraction from Diff Hunks

For richer fallback (optional), parse diff hunks for
function/class definitions:

```bash
# Extract added functions from diff (includes async def)
git diff <baseline> | grep -E '^\+(async )?def |^\+class ' | \
  sed 's/^+//' | sed 's/(.*//'
```

This gives function-level granularity without sem,
though it misses renames, decorated definitions, and
cross-file dependencies.

## Impact Fallback

When `sem impact` is unavailable, trace callers with rg:

```bash
# For each changed file, find importers
git diff --name-only HEAD | while read f; do
  module=$(basename "$f" .py)
  if command -v rg &>/dev/null; then
    rg -l "import.*$module|from.*$module" --type py .
  else
    grep -rl "import.*$module\|from.*$module" \
      --include="*.py" .
  fi
done | sort -u
```


---
name: sem-integration
description: Provides sem semantic-diff detection, install-on-first-use, and fallback patterns. Use when building skills that consume git diff out