@vladpazych/dexter 0.1.0

package/src/meta/domain/commit.ts

@@ -0,0 +1,135 @@
+/**
+ * Commit domain logic — isolated git commit using temporary index.
+ */
+
+import { join } from "node:path"
+
+import { ControlError } from "../errors.ts"
+import type { ControlPorts } from "../ports.ts"
+import type { CommitParams, CommitResult } from "../types.ts"
+
+import { checkQuality } from "./quality.ts"
+
+const MAX_MESSAGE_LENGTH = 72
+
+function fail(code: string, message: string, hints: string[] = []): never {
+  throw new ControlError(code, message, hints)
+}
+
+export async function commit(ports: ControlPorts, params: CommitParams): Promise<CommitResult> {
+  const { message, files } = params
+
+  if (!ports.git.run(["--version"]).success) {
+    fail("git_not_found", "git not installed", ["install git to use this command"])
+  }
+  if (!ports.git.run(["rev-parse", "--is-inside-work-tree"]).success) {
+    fail("not_repo", "not a git repository", ["run from within a git repository, or run 'git init' first"])
+  }
+  if (!ports.git.run(["rev-parse", "HEAD"]).success) {
+    fail("no_commits", "repository has no commits", [
+      "create an initial commit first: git commit --allow-empty -m 'initial commit'",
+    ])
+  }
+
+  if (!message) {
+    fail("empty_message", "commit message cannot be empty", ["describe why this change exists"])
+  }
+  if (message.length > MAX_MESSAGE_LENGTH) {
+    fail("message_too_long", `message exceeds ${MAX_MESSAGE_LENGTH} characters (${message.length})`, [
+      "keep the commit message concise — one line explaining why",
+    ])
+  }
+
+  if (files.length === 0) {
+    fail("no_files", "no files to commit", ['./meta/run commit "message" file1 file2 ...'])
+  }
+
+  const quality = await checkQuality(ports, files)
+  if (!quality.passed) {
+    const diagnostics = quality.checks.filter((c) => c.status === "fail").map((c) => `${c.name}: ${c.output}`)
+    fail("quality_failed", "quality checks failed", diagnostics)
+  }
+
+  const tempIndex = join(ports.tmpdir(), `git-index.${process.pid}.${Date.now()}`)
+  const indexEnv = { GIT_INDEX_FILE: tempIndex }
+
+  try {
+    const readTreeResult = ports.git.run(["read-tree", "HEAD"], indexEnv)
+    if (!readTreeResult.success) {
+      fail("read_tree_failed", "failed to read git tree", [readTreeResult.stderr])
+    }
+
+    const headTree = ports.git.run(["ls-tree", "-r", "--name-only", "HEAD"], indexEnv)
+    const caseMap = new Map<string, string>()
+    if (headTree.success) {
+      for (const p of headTree.stdout.split("\n").filter(Boolean)) {
+        caseMap.set(p.toLowerCase(), p)
+      }
+    }
+
+    let hasCaseRenames = false
+    for (const file of files) {
+      const fileExists = ports.fs.exists(file)
+      const isTracked = ports.git.run(["ls-tree", "--name-only", "HEAD", "--", file]).stdout !== ""
+
+      if (!fileExists && !isTracked) {
+        const allFiles = ports.git.run(["ls-files"]).stdout
+        const basename = file.split("/").pop() ?? file
+        const similar = allFiles
+          .split("\n")
+          .filter((f) => f.toLowerCase().includes(basename.toLowerCase()))
+          .slice(0, 3)
+
+        const hints = ["file may have been moved, renamed, or never created"]
+        if (similar.length > 0 && similar[0]) {
+          hints.push("similar tracked files:")
+          similar.forEach((f) => hints.push(`  ${f}`))
+        }
+        fail("file_not_found", `file not found and not tracked: ${file}`, hints)
+      }
+
+      if (fileExists) {
+        if (ports.git.checkIgnore(file)) {
+          fail("file_ignored", `file is ignored by .gitignore: ${file}`, ["file matches a pattern in .gitignore"])
+        }
+      }
+
+      const headPath = caseMap.get(file.toLowerCase())
+      if (headPath && headPath !== file) {
+        ports.git.run(["rm", "--cached", "--quiet", "--", headPath], indexEnv)
+        hasCaseRenames = true
+      }
+
+      const addResult = ports.git.run(["add", "--", file], indexEnv)
+      if (!addResult.success) {
+        fail("stage_failed", `failed to stage file: ${file}`, [addResult.stderr])
+      }
+    }
+
+    if (!hasCaseRenames) {
+      const diffResult = ports.git.run(["diff", "--cached", "--quiet"], indexEnv)
+      if (diffResult.success) {
+        fail("no_changes", "no changes to commit in specified files", ["file contents match what is already in HEAD"])
+      }
+    }
+
+    const commitResult = ports.git.run(["commit", "-m", message, "--quiet"], indexEnv)
+    if (!commitResult.success) {
+      fail("commit_failed", "commit failed", [commitResult.stderr])
+    }
+
+    const hash = ports.git.run(["rev-parse", "--short", "HEAD"], indexEnv).stdout.trim()
+    const committedFiles = ports.git
+      .run(["diff-tree", "--no-commit-id", "--name-only", "-r", "HEAD"], indexEnv)
+      .stdout.split("\n")
+      .filter(Boolean)
+
+    ports.git.run(["reset", "--quiet", "HEAD"])
+
+    return { hash, message, files: committedFiles }
+  } finally {
+    if (ports.fs.exists(tempIndex)) {
+      ports.fs.unlink(tempIndex)
+    }
+  }
+}

