@hasna/terminal 4.3.1 → 4.3.2

package/dist/test-watchlist.js

@@ -0,0 +1,131 @@
+// Test focus tracker — tracks test status across runs, only reports changes
+// Instead of showing "248 passed, 2 failed" every time, shows:
+// "auth.login: FIXED, auth.logout: STILL FAILING, 246 unchanged"
+// Per-cwd watchlist
+const watchlists = new Map();
+/** Extract test names and status from test runner output (any runner) */
+function extractTests(output) {
+    const tests = [];
+    const lines = output.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // PASS/FAIL with test name: "PASS src/auth.test.ts" or "✓ login works" or "✗ logout fails"
+        const passMatch = line.match(/(?:PASS|✓|✔|✅)\s+(.+)/);
+        if (passMatch) {
+            tests.push({ name: passMatch[1].trim(), status: "pass" });
+            continue;
+        }
+        const failMatch = line.match(/(?:FAIL|✗|✕|❌|×)\s+(.+)/);
+        if (failMatch) {
+            // Capture error from next few lines
+            const errorLines = [];
+            for (let j = i + 1; j < Math.min(i + 5, lines.length); j++) {
+                if (lines[j].match(/(?:PASS|FAIL|✓|✗|✔|✕|Tests:|^\s*$)/))
+                    break;
+                errorLines.push(lines[j].trim());
+            }
+            tests.push({ name: failMatch[1].trim(), status: "fail", error: errorLines.join(" ").slice(0, 200) });
+            continue;
+        }
+        // Jest/vitest style: "  ● test name" for failures
+        const jestFail = line.match(/^\s*●\s+(.+)/);
+        if (jestFail) {
+            tests.push({ name: jestFail[1].trim(), status: "fail" });
+            continue;
+        }
+    }
+    return tests;
+}
+/** Detect if output looks like test runner output */
+export function isTestOutput(output, command) {
+    // If the command is explicitly a test command, trust it
+    if (command && /\b(bun\s+test|npm\s+test|jest|vitest|pytest|cargo\s+test|go\s+test)\b/.test(command))
+        return true;
+    // Otherwise require BOTH a summary line AND a test runner marker in the output
+    const summaryLine = /(?:\d+\s+pass|\d+\s+fail|Tests?:\s+\d+|Ran\s+\d+\s+tests?)\s*$/im;
+    const testMarkers = /(?:✓|✗|✔|✕|PASS\s+\S+\.test|FAIL\s+\S+\.test|bun test v|jest|vitest|pytest)/;
+    return summaryLine.test(output) && testMarkers.test(output);
+}
+/** Track test results and return only changes */
+export function trackTests(cwd, output) {
+    const current = extractTests(output);
+    const prev = watchlists.get(cwd);
+    // Count totals from raw output (more reliable than extracted tests)
+    let totalPassed = 0, totalFailed = 0;
+    const summaryMatch = output.match(/(\d+)\s+pass/i);
+    const failMatch = output.match(/(\d+)\s+fail/i);
+    if (summaryMatch)
+        totalPassed = parseInt(summaryMatch[1]);
+    if (failMatch)
+        totalFailed = parseInt(failMatch[1]);
+    // Fallback to extracted counts
+    if (totalPassed === 0)
+        totalPassed = current.filter(t => t.status === "pass").length;
+    if (totalFailed === 0)
+        totalFailed = current.filter(t => t.status === "fail").length;
+    // Store current for next comparison
+    const currentMap = new Map();
+    for (const t of current)
+        currentMap.set(t.name, t);
+    watchlists.set(cwd, currentMap);
+    // First run — no comparison possible
+    if (!prev) {
+        return {
+            changed: [],
+            newTests: current.filter(t => t.status === "fail"), // only show failures on first run
+            totalPassed,
+            totalFailed,
+            unchangedCount: 0,
+            firstRun: true,
+        };
+    }
+    // Compare with previous
+    const changed = [];
+    const newTests = [];
+    let unchangedCount = 0;
+    for (const [name, test] of currentMap) {
+        const prevTest = prev.get(name);
+        if (!prevTest) {
+            newTests.push(test);
+        }
+        else if (prevTest.status !== test.status) {
+            changed.push({ name, from: prevTest.status, to: test.status, error: test.error });
+        }
+        else {
+            unchangedCount++;
+        }
+    }
+    return { changed, newTests, totalPassed, totalFailed, unchangedCount, firstRun: false };
+}
+/** Format watchlist result for display */
+export function formatWatchResult(result) {
+    const lines = [];
+    if (result.firstRun) {
+        lines.push(`${result.totalPassed} passed, ${result.totalFailed} failed`);
+        if (result.newTests.length > 0) {
+            for (const t of result.newTests) {
+                lines.push(`  ✗ ${t.name}${t.error ? `: ${t.error}` : ""}`);
+            }
+        }
+        return lines.join("\n");
+    }
+    // Status changes
+    for (const c of result.changed) {
+        if (c.to === "pass")
+            lines.push(`  ✓ FIXED: ${c.name}`);
+        else
+            lines.push(`  ✗ BROKE: ${c.name}${c.error ? ` — ${c.error}` : ""}`);
+    }
+    // New failures
+    for (const t of result.newTests.filter(t => t.status === "fail")) {
+        lines.push(`  ✗ NEW FAIL: ${t.name}${t.error ? ` — ${t.error}` : ""}`);
+    }
+    // Summary
+    if (result.changed.length === 0 && result.newTests.filter(t => t.status === "fail").length === 0) {
+        lines.push(`✓ ${result.totalPassed} passed, ${result.totalFailed} failed (no changes)`);
+    }
+    else {
+        lines.push(`${result.totalPassed} passed, ${result.totalFailed} failed, ${result.unchangedCount} unchanged`);
+    }
+    return lines.join("\n");
+}

