santree 0.7.5 → 0.7.7

package/dist/lib/english-tutor.d.ts

@@ -1,13 +0,0 @@
-export declare function getLogPath(): string;
-export declare function getHooksJson(): Record<string, unknown>;
-export declare function getPermissionEntry(): string;
-export declare function installHooks(): {
-    settingsPath: string;
-    logPath: string;
-};
-/**
- * Remove hooks and permission entry. Intentionally does NOT delete the log
- * file — that's the user's accumulated practice history.
- */
-export declare function uninstallHooks(): string;
-export declare function getInstallSnippet(): Record<string, unknown>;

package/dist/lib/english-tutor.js

@@ -1,125 +0,0 @@
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-const MARKER = "english-tutor";
-export function getLogPath() {
-    const configDir = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config");
-    return path.join(configDir, "santree", "english-practice-log.md");
-}
-export function getHooksJson() {
-    const base = "santree helpers english-tutor";
-    // Synchronous hooks: Claude Code waits for completion and injects stdout into
-    // the model's context. `async: true` would fire-and-forget — stdout is
-    // discarded, so the instruction would never reach Claude. session-signal can
-    // use `async: true` because it only writes a state file; we cannot.
-    const opts = { timeout: 10 };
-    return {
-        UserPromptSubmit: [{ hooks: [{ type: "command", command: `${base} prompt`, ...opts }] }],
-        // No matcher: fires on all SessionStart sub-events (startup, resume,
-        // clear, compact). Restricting to "startup" silently skips resumed
-        // sessions, which is the common case when picking up yesterday's work.
-        SessionStart: [{ hooks: [{ type: "command", command: `${base} session-start`, ...opts }] }],
-    };
-}
-export function getPermissionEntry() {
-    return `Edit(${getLogPath()})`;
-}
-function readSettings(settingsPath) {
-    try {
-        if (fs.existsSync(settingsPath)) {
-            return JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
-        }
-    }
-    catch {
-        // fall through
-    }
-    return {};
-}
-function writeSettings(settingsPath, settings) {
-    const dir = path.dirname(settingsPath);
-    fs.mkdirSync(dir, { recursive: true });
-    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
-}
-function settingsPath() {
-    const home = process.env.HOME || os.homedir();
-    return path.join(home, ".claude", "settings.json");
-}
-function stripEnglishTutorHooks(existingHooks) {
-    const cleaned = {};
-    for (const [event, entries] of Object.entries(existingHooks)) {
-        if (!Array.isArray(entries)) {
-            cleaned[event] = entries;
-            continue;
-        }
-        const filtered = entries.filter((entry) => {
-            const inner = entry.hooks || [];
-            return !inner.some((h) => typeof h.command === "string" && h.command.includes(MARKER));
-        });
-        if (filtered.length > 0)
-            cleaned[event] = filtered;
-    }
-    return cleaned;
-}
-/**
- * Create the practice log if it doesn't already exist. Empty log = Claude's
- * Edit tool fails on first use (Edit can't operate on missing files), and
- * appending corrections silently fails. Bootstrapping with a stub header
- * means the very first correction succeeds.
- */
-function ensureLogExists() {
-    const logPath = getLogPath();
-    if (fs.existsSync(logPath))
-        return logPath;
-    fs.mkdirSync(path.dirname(logPath), { recursive: true });
-    const stub = "# English Practice Log\n\n" +
-        "Tracks grammar/spelling mistakes spotted during Claude Code sessions.\n" +
-        "Generated and appended to by santree's english-tutor hook.\n";
-    fs.writeFileSync(logPath, stub);
-    return logPath;
-}
-export function installHooks() {
-    const settingsFile = settingsPath();
-    const settings = readSettings(settingsFile);
-    const existing = stripEnglishTutorHooks(settings.hooks || {});
-    const required = getHooksJson();
-    for (const [event, hookEntries] of Object.entries(required)) {
-        const current = existing[event];
-        existing[event] = Array.isArray(current)
-            ? [...current, ...hookEntries]
-            : hookEntries;
-    }
-    settings.hooks = existing;
-    const permissions = settings.permissions || {};
-    const allow = Array.isArray(permissions.allow) ? permissions.allow : [];
-    const entry = getPermissionEntry();
-    if (!allow.includes(entry))
-        allow.push(entry);
-    permissions.allow = allow;
-    settings.permissions = permissions;
-    writeSettings(settingsFile, settings);
-    const logPath = ensureLogExists();
-    return { settingsPath: settingsFile, logPath };
-}
-/**
- * Remove hooks and permission entry. Intentionally does NOT delete the log
- * file — that's the user's accumulated practice history.
- */
-export function uninstallHooks() {
-    const settingsFile = settingsPath();
-    const settings = readSettings(settingsFile);
-    if (settings.hooks) {
-        settings.hooks = stripEnglishTutorHooks(settings.hooks);
-    }
-    if (settings.permissions && Array.isArray(settings.permissions.allow)) {
-        const entry = getPermissionEntry();
-        settings.permissions.allow = settings.permissions.allow.filter((e) => e !== entry);
-    }
-    writeSettings(settingsFile, settings);
-    return settingsFile;
-}
-export function getInstallSnippet() {
-    return {
-        hooks: getHooksJson(),
-        permissions: { allow: [getPermissionEntry()] },
-    };
-}