package/src/meta/domain/commits.ts

@@ -0,0 +1,23 @@
+/**
+ * Query: commits — recent commits for given scopes + repo-wide style reference.
+ */
+
+import type { ControlPorts } from "../ports.ts"
+import type { CommitsScope, QueryResult } from "../types.ts"
+
+export function commits(ports: ControlPorts, scopes: string[]): QueryResult {
+  const data: CommitsScope[] = []
+
+  for (const scope of scopes) {
+    const logResult = ports.git.run(["log", "--oneline", "--format=%h %s (%an, %ar)", "-6", "--", scope])
+    const lines = logResult.success && logResult.stdout ? logResult.stdout.split("\n").filter(Boolean) : []
+    if (lines.length > 0) {
+      data.push({ path: scope, log: lines })
+    }
+  }
+
+  const log = ports.git.run(["log", "--oneline", "-5"])
+  const recent = log.success ? log.stdout.split("\n").filter(Boolean) : []
+
+  return { what: "commits", scopes, data, recent }
+}

package/src/meta/domain/constraints/registry.ts

@@ -0,0 +1,49 @@
+/**
+ * Constraint Registry — centralized constraint definitions.
+ */
+
+import { type ConstraintResult, type PatternConstraint, createPatternConstraint } from "./types.ts"
+
+/** Git commands that should use workflow scripts */
+export const GIT_WORKFLOW_CONSTRAINTS: PatternConstraint[] = [
+  createPatternConstraint("git-add", /^git\s+(add)(\s|$)/, "Use ./scripts/git/commit"),
+  createPatternConstraint("git-commit", /^git\s+(commit)(\s|$)/, "Use ./scripts/git/commit"),
+]
+
+/** Destructive git operations */
+export const GIT_DESTRUCTIVE_CONSTRAINTS: PatternConstraint[] = [
+  createPatternConstraint("git-force-push", /^git\s+push\s+.*--force/, "Force push not allowed. Use revert instead."),
+  createPatternConstraint("git-hard-reset", /^git\s+reset\s+--hard/, "Hard reset not allowed. Use revert instead."),
+  createPatternConstraint(
+    "git-clean-force",
+    /^git\s+clean\s+-f/,
+    "git clean -f not allowed. Remove files explicitly.",
+  ),
+  createPatternConstraint(
+    "git-checkout-all",
+    /^git\s+checkout\s+\.$/,
+    "Discard all changes not allowed. Be explicit about files.",
+  ),
+]
+
+/** All bash command constraints */
+export const BASH_CONSTRAINTS: PatternConstraint[] = [...GIT_WORKFLOW_CONSTRAINTS, ...GIT_DESTRUCTIVE_CONSTRAINTS]
+
+/** Check a command against all bash constraints */
+export function checkBashCommand(command: string): ConstraintResult {
+  for (const constraint of BASH_CONSTRAINTS) {
+    const result = constraint.check(command)
+    if (!result.ok) {
+      return result
+    }
+  }
+  return { ok: true }
+}
+
+/** Check a command against pattern constraints, returning the first match */
+export function findMatchingConstraint(
+  command: string,
+  constraints: PatternConstraint[],
+): PatternConstraint | undefined {
+  return constraints.find((c) => c.pattern.test(command))
+}

