ashlrcode 1.0.0

package/src/config/features.ts

@@ -0,0 +1,51 @@
+/**
+ * Feature flags — compile-time dead code elimination via Bun.
+ *
+ * Usage: if (feature("VOICE_MODE")) { ... }
+ * Disabled features are stripped from the bundle at build time.
+ */
+
+// Feature flag definitions with defaults
+const FLAGS: Record<string, boolean> = {
+  VOICE_MODE: false,
+  KAIROS: false,
+  BROWSER_TOOL: false,
+  LSP: false,
+  SPECULATION: false,
+  DREAM_TASK: true,
+  TEAM_MODE: true,
+  WORKTREE_AGENTS: true,
+  ADVANCED_PERMISSIONS: true,
+  EFFORT_LEVELS: true,
+};
+
+// Runtime overrides from env vars: AC_FEATURE_VOICE_MODE=true
+for (const [key] of Object.entries(FLAGS)) {
+  const envKey = `AC_FEATURE_${key}`;
+  const envVal = process.env[envKey];
+  if (envVal !== undefined) {
+    FLAGS[key] = envVal === "true" || envVal === "1";
+  }
+}
+
+/**
+ * Check if a feature is enabled.
+ * In production builds, Bun can DCE branches where this returns false.
+ */
+export function feature(name: string): boolean {
+  return FLAGS[name] ?? false;
+}
+
+/**
+ * List all feature flags and their current state.
+ */
+export function listFeatures(): Record<string, boolean> {
+  return { ...FLAGS };
+}
+
+/**
+ * Enable/disable a feature at runtime (for testing/debugging).
+ */
+export function setFeature(name: string, enabled: boolean): void {
+  FLAGS[name] = enabled;
+}

package/src/config/git.ts