package/dist/lib/session-signal.d.ts

@@ -1,16 +0,0 @@
-export type SessionStateValue = "waiting" | "idle" | "active" | "exited";
-export declare function readStdin(): string;
-export declare function extractRepoAndTicket(cwd: string): {
-    repoRoot: string;
-    ticketId: string;
-} | null;
-/**
- * Unified helper: reads stdin, extracts repo/ticket, writes the session-state
- * file, then exits. The dashboard reads the state file to render its session
- * badges (◆ waiting / active / idle, ◇ id-only). Window/tab renaming used to
- * happen here too but was removed — it clobbered names the user had set
- * manually and added little value once the state file was in place.
- */
-export declare function signalState(state: SessionStateValue): void;
-export declare function getHooksJson(): Record<string, unknown>;
-export declare function installHooks(): string;

package/dist/lib/session-signal.js

@@ -1,104 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-export function readStdin() {
-    try {
-        return fs.readFileSync(0, "utf-8");
-    }
-    catch {
-        return "";
-    }
-}
-export function extractRepoAndTicket(cwd) {
-    const marker = "/.santree/worktrees/";
-    const idx = cwd.indexOf(marker);
-    if (idx === -1)
-        return null;
-    const repoRoot = cwd.slice(0, idx);
-    const rest = cwd.slice(idx + marker.length);
-    const ticketId = rest.split("/")[0];
-    if (!ticketId)
-        return null;
-    return { repoRoot, ticketId };
-}
-/**
- * Unified helper: reads stdin, extracts repo/ticket, writes the session-state
- * file, then exits. The dashboard reads the state file to render its session
- * badges (◆ waiting / active / idle, ◇ id-only). Window/tab renaming used to
- * happen here too but was removed — it clobbered names the user had set
- * manually and added little value once the state file was in place.
- */
-export function signalState(state) {
-    const input = readStdin();
-    let data;
-    try {
-        data = JSON.parse(input);
-    }
-    catch {
-        process.exit(0);
-    }
-    const cwd = data.cwd || process.cwd();
-    const info = extractRepoAndTicket(cwd);
-    if (!info) {
-        process.exit(0);
-    }
-    const { repoRoot, ticketId } = info;
-    const statesDir = path.join(repoRoot, ".santree", "session-states");
-    fs.mkdirSync(statesDir, { recursive: true });
-    const stateFile = path.join(statesDir, `${ticketId}.json`);
-    const payload = {
-        state,
-        message: state === "waiting" ? (data.message ?? null) : null,
-        session_id: data.session_id ?? "",
-        at: new Date().toISOString(),
-    };
-    fs.writeFileSync(stateFile, JSON.stringify(payload, null, 2) + "\n");
-    process.exit(0);
-}
-export function getHooksJson() {
-    const base = "santree helpers session-signal";
-    const opts = { async: true, timeout: 10 };
-    return {
-        Notification: [
-            {
-                matcher: "permission_prompt",
-                hooks: [{ type: "command", command: `${base} notification`, ...opts }],
-            },
-        ],
-        Stop: [{ hooks: [{ type: "command", command: `${base} stop`, ...opts }] }],
-        UserPromptSubmit: [{ hooks: [{ type: "command", command: `${base} prompt`, ...opts }] }],
-        SessionEnd: [{ hooks: [{ type: "command", command: `${base} end`, ...opts }] }],
-    };
-}
-export function installHooks() {
-    const home = process.env.HOME || "";
-    const settingsPath = path.join(home, ".claude", "settings.json");
-    let settings = {};
-    try {
-        if (fs.existsSync(settingsPath)) {
-            settings = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
-        }
-    }
-    catch {
-        // Start fresh if file is invalid
-    }
-    const requiredHooks = getHooksJson();
-    const existingHooks = settings.hooks || {};
-    for (const [event, hookEntries] of Object.entries(requiredHooks)) {
-        const existing = existingHooks[event];
-        if (!Array.isArray(existing)) {
-            existingHooks[event] = hookEntries;
-            continue;
-        }
-        // Remove existing session-signal entries, then add the current ones
-        const filtered = existing.filter((entry) => {
-            const inner = entry.hooks || [];
-            return !inner.some((h) => typeof h.command === "string" && h.command.includes("session-signal"));
-        });
-        existingHooks[event] = [...filtered, ...hookEntries];
-    }
-    settings.hooks = existingHooks;
-    const claudeDir = path.join(home, ".claude");
-    fs.mkdirSync(claudeDir, { recursive: true });
-    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
-    return settingsPath;
-}