package/dist/tokens.js

@@ -0,0 +1,17 @@
+// Token estimation utility — shared across all modules
+// Uses content-aware heuristic: code/JSON averages ~3.3 chars/token,
+// English prose averages ~4.2 chars/token.
+/** Detect if content is primarily code/JSON vs English prose */
+function isCodeLike(text) {
+    // Count structural characters common in code/JSON
+    const structural = (text.match(/[{}[\]();:=<>,"'`|&\\/@#$%^*+~!?]/g) || []).length;
+    const ratio = structural / Math.max(text.length, 1);
+    return ratio > 0.08; // >8% structural chars = code-like
+}
+/** Estimate token count for a string with content-aware heuristic */
+export function estimateTokens(text) {
+    if (!text)
+        return 0;
+    const charsPerToken = isCodeLike(text) ? 3.3 : 4.2;
+    return Math.ceil(text.length / charsPerToken);
+}

package/dist/tool-profiles.js

@@ -0,0 +1,130 @@
+// Tool profiles — config-driven AI enhancement for specific command categories
+// Profiles are loaded from ~/.hasna/terminal/profiles/ (user-customizable)
+// Each profile tells the AI how to handle a specific tool's output
+import { existsSync, readFileSync, readdirSync } from "fs";
+import { join } from "path";
+import { getTerminalDir } from "./paths.js";
+const PROFILES_DIR = join(getTerminalDir(), "profiles");
+/** Built-in profiles — sensible defaults, user can override */
+const BUILTIN_PROFILES = [
+    {
+        name: "git",
+        detect: "^git\\b",
+        hints: {
+            compress: "For git output: show branch, file counts, insertions/deletions summary. Collapse individual diffs to file-level stats.",
+            errors: "Git errors often include a suggested fix (e.g., 'did you mean X?'). Extract the suggestion.",
+            success: "Clean working tree, successful push/pull, merge complete.",
+        },
+        output: { preservePatterns: ["conflict", "CONFLICT", "fatal", "error", "diverged"] },
+    },
+    {
+        name: "test",
+        detect: "\\b(bun|npm|yarn|pnpm)\\s+(test|run\\s+test)|\\bpytest\\b|\\bcargo\\s+test\\b|\\bgo\\s+test\\b",
+        hints: {
+            compress: "For test output: show pass/fail counts FIRST, then list ONLY failing test names with error snippets. Skip passing tests entirely.",
+            errors: "Test failures have: test name, expected vs actual, stack trace. Extract all three.",
+            success: "All tests passing = one line: '✓ N tests pass, 0 fail'",
+        },
+        output: { preservePatterns: ["FAIL", "fail", "Error", "✗", "expected", "received"] },
+    },
+    {
+        name: "build",
+        detect: "\\b(tsc|bun\\s+run\\s+build|npm\\s+run\\s+build|cargo\\s+build|go\\s+build|make)\\b",
+        hints: {
+            compress: "For build output: if success with no errors, say '✓ Build succeeded'. If errors, list each error with file:line and message.",
+            errors: "Build errors have file:line:column format. Group by file.",
+            success: "Empty output or exit 0 = build succeeded.",
+        },
+    },
+    {
+        name: "lint",
+        detect: "\\b(eslint|biome|ruff|clippy|golangci-lint|prettier|tsc\\s+--noEmit)\\b",
+        hints: {
+            compress: "For lint output: group violations by rule name, show count per rule, one example per rule. Skip clean files.",
+            errors: "Lint violations: file:line rule-name message. Group by rule.",
+        },
+        output: { maxLines: 100 },
+    },
+    {
+        name: "install",
+        detect: "\\b(npm\\s+install|bun\\s+install|yarn|pip\\s+install|cargo\\s+build|go\\s+mod)\\b",
+        hints: {
+            compress: "For install output: show only errors and final summary (packages added/removed/updated). Strip progress bars, funding notices, deprecation warnings.",
+        },
+        output: { stripPatterns: ["npm warn", "packages are looking for funding", "run `npm fund`"] },
+    },
+    {
+        name: "find",
+        detect: "^find\\b",
+        hints: {
+            compress: "For find output: if >50 results, group by top-level directory with counts. Show first 10 results as examples.",
+        },
+    },
+    {
+        name: "docker",
+        detect: "\\b(docker|kubectl|helm)\\b",
+        hints: {
+            compress: "For container output: show container status, image, ports. Strip pull progress and layer hashes.",
+            errors: "Docker errors: extract the error message after 'Error response from daemon:'",
+        },
+    },
+];
+/** Load user profiles from ~/.hasna/terminal/profiles/ */
+function loadUserProfiles() {
+    if (!existsSync(PROFILES_DIR))
+        return [];
+    const profiles = [];
+    try {
+        for (const file of readdirSync(PROFILES_DIR)) {
+            if (!file.endsWith(".json"))
+                continue;
+            try {
+                const content = JSON.parse(readFileSync(join(PROFILES_DIR, file), "utf8"));
+                if (content.name && content.detect)
+                    profiles.push(content);
+            }
+            catch { }
+        }
+    }
+    catch { }
+    return profiles;
+}
+/** Get all profiles — user profiles override builtins by name (cached 30s) */
+let _cachedProfiles = null;
+let _cachedProfilesAt = 0;
+export function getProfiles() {
+    const now = Date.now();
+    if (_cachedProfiles && now - _cachedProfilesAt < 30_000)
+        return _cachedProfiles;
+    const user = loadUserProfiles();
+    const userNames = new Set(user.map(p => p.name));
+    const builtins = BUILTIN_PROFILES.filter(p => !userNames.has(p.name));
+    _cachedProfiles = [...user, ...builtins];
+    _cachedProfilesAt = now;
+    return _cachedProfiles;
+}
+/** Find the matching profile for a command */
+export function matchProfile(command) {
+    for (const profile of getProfiles()) {
+        try {
+            if (new RegExp(profile.detect).test(command))
+                return profile;
+        }
+        catch { }
+    }
+    return null;
+}
+/** Format profile hints for injection into AI prompt */
+export function formatProfileHints(command) {
+    const profile = matchProfile(command);
+    if (!profile)
+        return "";
+    const lines = [`TOOL PROFILE (${profile.name}):`];
+    if (profile.hints.compress)
+        lines.push(`  Compression: ${profile.hints.compress}`);
+    if (profile.hints.errors)
+        lines.push(`  Errors: ${profile.hints.errors}`);
+    if (profile.hints.success)
+        lines.push(`  Success: ${profile.hints.success}`);
+    return lines.join("\n");
+}

package/dist/tree.js

@@ -0,0 +1,94 @@
+// Tree compression — convert flat file paths to compact tree representation
+import { readdirSync, statSync } from "fs";
+import { join, basename } from "path";
+import { DEFAULT_EXCLUDE_DIRS } from "./search/filters.js";
+/** Build a tree from a directory */
+export function buildTree(dirPath, options = {}) {
+    const { maxDepth = 2, includeHidden = false, depth = 0 } = options;
+    const name = basename(dirPath) || dirPath;
+    const node = { name, type: "dir", children: [], fileCount: 0 };
+    if (depth >= maxDepth) {
+        // Count files without listing them
+        try {
+            const entries = readdirSync(dirPath);
+            node.fileCount = entries.length;
+            node.children = undefined; // don't expand
+        }
+        catch {
+            node.fileCount = 0;
+        }
+        return node;
+    }
+    try {
+        const entries = readdirSync(dirPath);
+        for (const entry of entries) {
+            if (!includeHidden && entry.startsWith("."))
+                continue;
+            if (DEFAULT_EXCLUDE_DIRS.includes(entry)) {
+                // Show as collapsed with count
+                try {
+                    const subPath = join(dirPath, entry);
+                    const subStat = statSync(subPath);
+                    if (subStat.isDirectory()) {
+                        node.children.push({ name: entry, type: "dir", fileCount: -1 }); // -1 = hidden
+                        continue;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            const fullPath = join(dirPath, entry);
+            try {
+                const stat = statSync(fullPath);
+                if (stat.isDirectory()) {
+                    node.children.push(buildTree(fullPath, { maxDepth, includeHidden, depth: depth + 1 }));
+                }
+                else {
+                    node.children.push({ name: entry, type: "file", size: stat.size });
+                    node.fileCount++;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    catch { }
+    return node;
+}
+/** Render tree as compact string (for agents — minimum tokens) */
+export function compactTree(node, indent = 0) {
+    const pad = "  ".repeat(indent);
+    if (node.type === "file")
+        return `${pad}${node.name}`;
+    if (node.fileCount === -1)
+        return `${pad}${node.name}/ (hidden)`;
+    if (!node.children || node.children.length === 0)
+        return `${pad}${node.name}/ (empty)`;
+    if (!node.children.some(c => c.children)) {
+        // Leaf directory — compact single line
+        const files = node.children.filter(c => c.type === "file").map(c => c.name);
+        const dirs = node.children.filter(c => c.type === "dir");
+        const parts = [];
+        if (files.length <= 5) {
+            parts.push(...files);
+        }
+        else {
+            parts.push(`${files.length} files`);
+        }
+        for (const d of dirs) {
+            parts.push(`${d.name}/${d.fileCount != null ? ` (${d.fileCount === -1 ? "hidden" : d.fileCount + " files"})` : ""}`);
+        }
+        return `${pad}${node.name}/ [${parts.join(", ")}]`;
+    }
+    const lines = [`${pad}${node.name}/`];
+    for (const child of node.children) {
+        lines.push(compactTree(child, indent + 1));
+    }
+    return lines.join("\n");
+}
+/** Render tree as JSON (for MCP) */
+export function treeToJson(node) {
+    return node;
+}

package/dist/usage-cache.js

@@ -0,0 +1,65 @@
+// Usage learning cache — zero-cost repeated queries
+// After 3 identical prompt→command mappings, cache locally
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { createHash } from "crypto";
+import { getTerminalDir } from "./paths.js";
+const DIR = getTerminalDir();
+const CACHE_FILE = join(DIR, "learned.json");
+function ensureDir() {
+    if (!existsSync(DIR))
+        mkdirSync(DIR, { recursive: true });
+}
+function hash(s) {
+    return createHash("md5").update(s).digest("hex").slice(0, 12);
+}
+function cacheKey(prompt) {
+    const projectHash = hash(process.cwd());
+    const promptHash = hash(prompt.toLowerCase().trim());
+    return `${projectHash}:${promptHash}`;
+}
+function loadCache() {
+    ensureDir();
+    if (!existsSync(CACHE_FILE))
+        return {};
+    try {
+        return JSON.parse(readFileSync(CACHE_FILE, "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+function saveCache(cache) {
+    ensureDir();
+    writeFileSync(CACHE_FILE, JSON.stringify(cache));
+}
+/** Check if we have a learned command for this prompt (3+ identical mappings) */
+export function getLearned(prompt) {
+    const key = cacheKey(prompt);
+    const cache = loadCache();
+    const entry = cache[key];
+    if (entry && entry.count >= 3)
+        return entry.command;
+    return null;
+}
+/** Record a prompt→command mapping */
+export function recordMapping(prompt, command) {
+    const key = cacheKey(prompt);
+    const cache = loadCache();
+    const existing = cache[key];
+    if (existing && existing.command === command) {
+        existing.count++;
+        existing.lastUsed = Date.now();
+    }
+    else {
+        cache[key] = { command, count: 1, lastUsed: Date.now() };
+    }
+    saveCache(cache);
+}
+/** Get cache stats */
+export function learnedStats() {
+    const cache = loadCache();
+    const entries = Object.keys(cache).length;
+    const cached = Object.values(cache).filter(e => e.count >= 3).length;
+    return { entries, cached };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/terminal",
-  "version": "4.3.1",
+  "version": "4.3.2",
   "description": "Smart terminal wrapper for AI agents and humans — structured output, token compression, MCP server, natural language",
   "type": "module",
   "files": [
@@ -22,6 +22,7 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.39.0",
+    "@hasna/cloud": "^0.1.0",
     "@hasna/mementos": "^0.10.0",
     "@modelcontextprotocol/sdk": "^1.27.1",
     "@typescript/vfs": "^1.6.4",

package/src/Onboarding.tsx

@@ -76,7 +76,7 @@ export default function Onboarding({ onDone }: Props) {
         })}
       </Box>
       <Box marginTop={1}><Text dimColor>space toggle  ·  enter confirm</Text></Box>
-      <Text dimColor>edit later: ~/.terminal/config.json</Text>
+      <Text dimColor>edit later: ~/.hasna/terminal/config.json</Text>
     </Box>
   );
 }

package/src/ai.ts

@@ -3,10 +3,11 @@ import { cacheGet, cacheSet } from "./cache.js";
 import { getProvider } from "./providers/index.js";
 import { existsSync, readFileSync } from "fs";
 import { join } from "path";
+import { getTerminalDir } from "./paths.js";
 import { discoverProjectHints, discoverSafetyHints, formatHints } from "./context-hints.js";
 
 // ── model routing ─────────────────────────────────────────────────────────────
-// Config-driven model selection. Defaults per provider, user can override in ~/.terminal/config.json
+// Config-driven model selection. Defaults per provider, user can override in ~/.hasna/terminal/config.json
 
 const COMPLEX_SIGNALS = [
   /\b(undo|revert|rollback|previous|last)\b/i,
@@ -18,7 +19,7 @@ const COMPLEX_SIGNALS = [
   /[|&;]{2}/,
 ];
 
-/** Default models per provider — user can override in ~/.terminal/config.json under "models" */
+/** Default models per provider — user can override in ~/.hasna/terminal/config.json under "models" */
 const MODEL_DEFAULTS: Record<string, { fast: string; smart: string }> = {
   cerebras:  { fast: "qwen-3-235b-a22b-instruct-2507", smart: "qwen-3-235b-a22b-instruct-2507" },
   groq:      { fast: "openai/gpt-oss-120b",             smart: "moonshotai/kimi-k2-instruct" },
@@ -26,7 +27,7 @@ const MODEL_DEFAULTS: Record<string, { fast: string; smart: string }> = {
   anthropic: { fast: "claude-haiku-4-5-20251001",       smart: "claude-sonnet-4-6" },
 };
 
-/** Load user model overrides from ~/.terminal/config.json (cached 30s) */
+/** Load user model overrides from ~/.hasna/terminal/config.json (cached 30s) */
 let _modelOverrides: Record<string, { fast?: string; smart?: string }> | null = null;
 let _modelOverridesAt = 0;
 
@@ -34,7 +35,7 @@ function loadModelOverrides(): Record<string, { fast?: string; smart?: string }>
   const now = Date.now();
   if (_modelOverrides && now - _modelOverridesAt < 30_000) return _modelOverrides;
   try {
-    const configPath = join(process.env.HOME ?? "~", ".terminal", "config.json");
+    const configPath = join(getTerminalDir(), "config.json");
     if (existsSync(configPath)) {
       const config = JSON.parse(readFileSync(configPath, "utf8"));
       _modelOverrides = config.models ?? {};

package/src/cache.ts

@@ -1,10 +1,10 @@
 // In-memory LRU cache + disk persistence for command translations
 
 import { existsSync, readFileSync, writeFileSync } from "fs";
-import { homedir } from "os";
 import { join } from "path";
+import { getTerminalDir } from "./paths.js";
 
-const CACHE_FILE = join(homedir(), ".terminal", "cache.json");
+const CACHE_FILE = join(getTerminalDir(), "cache.json");
 const MAX_ENTRIES = 500;
 
 type CacheMap = Record<string, string>;

package/src/economy.ts

@@ -1,10 +1,10 @@
 // Token economy tracker — tracks token savings across all interactions
 
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
-import { homedir } from "os";
 import { join } from "path";
+import { getTerminalDir } from "./paths.js";
 
-const DIR = join(homedir(), ".terminal");
+const DIR = getTerminalDir();
 const ECONOMY_FILE = join(DIR, "economy.json");
 
 export interface EconomyStats {
@@ -129,7 +129,7 @@ const PROVIDER_PRICING: Record<string, { input: number; output: number }> = {
   "anthropic-opus":   { input: 5.00, output: 25.00 },
 };
 
-/** Load configurable turns-before-compaction from ~/.terminal/config.json */
+/** Load configurable turns-before-compaction from ~/.hasna/terminal/config.json */
 function loadTurnsMultiplier(): number {
   try {
     const configPath = join(DIR, "config.json");

package/src/history.ts

@@ -1,8 +1,8 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { homedir } from "os";
 import { join } from "path";
+import { getTerminalDir } from "./paths.js";
 
-const DIR = join(homedir(), ".terminal");
+const DIR = getTerminalDir();
 const HISTORY_FILE = join(DIR, "history.json");
 const CONFIG_FILE = join(DIR, "config.json");
 

package/src/mcp/server.ts

@@ -15,6 +15,7 @@ import { registerProcessTools } from "./tools/process.js";
 import { registerBatchTools } from "./tools/batch.js";
 import { registerMemoryTools } from "./tools/memory.js";
 import { registerMetaTools } from "./tools/meta.js";
+import { registerCloudTools } from "@hasna/cloud";
 
 // ── server ───────────────────────────────────────────────────────────────────
 
@@ -49,6 +50,7 @@ export function createServer(): McpServer {
   registerBatchTools(server, h);
   registerMemoryTools(server, h);
   registerMetaTools(server, h);
+  registerCloudTools(server, "terminal");
 
   return server;
 }

package/src/mcp/tools/memory.ts

@@ -136,7 +136,8 @@ export function registerMemoryTools(server: McpServer, h: ToolHelpers): void {
     async ({ name, value }) => {
       const { existsSync, readFileSync, writeFileSync, chmodSync } = await import("fs");
       const { join } = await import("path");
-      const secretsFile = join(process.env.HOME ?? "~", ".terminal", "secrets.json");
+      const { getTerminalDir } = await import("../../paths.js");
+      const secretsFile = join(getTerminalDir(), "secrets.json");
       let secrets: Record<string, string> = {};
       if (existsSync(secretsFile)) {
         try { secrets = JSON.parse(readFileSync(secretsFile, "utf8")); } catch {}
@@ -157,7 +158,8 @@ export function registerMemoryTools(server: McpServer, h: ToolHelpers): void {
     async () => {
       const { existsSync, readFileSync } = await import("fs");
       const { join } = await import("path");
-      const secretsFile = join(process.env.HOME ?? "~", ".terminal", "secrets.json");
+      const { getTerminalDir } = await import("../../paths.js");
+      const secretsFile = join(getTerminalDir(), "secrets.json");
       let names: string[] = [];
       if (existsSync(secretsFile)) {
         try { names = Object.keys(JSON.parse(readFileSync(secretsFile, "utf8"))); } catch {}

package/src/output-store.ts

@@ -4,8 +4,9 @@
 import { existsSync, mkdirSync, writeFileSync, readdirSync, statSync, unlinkSync } from "fs";
 import { join } from "path";
 import { createHash } from "crypto";
+import { getTerminalDir } from "./paths.js";
 
-const OUTPUTS_DIR = join(process.env.HOME ?? "~", ".terminal", "outputs");
+const OUTPUTS_DIR = join(getTerminalDir(), "outputs");
 
 /** Ensure outputs directory exists */
 function ensureDir() {

package/src/paths.ts

@@ -0,0 +1,32 @@
+// Centralized path resolution for open-terminal global data directory.
+// Migrated from ~/.terminal/ to ~/.hasna/terminal/ with backward compat.
+
+import { existsSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+/**
+ * Get the global terminal data directory.
+ * New default: ~/.hasna/terminal/
+ * Legacy fallback: ~/.terminal/ (if it exists and new dir doesn't)
+ * Env override: HASNA_TERMINAL_DIR or TERMINAL_DIR
+ */
+export function getTerminalDir(): string {
+  if (process.env.HASNA_TERMINAL_DIR) return process.env.HASNA_TERMINAL_DIR;
+  if (process.env.TERMINAL_DIR) return process.env.TERMINAL_DIR;
+
+  const home = homedir();
+  const newDir = join(home, ".hasna", "terminal");
+  const legacyDir = join(home, ".terminal");
+
+  // Use legacy dir if it exists and new one doesn't yet (backward compat)
+  if (!existsSync(newDir) && existsSync(legacyDir)) {
+    return legacyDir;
+  }
+
+  if (!existsSync(newDir)) {
+    mkdirSync(newDir, { recursive: true });
+  }
+
+  return newDir;
+}

package/src/recipes/storage.ts

@@ -1,12 +1,12 @@
-// Recipes storage — global (~/.terminal/recipes.json) + per-project (.terminal/recipes.json)
+// Recipes storage — global (~/.hasna/terminal/recipes.json) + per-project (.terminal/recipes.json)
 
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { homedir } from "os";
 import { join } from "path";
 import type { Recipe, Collection, RecipeStore } from "./model.js";
 import { genId, extractVariables } from "./model.js";
+import { getTerminalDir } from "../paths.js";
 
-const GLOBAL_DIR = join(homedir(), ".terminal");
+const GLOBAL_DIR = getTerminalDir();
 const GLOBAL_FILE = join(GLOBAL_DIR, "recipes.json");
 
 function projectFile(projectPath: string): string {

package/src/session-context.ts

@@ -2,10 +2,10 @@
 // Enables: terminal "show auth code" → terminal "explain that function"
 
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
-import { homedir } from "os";
 import { join } from "path";
+import { getTerminalDir } from "./paths.js";
 
-const DIR = join(homedir(), ".terminal");
+const DIR = getTerminalDir();
 const CTX_FILE = join(DIR, "session-context.json");
 const MAX_ENTRIES = 5;