@@ -0,0 +1,137 @@
+/**
+ * Git utilities — repo analysis, VCS detection, and system prompt enrichment.
+ */
+
+import { existsSync } from "fs";
+import { join } from "path";
+import { createHash } from "crypto";
+
+export interface GitContext {
+  isRepo: boolean;
+  branch?: string;
+  status?: string;
+  remoteUrl?: string;
+}
+
+// ---------------------------------------------------------------------------
+// Core helpers
+// ---------------------------------------------------------------------------
+
+async function runGit(cwd: string, args: string): Promise<string | null> {
+  try {
+    const proc = Bun.spawn(["git", ...args.split(" ")], {
+      cwd,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const stdout = await new Response(proc.stdout).text();
+    const exitCode = await proc.exited;
+    return exitCode === 0 ? stdout.trim() : null;
+  } catch {
+    return null;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// VCS detection
+// ---------------------------------------------------------------------------
+
+/** Detect the VCS type of a directory. */
+export async function detectVCS(cwd: string): Promise<"git" | "svn" | "hg" | "none"> {
+  if (existsSync(join(cwd, ".git"))) return "git";
+  if (existsSync(join(cwd, ".svn"))) return "svn";
+  if (existsSync(join(cwd, ".hg"))) return "hg";
+  return "none";
+}
+
+/** Check if directory is inside a git repo (works for nested dirs). */
+export async function isGitRepo(cwd: string): Promise<boolean> {
+  const result = await runGit(cwd, "rev-parse --is-inside-work-tree");
+  return result === "true";
+}
+
+// ---------------------------------------------------------------------------
+// Branch / remote
+// ---------------------------------------------------------------------------
+
+/** Get current git branch. */
+export async function getCurrentBranch(cwd: string): Promise<string | null> {
+  return runGit(cwd, "rev-parse --abbrev-ref HEAD");
+}
+
+/** Get git remote URL (for repo identification). */
+export async function getRemoteUrl(cwd: string): Promise<string | null> {
+  return runGit(cwd, "remote get-url origin");
+}
+
+/** Get a short hash of the remote URL (for session association). */
+export async function getRepoHash(cwd: string): Promise<string | null> {
+  const url = await getRemoteUrl(cwd);
+  if (!url) return null;
+  return createHash("sha256").update(url).digest("hex").slice(0, 16);
+}
+
+// ---------------------------------------------------------------------------
+// Status / history
+// ---------------------------------------------------------------------------
+
+/** Get recent commits summary. */
+export async function getRecentCommits(cwd: string, count: number = 5): Promise<string[]> {
+  const output = await runGit(cwd, `log --oneline -${count}`);
+  return output ? output.split("\n") : [];
+}
+
+/** Get git status summary (counts). */
+export async function getGitStatus(cwd: string): Promise<{ modified: number; untracked: number; staged: number }> {
+  const output = await runGit(cwd, "status --porcelain");
+  if (!output) return { modified: 0, untracked: 0, staged: 0 };
+  const lines = output.split("\n").filter(Boolean);
+  return {
+    modified: lines.filter(l => l.startsWith(" M") || l.startsWith("M ")).length,
+    untracked: lines.filter(l => l.startsWith("??")).length,
+    staged: lines.filter(l => l.startsWith("A ") || l.startsWith("M ")).length,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Legacy aggregate context (used by cli.ts today)
+// ---------------------------------------------------------------------------
+
+/**
+ * Detect git repo context for the current working directory.
+ */
+export async function getGitContext(cwd: string): Promise<GitContext> {
+  if (!existsSync(join(cwd, ".git"))) {
+    return { isRepo: false };
+  }
+
+  const branch = await runGit(cwd, "rev-parse --abbrev-ref HEAD");
+  const status = await runGit(cwd, "status --porcelain");
+  const remoteUrl = await runGit(cwd, "config --get remote.origin.url");
+
+  return {
+    isRepo: true,
+    branch: branch ?? undefined,
+    status: status ?? undefined,
+    remoteUrl: remoteUrl ?? undefined,
+  };
+}
+
+/**
+ * Format git context for inclusion in system prompt.
+ */
+export function formatGitPrompt(ctx: GitContext): string {
+  if (!ctx.isRepo) return "";
+
+  const lines = ["# Git Context"];
+  if (ctx.branch) lines.push(`- Branch: ${ctx.branch}`);
+  if (ctx.remoteUrl) lines.push(`- Remote: ${ctx.remoteUrl}`);
+  if (ctx.status) {
+    const changes = ctx.status.split("\n").filter(Boolean).length;
+    lines.push(`- ${changes} uncommitted change(s)`);
+  } else {
+    lines.push("- Clean working tree");
+  }
+
+  return lines.join("\n");
+}

package/src/config/hooks.ts

@@ -0,0 +1,201 @@
+/**
+ * Hook system — pre/post tool execution hooks from settings.json.
+ *
+ * Hooks can approve, deny, or modify tool calls via shell commands.
+ */
+
+export interface HookDefinition {
+  /** Match by tool name (exact or glob pattern) */
+  toolName?: string;
+  /** Match by input pattern (regex against JSON-serialized input) */
+  inputPattern?: string;
+  /** Shell command to execute (has access to env vars: TOOL_NAME, TOOL_INPUT) */
+  command?: string;
+  /** Direct action without running a command */
+  action?: "allow" | "deny";
+  /** Message to show when action is deny */
+  message?: string;
+}
+
+export interface HooksConfig {
+  preToolUse?: HookDefinition[];
+  postToolUse?: HookDefinition[];
+}
+
+export interface PreHookResult {
+  action: "allow" | "deny";
+  message?: string;
+}
+
+/**
+ * Run pre-tool-use hooks. Returns deny if any hook denies.
+ */
+export async function runPreToolHooks(
+  hooks: HooksConfig,
+  toolName: string,
+  input: Record<string, unknown>
+): Promise<PreHookResult> {
+  const preHooks = hooks.preToolUse ?? [];
+
+  for (const hook of preHooks) {
+    if (!matchesHook(hook, toolName, input)) continue;
+
+    // Direct action (no command needed)
+    if (hook.action === "deny") {
+      return { action: "deny", message: hook.message ?? `Denied by hook for ${toolName}` };
+    }
+    if (hook.action === "allow") {
+      return { action: "allow" };
+    }
+
+    // Run shell command
+    if (hook.command) {
+      const result = await runHookCommand(hook.command, toolName, input);
+      if (result.exitCode !== 0) {
+        return {
+          action: "deny",
+          message: result.output || `Hook command failed for ${toolName}`,
+        };
+      }
+    }
+  }
+
+  return { action: "allow" };
+}
+
+/**
+ * Run post-tool-use hooks. Fire-and-forget.
+ */
+export async function runPostToolHooks(
+  hooks: HooksConfig,
+  toolName: string,
+  input: Record<string, unknown>,
+  result: string
+): Promise<void> {
+  const postHooks = hooks.postToolUse ?? [];
+
+  for (const hook of postHooks) {
+    if (!matchesHook(hook, toolName, input)) continue;
+
+    if (hook.command) {
+      // Fire and forget
+      runHookCommand(hook.command, toolName, input, result).catch(() => {});
+    }
+  }
+}
+
+function matchesHook(
+  hook: HookDefinition,
+  toolName: string,
+  input: Record<string, unknown>
+): boolean {
+  // Match tool name
+  if (hook.toolName) {
+    if (hook.toolName.includes("*")) {
+      try {
+        // Escape regex metacharacters, then expand * to .*
+        const escaped = hook.toolName
+          .replace(/[.+?^${}()|[\]\\]/g, "\\$&")
+          .replace(/\*/g, ".*");
+        const regex = new RegExp("^" + escaped + "$");
+        if (!regex.test(toolName)) return false;
+      } catch {
+        // Invalid pattern, fall back to exact match
+        if (hook.toolName !== toolName) return false;
+      }
+    } else if (hook.toolName !== toolName) {
+      return false;
+    }
+  }
+
+  // Match input pattern (with length guard against ReDoS)
+  if (hook.inputPattern) {
+    const inputStr = JSON.stringify(input);
+    // Guard against catastrophic backtracking on large inputs
+    if (inputStr.length > 10_000) {
+      // For very large inputs, use simple string.includes as fallback
+      if (!inputStr.includes(hook.inputPattern)) return false;
+    } else {
+      try {
+        const regex = new RegExp(hook.inputPattern);
+        if (!regex.test(inputStr)) return false;
+      } catch {
+        return false; // Invalid regex, skip this hook
+      }
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Convert settings.json toolHooks format into internal HooksConfig.
+ * This bridges the user-facing config shape (tool/inputPattern/command/action)
+ * to the internal HookDefinition shape (toolName/inputPattern/command/action/message).
+ */
+export function loadHooksFromSettings(toolHooks: {
+  preToolUse?: Array<{
+    tool?: string;
+    inputPattern?: string;
+    command?: string;
+    action?: "allow" | "deny";
+  }>;
+  postToolUse?: Array<{
+    tool?: string;
+    command?: string;
+  }>;
+}): HooksConfig {
+  const config: HooksConfig = {};
+
+  if (toolHooks.preToolUse) {
+    config.preToolUse = toolHooks.preToolUse.map((rule) => ({
+      toolName: rule.tool,
+      inputPattern: rule.inputPattern,
+      command: rule.command,
+      action: rule.action,
+      message: rule.action === "deny" ? `Denied by toolHooks rule for ${rule.tool ?? "*"}` : undefined,
+    }));
+  }
+
+  if (toolHooks.postToolUse) {
+    config.postToolUse = toolHooks.postToolUse.map((rule) => ({
+      toolName: rule.tool,
+      command: rule.command,
+    }));
+  }
+
+  return config;
+}
+
+async function runHookCommand(
+  command: string,
+  toolName: string,
+  input: Record<string, unknown>,
+  result?: string
+): Promise<{ exitCode: number; output: string }> {
+  const env = {
+    ...process.env,
+    TOOL_NAME: toolName,
+    TOOL_INPUT: JSON.stringify(input),
+    ...(result ? { TOOL_RESULT: result.slice(0, 10_000) } : {}),
+  };
+
+  const proc = Bun.spawn(["bash", "-c", command], {
+    stdout: "pipe",
+    stderr: "pipe",
+    env,
+  });
+
+  // Timeout hook commands at 15 seconds
+  const timeoutId = setTimeout(() => proc.kill(), 15_000);
+
+  try {
+    const stdout = await new Response(proc.stdout).text();
+    const exitCode = await proc.exited;
+    clearTimeout(timeoutId);
+    return { exitCode, output: stdout.trim() };
+  } catch {
+    clearTimeout(timeoutId);
+    return { exitCode: 1, output: "Hook command timed out" };
+  }
+}

package/src/config/permissions.ts

@@ -0,0 +1,251 @@
+/**
+ * Permission system — configurable allow/deny/ask rules with persistence.
+ *
+ * Permissions are saved to ~/.ashlrcode/permissions.json and persist
+ * across sessions. Users can choose:
+ *   y = allow once
+ *   a = always allow (persisted)
+ *   n = deny once
+ *   d = always deny (persisted)
+ */
+
+import { existsSync } from "fs";
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { join } from "path";
+import { getConfigDir } from "./settings.ts";
+
+export interface PermissionState {
+  alwaysAllow: Set<string>;
+  alwaysDeny: Set<string>;
+  /** Session-only allows (not persisted) */
+  sessionAllow: Set<string>;
+}
+
+interface PersistedPermissions {
+  alwaysAllow: string[];
+  alwaysDeny: string[];
+}
+
+function getPermissionsPath(): string {
+  return join(getConfigDir(), "permissions.json");
+}
+
+// Default read-only tools that never need permission
+const READ_ONLY_AUTO_ALLOW = new Set([
+  "Read", "Glob", "Grep", "AskUser", "WebFetch",
+  "EnterPlan", "ExitPlan", "PlanWrite",
+  "TaskCreate", "TaskUpdate", "TaskList",
+  "Agent",
+]);
+
+let state: PermissionState = {
+  alwaysAllow: new Set(),
+  alwaysDeny: new Set(),
+  sessionAllow: new Set(),
+};
+
+/** Bypass mode — when true, all permissions are auto-approved */
+let bypassMode = false;
+
+/** Auto-accept edits — when true, Write/Edit are auto-approved but Bash still asks */
+let autoAcceptEdits = false;
+
+export function setBypassMode(enabled: boolean): void {
+  bypassMode = enabled;
+}
+
+export function setAutoAcceptEdits(enabled: boolean): void {
+  autoAcceptEdits = enabled;
+}
+
+export function isBypassMode(): boolean {
+  return bypassMode;
+}
+
+export async function loadPermissions(): Promise<void> {
+  const permissionsPath = getPermissionsPath();
+  if (!existsSync(permissionsPath)) return;
+
+  try {
+    const raw = await readFile(permissionsPath, "utf-8");
+    const data = JSON.parse(raw) as PersistedPermissions;
+    state.alwaysAllow = new Set(data.alwaysAllow ?? []);
+    state.alwaysDeny = new Set(data.alwaysDeny ?? []);
+  } catch {
+    // Corrupted file, start fresh
+  }
+}
+
+async function savePermissions(): Promise<void> {
+  await mkdir(getConfigDir(), { recursive: true });
+  const data: PersistedPermissions = {
+    alwaysAllow: Array.from(state.alwaysAllow),
+    alwaysDeny: Array.from(state.alwaysDeny),
+  };
+  await writeFile(getPermissionsPath(), JSON.stringify(data, null, 2), "utf-8");
+}
+
+/**
+ * Check if a tool needs user permission.
+ * Returns: "allow" (auto-approved), "deny" (auto-blocked), "ask" (prompt user)
+ */
+export function checkPermission(toolName: string): "allow" | "deny" | "ask" {
+  // Bypass mode — approve everything
+  if (bypassMode) return "allow";
+
+  // Read-only tools are always allowed
+  if (READ_ONLY_AUTO_ALLOW.has(toolName)) return "allow";
+
+  // Auto-accept edits mode — approve Write/Edit but still ask for Bash
+  if (autoAcceptEdits && (toolName === "Write" || toolName === "Edit")) return "allow";
+
+  // Check persistent deny
+  if (state.alwaysDeny.has(toolName)) return "deny";
+
+  // Check persistent allow
+  if (state.alwaysAllow.has(toolName)) return "allow";
+
+  // Check session allow
+  if (state.sessionAllow.has(toolName)) return "allow";
+
+  return "ask";
+}
+
+/**
+ * Record a permission decision.
+ */
+export async function recordPermission(
+  toolName: string,
+  decision: "allow_once" | "always_allow" | "deny_once" | "always_deny"
+): Promise<void> {
+  switch (decision) {
+    case "allow_once":
+      // No persistence needed
+      break;
+    case "always_allow":
+      state.alwaysAllow.add(toolName);
+      state.alwaysDeny.delete(toolName);
+      await savePermissions();
+      break;
+    case "deny_once":
+      // No persistence needed
+      break;
+    case "always_deny":
+      state.alwaysDeny.add(toolName);
+      state.alwaysAllow.delete(toolName);
+      await savePermissions();
+      break;
+  }
+}
+
+/**
+ * Allow a tool for this session only (not persisted).
+ */
+export function allowForSession(toolName: string): void {
+  state.sessionAllow.add(toolName);
+}
+
+export function getPermissionState(): PermissionState {
+  return state;
+}
+
+// --- Ink-mode permission resolver (callback-based, like AskUser) ---
+
+let pendingPermissionResolve: ((decision: "allow_once" | "always_allow" | "deny_once" | "always_deny") => void) | null = null;
+let pendingPermissionInfo: { toolName: string; description: string } | null = null;
+
+export function hasPendingPermission(): boolean {
+  return pendingPermissionResolve !== null;
+}
+
+export function getPendingPermissionInfo(): { toolName: string; description: string } | null {
+  return pendingPermissionInfo;
+}
+
+/**
+ * Resolve a pending Ink-mode permission prompt with a single-key answer.
+ * Returns true if the key was recognized and the pending prompt was resolved.
+ */
+export function answerPendingPermission(key: string): boolean {
+  if (!pendingPermissionResolve) return false;
+  const decisions: Record<string, "allow_once" | "always_allow" | "deny_once" | "always_deny"> = {
+    y: "allow_once",
+    a: "always_allow",
+    n: "deny_once",
+    d: "always_deny",
+  };
+  const decision = decisions[key.toLowerCase()];
+  if (!decision) return false;
+
+  pendingPermissionResolve(decision);
+  pendingPermissionResolve = null;
+  pendingPermissionInfo = null;
+  return true;
+}
+
+/**
+ * Request permission in Ink mode. Blocks (via Promise) until the user
+ * types a recognized key (y/a/n/d) that gets routed through
+ * answerPendingPermission().
+ */
+export async function requestPermissionInk(toolName: string, description: string): Promise<boolean> {
+  pendingPermissionInfo = { toolName, description };
+
+  const decision = await new Promise<"allow_once" | "always_allow" | "deny_once" | "always_deny">((resolve) => {
+    pendingPermissionResolve = resolve;
+  });
+
+  await recordPermission(toolName, decision);
+  if (decision === "allow_once") allowForSession(toolName);
+
+  return decision === "allow_once" || decision === "always_allow";
+}
+
+export function resetPermissionsForTests(): void {
+  state = {
+    alwaysAllow: new Set(),
+    alwaysDeny: new Set(),
+    sessionAllow: new Set(),
+  };
+  bypassMode = false;
+  autoAcceptEdits = false;
+  rules = [];
+}
+
+// --- Input-based permission rules ---
+
+export interface PermissionRule {
+  tool: string;           // Exact name or simple glob ("File*", "*Bash")
+  inputPattern?: string;  // Regex to match against JSON-stringified input
+  action: "allow" | "deny" | "ask";
+}
+
+let rules: PermissionRule[] = [];
+
+function matchesToolPattern(pattern: string, toolName: string): boolean {
+  if (pattern === "*") return true;
+  if (pattern === toolName) return true;
+  if (pattern.startsWith("*") && toolName.endsWith(pattern.slice(1))) return true;
+  if (pattern.endsWith("*") && toolName.startsWith(pattern.slice(0, -1))) return true;
+  return false;
+}
+
+/**
+ * Check input-based permission rules. Returns the action of the first matching rule,
+ * or null if no rule matches.
+ */
+export function checkRules(toolName: string, input?: Record<string, unknown>): "allow" | "deny" | "ask" | null {
+  const inputStr = input ? JSON.stringify(input) : "";
+  for (const rule of rules) {
+    if (!matchesToolPattern(rule.tool, toolName)) continue;
+    if (rule.inputPattern) {
+      try { if (!new RegExp(rule.inputPattern).test(inputStr)) continue; }
+      catch { continue; }
+    }
+    return rule.action;
+  }
+  return null;
+}
+
+export function setRules(newRules: PermissionRule[]): void { rules = newRules; }
+export function getRules(): PermissionRule[] { return rules; }

package/src/config/project-config.ts

@@ -0,0 +1,63 @@
+/**
+ * Project configuration — loads ASHLR.md / CLAUDE.md from project directories.
+ *
+ * Walks up the directory tree, merging project configs found along the way
+ * (closest takes precedence, similar to .gitignore behavior).
+ */
+
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+import { join, dirname, resolve } from "path";
+import { getConfigDir } from "./settings.ts";
+
+const CONFIG_FILENAMES = ["ASHLR.md", "CLAUDE.md"];
+
+export interface ProjectConfig {
+  instructions: string;
+  sources: string[]; // file paths where instructions were found
+}
+
+/**
+ * Load project configuration by walking up from cwd.
+ */
+export async function loadProjectConfig(cwd: string): Promise<ProjectConfig> {
+  const discovered: Array<{ path: string; content: string }> = [];
+  const seen = new Set<string>();
+
+  let dir = resolve(cwd);
+
+  // Walk up, collect configs (stop at filesystem root or after 10 levels)
+  for (let i = 0; i < 10; i++) {
+    for (const filename of CONFIG_FILENAMES) {
+      const configPath = join(dir, filename);
+      if (existsSync(configPath) && !seen.has(configPath)) {
+        seen.add(configPath);
+        const content = await readFile(configPath, "utf-8");
+        discovered.push({ path: configPath, content: `# ${filename} (${dir})\n\n${content}` });
+      }
+    }
+    const parentDir = dirname(dir);
+    if (parentDir === dir) break;
+    dir = parentDir;
+  }
+
+  // Also check home directory for global config
+  const homeConfig = join(getConfigDir(), "ASHLR.md");
+  if (existsSync(homeConfig) && !seen.has(homeConfig)) {
+    const content = await readFile(homeConfig, "utf-8");
+    discovered.push({ path: homeConfig, content: `# Global ASHLR.md\n\n${content}` });
+  }
+
+  const homePrefix = `${getConfigDir()}/`;
+  const ordered = discovered.sort((a, b) => {
+    const depth = (path: string) => path.split("/").length;
+    const aDepth = a.path.startsWith(homePrefix) ? -1 : depth(a.path);
+    const bDepth = b.path.startsWith(homePrefix) ? -1 : depth(b.path);
+    return aDepth - bDepth;
+  });
+
+  return {
+    instructions: ordered.map((entry) => entry.content).join("\n\n---\n\n"),
+    sources: ordered.map((entry) => entry.path),
+  };
+}