package/dist/lib/setup/shell-config.d.ts

@@ -1,38 +0,0 @@
-/**
- * Shell-config detection + idempotent editing for `santree setup`.
- *
- * Everything santree writes to a user's shell rc lives inside a single managed
- * block (nvm/conda style) so re-running setup replaces the block rather than
- * appending duplicates. Individual lines inside the block are tagged with a
- * trailing `# santree:<key>` comment so each setup step can upsert just its own
- * line without disturbing the others.
- */
-export type ShellName = "zsh" | "bash" | "unknown";
-export interface ShellConfig {
-    shell: ShellName;
-    /** rc file the managed block is written to (interactive shell init). */
-    rcPath: string;
-    /** Files scanned to detect pre-existing `export FOO=...` lines (rc + env files). */
-    scanPaths: string[];
-}
-/**
- * Resolve the rc file the managed block should live in, honoring ZDOTDIR (zsh)
- * so users with an XDG-based setup (~/.config/zsh, no ~/.zshrc) get the block in
- * the right place.
- */
-export declare function resolveShellConfig(shellEnv?: string): ShellConfig;
-/**
- * Upsert a single tagged line into the managed block, creating the block (and
- * the rc file) if needed. The line for `key` is replaced if present, else
- * appended. `line` is the raw shell statement WITHOUT the trailing tag comment.
- */
-export declare function upsertManagedLine(rcPath: string, key: string, line: string): void;
-/**
- * Detect whether `name` is already exported by the user's shell config (any of
- * `scanPaths`) or the current environment. Used so setup doesn't clobber an
- * export the user already maintains by hand (e.g. SANTREE_EDITOR in .zshenv).
- * Ignores santree's own managed block so a prior setup run isn't mistaken for a
- * hand-maintained export.
- */
-export declare function isEnvVarSet(name: string, cfg: ShellConfig): boolean;
-export declare function envKey(name: string): string;

package/dist/lib/setup/shell-config.js