package/src/meta/domain/constraints/types.ts

@@ -0,0 +1,30 @@
+/**
+ * Constraint system types
+ */
+
+export type ConstraintResult = { ok: true } | { ok: false; message: string; hint?: string }
+
+export interface Constraint<T = unknown> {
+  name: string
+  check: (input: T) => ConstraintResult
+}
+
+export interface PatternConstraint extends Constraint<string> {
+  pattern: RegExp
+  hint: string
+}
+
+/** Create a pattern-based constraint */
+export function createPatternConstraint(name: string, pattern: RegExp, hint: string): PatternConstraint {
+  return {
+    name,
+    pattern,
+    hint,
+    check: (input: string): ConstraintResult => {
+      if (pattern.test(input)) {
+        return { ok: false, message: `Pattern matched: ${name}`, hint }
+      }
+      return { ok: true }
+    },
+  }
+}

package/src/meta/domain/diff.ts

@@ -0,0 +1,34 @@
+/**
+ * Query: diff — git status and diff for given scopes.
+ */
+
+import type { ControlPorts } from "../ports.ts"
+import type { DiffScope, QueryResult } from "../types.ts"
+
+const DIFF_LINE_LIMIT = 200
+
+export function diff(ports: ControlPorts, scopes: string[]): QueryResult {
+  const data: DiffScope[] = []
+
+  for (const scope of scopes) {
+    const statusResult = ports.git.run(["status", "--short", "--", scope])
+    const status = statusResult.success ? statusResult.stdout.trim() : ""
+
+    const diffResult = ports.git.run(["diff", "HEAD", "--", scope])
+    let diffText = ""
+    if (diffResult.success && diffResult.stdout) {
+      const lines = diffResult.stdout.split("\n")
+      if (lines.length > DIFF_LINE_LIMIT) {
+        diffText = lines.slice(0, DIFF_LINE_LIMIT).join("\n") + `\n... (${lines.length - DIFF_LINE_LIMIT} more lines)`
+      } else {
+        diffText = diffResult.stdout
+      }
+    }
+
+    if (status || diffText.trim()) {
+      data.push({ path: scope, status, diff: diffText.trim() })
+    }
+  }
+
+  return { what: "diff", scopes, data }
+}

package/src/meta/domain/eval.ts

@@ -0,0 +1,57 @@
+/**
+ * Eval domain logic — execute TypeScript code in a sandboxed subprocess.
+ */
+
+import { join } from "node:path"
+
+import { ControlError } from "../errors.ts"
+import type { ControlPorts } from "../ports.ts"
+import type { EvalParams, EvalResult } from "../types.ts"
+
+const SCRATCH_DIR = "meta/.scratch"
+const DEFAULT_TIMEOUT = 5000
+
+export async function evaluate(ports: ControlPorts, params: EvalParams): Promise<EvalResult> {
+  const { code, timeout = DEFAULT_TIMEOUT } = params
+
+  if (!code.trim()) {
+    throw new ControlError("empty_code", "no code to evaluate", ["provide a TypeScript expression or snippet"])
+  }
+
+  const scratchPath = join(ports.root, SCRATCH_DIR)
+  if (!ports.fs.exists(scratchPath)) {
+    ports.fs.mkdir(scratchPath)
+  }
+
+  const filename = `eval-${process.pid}-${Date.now()}.ts`
+  const filepath = join(scratchPath, filename)
+
+  try {
+    ports.fs.writeFile(filepath, code)
+
+    const stdout: string[] = []
+    const stderr: string[] = []
+
+    const handle = ports.process.spawn({
+      cmd: "bun",
+      args: ["run", filepath],
+      cwd: ports.root,
+      timeout,
+    })
+
+    handle.onLine("stdout", (line) => stdout.push(line))
+    handle.onLine("stderr", (line) => stderr.push(line))
+
+    const exitCode = await handle.wait()
+
+    return {
+      ok: exitCode === 0,
+      stdout: stdout.join("\n"),
+      stderr: stderr.join("\n"),
+    }
+  } finally {
+    if (ports.fs.exists(filepath)) {
+      ports.fs.unlink(filepath)
+    }
+  }
+}