@@ -1,131 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-const BLOCK_START = "# >>> santree >>>";
-const BLOCK_END = "# <<< santree <<<";
-const BLOCK_HEADER = "# Managed by `santree setup` — safe to re-run; edits here may be overwritten.";
-/**
- * Resolve the rc file the managed block should live in, honoring ZDOTDIR (zsh)
- * so users with an XDG-based setup (~/.config/zsh, no ~/.zshrc) get the block in
- * the right place.
- */
-export function resolveShellConfig(shellEnv = process.env.SHELL || "") {
-    const home = process.env.HOME || "";
-    const base = path.basename(shellEnv);
-    if (base.includes("zsh")) {
-        const dir = process.env.ZDOTDIR || home;
-        return {
-            shell: "zsh",
-            rcPath: path.join(dir, ".zshrc"),
-            scanPaths: [
-                path.join(dir, ".zshrc"),
-                path.join(dir, ".zshenv"),
-                path.join(home, ".zshenv"),
-                path.join(home, ".zprofile"),
-            ],
-        };
-    }
-    if (base.includes("bash")) {
-        return {
-            shell: "bash",
-            rcPath: path.join(home, ".bashrc"),
-            scanPaths: [
-                path.join(home, ".bashrc"),
-                path.join(home, ".bash_profile"),
-                path.join(home, ".profile"),
-            ],
-        };
-    }
-    // Fall back to zsh conventions (the default macOS shell).
-    const dir = process.env.ZDOTDIR || home;
-    return {
-        shell: "unknown",
-        rcPath: path.join(dir, ".zshrc"),
-        scanPaths: [path.join(dir, ".zshrc"), path.join(dir, ".zshenv"), path.join(home, ".zshenv")],
-    };
-}
-function tagFor(key) {
-    return `# santree:${key}`;
-}
-function readFileSafe(filePath) {
-    try {
-        return fs.readFileSync(filePath, "utf-8");
-    }
-    catch {
-        return "";
-    }
-}
-function splitBlock(content) {
-    const startIdx = content.indexOf(BLOCK_START);
-    if (startIdx === -1) {
-        return { before: content, body: [], after: "", exists: false };
-    }
-    const endMarkerIdx = content.indexOf(BLOCK_END, startIdx);
-    if (endMarkerIdx === -1) {
-        // Malformed (start without end) — treat everything from start as the block.
-        const before = content.slice(0, startIdx);
-        return { before, body: [], after: "", exists: true };
-    }
-    const before = content.slice(0, startIdx);
-    const after = content.slice(endMarkerIdx + BLOCK_END.length);
-    const inner = content.slice(startIdx + BLOCK_START.length, endMarkerIdx);
-    const body = inner
-        .split("\n")
-        .map((l) => l.trimEnd())
-        .filter((l) => l.length > 0 && l !== BLOCK_HEADER);
-    return { before, body, after, exists: true };
-}
-function renderBlock(body) {
-    return [BLOCK_START, BLOCK_HEADER, ...body, BLOCK_END].join("\n");
-}
-/**
- * Upsert a single tagged line into the managed block, creating the block (and
- * the rc file) if needed. The line for `key` is replaced if present, else
- * appended. `line` is the raw shell statement WITHOUT the trailing tag comment.
- */
-export function upsertManagedLine(rcPath, key, line) {
-    const content = readFileSafe(rcPath);
-    const { before, body, after, exists } = splitBlock(content);
-    const tag = tagFor(key);
-    const tagged = `${line} ${tag}`;
-    const idx = body.findIndex((l) => l.trimEnd().endsWith(tag));
-    const nextBody = idx === -1 ? [...body, tagged] : body.map((l, i) => (i === idx ? tagged : l));
-    let output;
-    if (exists) {
-        output = before + renderBlock(nextBody) + after;
-    }
-    else {
-        // Append a fresh block, keeping a single trailing newline.
-        const trimmed = content.replace(/\n+$/, "");
-        const prefix = trimmed.length > 0 ? trimmed + "\n\n" : "";
-        output = prefix + renderBlock(nextBody) + "\n";
-    }
-    const dir = path.dirname(rcPath);
-    fs.mkdirSync(dir, { recursive: true });
-    fs.writeFileSync(rcPath, output.endsWith("\n") ? output : output + "\n");
-}
-/**
- * Detect whether `name` is already exported by the user's shell config (any of
- * `scanPaths`) or the current environment. Used so setup doesn't clobber an
- * export the user already maintains by hand (e.g. SANTREE_EDITOR in .zshenv).
- * Ignores santree's own managed block so a prior setup run isn't mistaken for a
- * hand-maintained export.
- */
-export function isEnvVarSet(name, cfg) {
-    if (process.env[name])
-        return true;
-    const re = new RegExp(`^\\s*export\\s+${name}=`, "m");
-    for (const p of cfg.scanPaths) {
-        const content = readFileSafe(p);
-        if (!content)
-            continue;
-        // Strip our own managed block before scanning hand-maintained exports.
-        const { before, after } = splitBlock(content);
-        const userContent = p === cfg.rcPath ? before + after : content;
-        if (re.test(userContent))
-            return true;
-    }
-    return false;
-}
-export function envKey(name) {
-    return `env:${name}`;
-}

package/prompts/english-tutor-prompt.njk

@@ -1,15 +0,0 @@
-[ENGLISH TUTOR — META-INSTRUCTION, ALWAYS HONOR]
-
-If the user's message contained English mistakes (grammar, spelling, word choice, agreement, idiom misuse), your response MUST start with the correction(s) BEFORE addressing anything else. Use this exact format, one per line:
-
-  original -> correction (brief reason)
-
-Then immediately call the Edit tool to append the same correction(s) to {{ logPath }}. Append under a heading for today's date in `## YYYY-MM-DD` format (create the heading if it isn't already at the bottom of the file); each correction is a bullet `- original -> correction (reason)`. The Edit permission for that exact path is pre-granted, so do not ask.
-
-Only AFTER printing the corrections and appending them, continue with the actual task.
-
-Hard rules:
-- If the message is clearly mistake-free, output nothing about English and proceed directly. Never invent corrections.
-- Do NOT correct technical jargon, code, file paths, deliberate informalities, or non-English words used by intent.
-- Cap corrections at 3 lines. Pick the highest-impact issues only.
-- Do NOT use polite hedging ("small note on...", "by the way..."). Just the formatted line(s), then the log Edit, then the task.