package/src/meta/domain/format.ts

@@ -0,0 +1,34 @@
+/**
+ * Check output parsing — extract structured error data from raw tool output.
+ */
+
+import type { CheckData, CheckError } from "../types.ts"
+
+/**
+ * Detect lines that represent errors in check output.
+ */
+export function isErrorLine(line: string): boolean {
+  if (/[:(]\d+[,):]/.test(line) && /error/i.test(line)) return true
+  if (line.includes("\u2717") || line.includes("FAIL")) return true
+  return false
+}
+
+/**
+ * Extract structured error entries from raw check output.
+ */
+export function extractErrors(raw: string): CheckData {
+  if (!raw.trim()) {
+    return { errorCount: 0, errors: [], raw }
+  }
+
+  const lines = raw.split("\n")
+  const errors: CheckError[] = lines
+    .map((line, idx) => ({ line: idx + 1, summary: line }))
+    .filter(({ summary }) => isErrorLine(summary))
+    .map(({ line, summary }) => ({
+      line,
+      summary: summary.length > 80 ? summary.slice(0, 77) + "..." : summary,
+    }))
+
+  return { errorCount: errors.length, errors, raw }
+}

package/src/meta/domain/lint.ts

@@ -0,0 +1,88 @@
+/**
+ * Query: lint — ESLint results for given scopes.
+ */
+
+import { join, relative } from "node:path"
+
+import type { ControlPorts } from "../ports.ts"
+import type { QueryResult } from "../types.ts"
+import { isLintable } from "./quality.ts"
+import { discoverPackages, filterByFiles } from "./workspace.ts"
+import { extractErrors } from "./format.ts"
+
+export async function lint(ports: ControlPorts, scopes: string[], opts?: { changed?: boolean }): Promise<QueryResult> {
+  const effectiveScopes = scopes.length === 0 ? ["."] : scopes
+  const allFiles = opts?.changed ? getChangedFiles(ports, effectiveScopes) : getTrackedFiles(ports, effectiveScopes)
+
+  if (allFiles.length === 0) {
+    return { what: "lint", scopes, data: { errorCount: 0, errors: [], raw: "" } }
+  }
+
+  const packages = discoverPackages(ports)
+  const affected = filterByFiles(packages, allFiles, ports.root)
+  const pkgWithOwnConfig = affected.filter((pkg) => ports.fs.exists(join(pkg.dir, "eslint.config.js")))
+
+  const pkgFiles = new Set<string>()
+  const lintJobs: Promise<string>[] = []
+
+  for (const pkg of pkgWithOwnConfig) {
+    const pkgSpecific = allFiles.filter((f) => f.startsWith(pkg.relDir + "/"))
+    for (const f of pkgSpecific) pkgFiles.add(f)
+    if (pkgSpecific.length > 0) {
+      const relFiles = pkgSpecific.map((f) => relative(pkg.relDir, f))
+      lintJobs.push(runEslint(ports, relFiles, pkg.dir))
+    }
+  }
+
+  const rootFiles = allFiles.filter((f) => !pkgFiles.has(f))
+  if (rootFiles.length > 0) {
+    lintJobs.push(runEslint(ports, rootFiles, ports.root))
+  }
+
+  const outputs = await Promise.all(lintJobs)
+  const raw = outputs.filter(Boolean).join("\n")
+
+  return { what: "lint", scopes, data: extractErrors(raw) }
+}
+
+function getTrackedFiles(ports: ControlPorts, scopes: string[]): string[] {
+  const files: string[] = []
+  for (const scope of scopes) {
+    const lsResult = ports.git.run(["ls-files", scope])
+    if (lsResult.success && lsResult.stdout) {
+      files.push(
+        ...lsResult.stdout
+          .split("\n")
+          .filter(Boolean)
+          .filter(isLintable)
+          .filter((f) => ports.fs.exists(join(ports.root, f))),
+      )
+    }
+  }
+  return files
+}
+
+function getChangedFiles(ports: ControlPorts, scopes: string[]): string[] {
+  const files: string[] = []
+  for (const scope of scopes) {
+    const modified = ports.git.run(["diff", "--name-only", "HEAD", "--", scope])
+    if (modified.success) files.push(...modified.stdout.split("\n").filter(Boolean))
+    const untracked = ports.git.run(["ls-files", "--others", "--exclude-standard", "--", scope])
+    if (untracked.success) files.push(...untracked.stdout.split("\n").filter(Boolean))
+  }
+  return [...new Set(files)].filter(isLintable).filter((f) => ports.fs.exists(join(ports.root, f)))
+}
+
+function runEslint(ports: ControlPorts, files: string[], cwd: string): Promise<string> {
+  return new Promise((resolve) => {
+    const lines: string[] = []
+    const handle = ports.process.spawn({
+      cmd: "bunx",
+      args: ["eslint", "--no-warn-ignored", ...files],
+      cwd,
+    })
+    handle.onLine("stdout", (line) => lines.push(line))
+    handle.onLine("stderr", (line) => lines.push(line))
+    handle.wait().then(() => resolve(lines.join("\n")))
+  })
+}

package/src/meta/domain/pickaxe.ts

@@ -0,0 +1,99 @@
+/**
+ * Git pickaxe — find commits that added or removed a pattern.
+ */
+
+import type { ControlPorts } from "../ports.ts"
+import type { GitResult, PickaxeMatch } from "../types.ts"
+import { ControlError } from "../errors.ts"
+
+const MAX_MATCHES = 10
+
+/** Parse git log output with custom format + patch into PickaxeMatch[]. */
+function parseLogOutput(raw: string): PickaxeMatch[] {
+  if (!raw.trim()) return []
+
+  const matches: PickaxeMatch[] = []
+  const commits = raw.split(/^(?=commit [0-9a-f]{40}$)/m).filter(Boolean)
+
+  for (const block of commits) {
+    const lines = block.split("\n")
+    let hash = ""
+    let author = ""
+    let date = ""
+    let message = ""
+    const diffLines: string[] = []
+    let inDiff = false
+
+    for (const line of lines) {
+      if (line.startsWith("commit ")) {
+        hash = line.slice(7, 15)
+      } else if (line.startsWith("Author: ")) {
+        const authorMatch = line.match(/^Author:\s+(.+?)\s*</)
+        author = authorMatch ? authorMatch[1]!.trim() : line.slice(8).trim()
+      } else if (line.startsWith("Date: ")) {
+        const raw = line.slice(6).trim()
+        try {
+          date = new Date(raw).toISOString().slice(0, 10)
+        } catch {
+          date = raw
+        }
+      } else if (line.startsWith("    ") && !inDiff && !message) {
+        message = line.trim()
+      } else if (line.startsWith("diff --git") || inDiff) {
+        inDiff = true
+        diffLines.push(line)
+      }
+    }
+
+    if (hash) {
+      matches.push({
+        hash,
+        author,
+        date,
+        message,
+        diff: diffLines.join("\n").trim(),
+      })
+    }
+  }
+
+  return matches
+}
+
+export function pickaxe(
+  ports: ControlPorts,
+  pattern: string,
+  opts?: { regex?: boolean; scopes?: string[] },
+): GitResult {
+  if (!pattern) {
+    throw new ControlError("empty_pattern", "pickaxe requires a search pattern", [
+      "Usage: pickaxe <pattern> [--regex] [scopes...]",
+    ])
+  }
+
+  const args = ["log"]
+
+  if (opts?.regex) {
+    args.push("-G", pattern)
+  } else {
+    args.push("-S", pattern)
+  }
+
+  args.push(`-${MAX_MATCHES}`, "--patch", "--diff-filter=AMD")
+
+  if (opts?.scopes && opts.scopes.length > 0) {
+    args.push("--", ...opts.scopes)
+  }
+
+  const result = ports.git.run(args)
+  if (!result.success) {
+    throw new ControlError(
+      "pickaxe_failed",
+      `git log pickaxe failed: ${result.stderr.trim()}`,
+      [opts?.regex ? "Check that the regex pattern is valid" : "", "Ensure the repository has commits"].filter(Boolean),
+    )
+  }
+
+  const matches = parseLogOutput(result.stdout)
+
+  return { what: "pickaxe", pattern, matches }
+}