supipowers 1.5.2 → 2.0.0

package/src/git/status.ts

@@ -1,12 +1,45 @@
 import { normalizeLineEndings } from "../text.js";
 
-
 type ExecFn = (cmd: string, args: string[], opts?: { cwd?: string }) => Promise<{ stdout: string; code: number }>;
 
 export interface WorkingTreeStatus {
   dirty: boolean;
   /** Files with uncommitted changes (staged + unstaged + untracked) */
   files: string[];
+  /** Files currently staged in the index. */
+  stagedFiles: string[];
+  /** Files with unstaged or untracked changes. */
+  unstagedFiles: string[];
+}
+
+interface ParsedPorcelainEntry {
+  path: string;
+  staged: boolean;
+  unstaged: boolean;
+}
+
+function parsePorcelainPath(rawPath: string): string {
+  const renameSegments = rawPath.split(" -> ");
+  return renameSegments[renameSegments.length - 1]?.trim() ?? rawPath.trim();
+}
+
+function parsePorcelainLine(line: string): ParsedPorcelainEntry | null {
+  if (line.length < 4) {
+    return null;
+  }
+
+  const indexStatus = line[0] ?? " ";
+  const worktreeStatus = line[1] ?? " ";
+  const rawPath = line.slice(3).trim();
+  if (!rawPath) {
+    return null;
+  }
+
+  return {
+    path: parsePorcelainPath(rawPath),
+    staged: indexStatus !== " " && indexStatus !== "?",
+    unstaged: worktreeStatus !== " " || indexStatus === "?",
+  };
 }
 
 /**
@@ -17,14 +50,35 @@ export async function getWorkingTreeStatus(exec: ExecFn, cwd: string): Promise<W
   try {
     const result = await exec("git", ["status", "--porcelain"], { cwd });
     if (result.code !== 0) {
-      return { dirty: false, files: [] };
+      return { dirty: false, files: [], stagedFiles: [], unstagedFiles: [] };
+    }
+
+    const files: string[] = [];
+    const stagedFiles: string[] = [];
+    const unstagedFiles: string[] = [];
+
+    for (const line of normalizeLineEndings(result.stdout).split("\n").filter(Boolean)) {
+      const entry = parsePorcelainLine(line);
+      if (!entry) {
+        continue;
+      }
+
+      files.push(entry.path);
+      if (entry.staged) {
+        stagedFiles.push(entry.path);
+      }
+      if (entry.unstaged) {
+        unstagedFiles.push(entry.path);
+      }
     }
-    const files = normalizeLineEndings(result.stdout)
-      .split("\n")
-      .filter(Boolean)
-      .map((line) => line.slice(3)); // strip 2-char status + space
-    return { dirty: files.length > 0, files };
+
+    return {
+      dirty: files.length > 0,
+      files,
+      stagedFiles,
+      unstagedFiles,
+    };
   } catch {
-    return { dirty: false, files: [] };
+    return { dirty: false, files: [], stagedFiles: [], unstagedFiles: [] };
   }
 }

package/src/harness/anti_slop/architecture-parser.ts

@@ -0,0 +1,210 @@
+/**
+ * Parse `docs/architecture.md` into a layer table.
+ *
+ * Convention: the architecture doc contains a single GFM-style table with the columns
+ * `Layer`, `Files`, `Allowed`, `Forbidden`, optionally followed by a `Description` column.
+ * `Files` and `Allowed`/`Forbidden` cells use comma-separated values; backticks around
+ * globs are stripped.
+ *
+ * Example:
+ * ```
+ * | Layer    | Files                | Allowed                  | Forbidden          |
+ * |----------|----------------------|--------------------------|--------------------|
+ * | domain   | `src/domain/**`      | domain                   | infra, ui          |
+ * | infra    | `src/infrastructure/**` | domain, infra         | ui                 |
+ * | ui       | `src/ui/**`          | domain, infra, ui        | —                  |
+ * ```
+ *
+ * Empty cells (`—`, `-`, blank) are treated as the empty list.
+ *
+ * The parser is deliberately permissive: malformed tables produce `[]`, not an error. The
+ * layer-context-inject hook degrades gracefully when no rules are parsed.
+ */
+
+import type { HarnessLayerRule } from "../../types.js";
+
+interface Row {
+  layer: string;
+  files: string[];
+  allowed: string[];
+  forbidden: string[];
+  description?: string;
+}
+
+const LAYER_HEADERS = ["layer"];
+const FILE_HEADERS = ["files", "globs", "paths"];
+const ALLOWED_HEADERS = ["allowed", "allowedimports", "imports"];
+const FORBIDDEN_HEADERS = ["forbidden", "forbiddenimports", "denied"];
+const DESCRIPTION_HEADERS = ["description", "notes"];
+
+function normalizeHeader(value: string): string {
+  return value.toLowerCase().replace(/[^a-z]/g, "");
+}
+
+function parseListCell(cell: string): string[] {
+  const stripped = cell.trim();
+  if (!stripped || stripped === "—" || stripped === "-") return [];
+  return stripped
+    .split(",")
+    .map((part) => part.replace(/`/g, "").trim())
+    .filter((part) => part.length > 0);
+}
+
+function isSeparatorRow(cells: string[]): boolean {
+  // GFM table separators look like `|---|---|---|` — every cell is dashes (with optional
+  // colons for alignment).
+  return cells.every((cell) => /^[-:\s]+$/.test(cell));
+}
+
+function splitRow(line: string): string[] {
+  // Strip leading/trailing pipe, split on `|`, trim each cell.
+  const trimmed = line.trim();
+  const inner = trimmed.replace(/^\||\|$/g, "");
+  return inner.split("|").map((c) => c.trim());
+}
+
+/**
+ * Walk markdown line-by-line and extract every well-formed table. Returns rows from the
+ * FIRST table whose header includes a `Layer` column. Subsequent tables are ignored —
+ * the architecture doc convention is one canonical layer table.
+ */
+function findLayerTable(markdown: string): Row[] {
+  const lines = markdown.split(/\r?\n/);
+  let inTable = false;
+  let columnMap: { layer?: number; files?: number; allowed?: number; forbidden?: number; description?: number } | null = null;
+  const rows: Row[] = [];
+
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i];
+    const isPipeLine = line.includes("|");
+
+    if (!inTable) {
+      if (!isPipeLine) continue;
+      const cells = splitRow(line);
+      const next = i + 1 < lines.length ? lines[i + 1] : "";
+      if (!next.includes("|")) continue;
+      if (!isSeparatorRow(splitRow(next))) continue;
+
+      // Header row.
+      const map: { layer?: number; files?: number; allowed?: number; forbidden?: number; description?: number } = {};
+      for (let c = 0; c < cells.length; c += 1) {
+        const header = normalizeHeader(cells[c]);
+        if (LAYER_HEADERS.includes(header)) map.layer = c;
+        else if (FILE_HEADERS.includes(header)) map.files = c;
+        else if (ALLOWED_HEADERS.includes(header)) map.allowed = c;
+        else if (FORBIDDEN_HEADERS.includes(header)) map.forbidden = c;
+        else if (DESCRIPTION_HEADERS.includes(header)) map.description = c;
+      }
+
+      // Reject tables that are missing the essential columns.
+      if (map.layer === undefined || map.files === undefined) continue;
+      if (map.allowed === undefined && map.forbidden === undefined) continue;
+
+      columnMap = map;
+      inTable = true;
+      i += 1; // skip the separator on next iteration
+      continue;
+    }
+
+    if (!isPipeLine) {
+      // Blank line or non-table content terminates the table.
+      break;
+    }
+
+    const cells = splitRow(line);
+    if (isSeparatorRow(cells)) continue;
+    if (!columnMap) continue;
+
+    const layer = cells[columnMap.layer ?? 0]?.trim();
+    if (!layer) continue;
+
+    rows.push({
+      layer,
+      files: parseListCell(cells[columnMap.files ?? 0] ?? ""),
+      allowed: columnMap.allowed !== undefined ? parseListCell(cells[columnMap.allowed] ?? "") : [],
+      forbidden: columnMap.forbidden !== undefined ? parseListCell(cells[columnMap.forbidden] ?? "") : [],
+      description:
+        columnMap.description !== undefined && cells[columnMap.description]?.trim()
+          ? cells[columnMap.description].trim()
+          : undefined,
+    });
+  }
+
+  return rows;
+}
+
+/**
+ * Parse architecture markdown into HarnessLayerRule entries. Returns `[]` when no
+ * recognizable layer table is present.
+ */
+export function parseArchitectureMarkdown(markdown: string): HarnessLayerRule[] {
+  const rows = findLayerTable(markdown);
+  return rows.map((row) => ({
+    layer: row.layer,
+    globs: row.files,
+    allowedImports: row.allowed,
+    forbiddenImports: row.forbidden,
+    ...(row.description ? { description: row.description } : {}),
+  }));
+}
+
+/**
+ * Resolve the layer for a given file path against parsed rules. Glob matching is naive:
+ * we strip ``**`` and trailing slashes and check `startsWith` after normalization. This
+ * handles the convention `src/<layer>/**` without dragging in a glob library.
+ */
+export function resolveLayerForFile(
+  filePath: string,
+  rules: readonly HarnessLayerRule[],
+): HarnessLayerRule | null {
+  const normalized = filePath.replace(/\\/g, "/");
+  for (const rule of rules) {
+    for (const glob of rule.globs) {
+      if (matchesGlob(normalized, glob)) return rule;
+    }
+  }
+  return null;
+}
+
+/**
+ * Naive glob matcher tuned for the conventions parsed from architecture tables. Supports
+ * `**` (any path segments) and `*` (any single segment characters). Sufficient for the
+ * `src/<layer>/**` and `packages/<scope>/**\/*.ts` shapes the doc relies on.
+ */
+function matchesGlob(filePath: string, glob: string): boolean {
+  const normalizedGlob = glob.replace(/\\/g, "/");
+  const regexSrc = normalizedGlob
+    .split(/(\*\*|\*)/g)
+    .map((segment) => {
+      if (segment === "**") return ".*";
+      if (segment === "*") return "[^/]*";
+      return segment.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+    })
+    .join("");
+  const regex = new RegExp(`^${regexSrc}$`);
+  return regex.test(filePath);
+}
+
+/**
+ * Build the addendum string injected by the layer-context-inject hook. Caps at the
+ * configured `addendum_max_chars` to bound prompt growth; truncation appends `…` so the
+ * agent sees the cut.
+ */
+export function buildLayerAddendum(
+  filePath: string,
+  rule: HarnessLayerRule,
+  maxChars: number,
+): string {
+  const allowed = rule.allowedImports.length > 0 ? rule.allowedImports.join(", ") : "(none)";
+  const forbidden = rule.forbiddenImports.length > 0 ? rule.forbiddenImports.join(", ") : "(none)";
+  const lines = [
+    `# Architecture context (from docs/architecture.md)`,
+    `You are editing \`${filePath}\` in the \`${rule.layer}\` layer.`,
+    `- Permitted imports: ${allowed}`,
+    `- Forbidden imports: ${forbidden}`,
+  ];
+  if (rule.description) lines.push(`- Notes: ${rule.description}`);
+  const text = lines.join("\n");
+  if (text.length <= maxChars) return text;
+  return `${text.slice(0, Math.max(0, maxChars - 1))}…`;
+}

package/src/harness/anti_slop/backend-factory.ts

@@ -0,0 +1,30 @@
+/**
+ * Build a `SlopBackend` adapter from the user-selected backend choice.
+ *
+ * Lives here (in `anti_slop/`) so both `hooks/register.ts` and the per-stage CLI
+ * subcommands in `command.ts` can call it without going through `register.ts`. Keeping
+ * it in `register.ts` would create a circular import once the validate subcommand
+ * needs the adapter.
+ */
+
+import type { HarnessAntiSlopBackend } from "../../types.js";
+import type { SlopBackend } from "./backend.js";
+import { DesloppifyAdapter } from "./desloppify-adapter.js";
+import { FallowAdapter } from "./fallow-adapter.js";
+
+export function buildBackendAdapter(
+  backend: HarnessAntiSlopBackend,
+): SlopBackend | null {
+  switch (backend) {
+    case "fallow":
+      return new FallowAdapter();
+    case "desloppify":
+      return new DesloppifyAdapter();
+    case "hybrid":
+      // Hybrid prefers fallow for TS subtrees; the hook adapter is a single instance, so
+      // we default to fallow and let GC fan out to desloppify for non-TS.
+      return new FallowAdapter();
+    case "supi-native":
+      return null;
+  }
+}

package/src/harness/anti_slop/backend.ts

@@ -0,0 +1,140 @@
+/**
+ * Anti-slop backend abstraction.
+ *
+ * Stages (Discover, Validate, GC) and runtime hooks (pre-edit dupe probe, post-session
+ * sweep) consume slop scans through this interface. Concrete adapters wrap external CLIs
+ * (`fallow`, `desloppify`) or implement supi-native scanning.
+ *
+ * Adapter contract:
+ *  - `scan` returns the union of duplicate, dead-code, and other findings;
+ *  - `dupes` is a focused near-duplicate scan (used by the pre-edit probe);
+ *  - `deadCode` is a focused dead-export scan (used by post-session sweep);
+ *  - `audit` runs the backend's full "everything that's wrong" pass (used by Validate);
+ *  - `fix` applies the backend's safe auto-fixes (used by GC).
+ *
+ * All operations are advisory. Adapters MUST handle CLI-not-installed gracefully by
+ * returning a `SlopBackendUnavailable` result (never throw) — callers route around the
+ * unavailability without aborting the pipeline.
+ */
+
+import type { Platform } from "../../platform/types.js";
+import type {
+  HarnessAntiSlopBackend,
+  HarnessSlopQueueEntry,
+} from "../../types.js";
+
+// ---------------------------------------------------------------------------
+// Result shapes
+// ---------------------------------------------------------------------------
+
+/** A finding produced by a backend scan, before being normalized into a queue entry. */
+export interface SlopFinding {
+  kind: HarnessSlopQueueEntry["kind"];
+  file: string;
+  range: HarnessSlopQueueEntry["range"];
+  severity: HarnessSlopQueueEntry["severity"];
+  source: HarnessSlopQueueEntry["source"];
+  message: string;
+  remediation?: string;
+  details?: Record<string, unknown>;
+  /** Hint to the queue layer: when these findings should cluster, the same key is shared. */
+  clusterKey?: string;
+}
+
+export interface SlopScanResult {
+  ok: true;
+  findings: SlopFinding[];
+  durationMs: number;
+  /** Free-form metadata (CLI version, stats, etc.). */
+  details?: Record<string, unknown>;
+}
+
+export interface SlopBackendUnavailable {
+  ok: false;
+  reason: "not-installed" | "version-too-old" | "execution-failed" | "timeout" | "config-missing";
+  message: string;
+  /** When `execution-failed`, exit code and stderr for diagnostics. */
+  exitCode?: number;
+  stderr?: string;
+}
+
+export type SlopBackendResult = SlopScanResult | SlopBackendUnavailable;
+
+// ---------------------------------------------------------------------------
+// Options shapes
+// ---------------------------------------------------------------------------
+
+export interface ScanOptions {
+  cwd: string;
+  /** When set, restricts the scan to the given subtree (relative to cwd). */
+  subtree?: string;
+  /** When true, only scan files changed since HEAD. */
+  changedSinceHead?: boolean;
+  /** Hard timeout in ms; the adapter aborts and returns `timeout` past this. */
+  timeoutMs?: number;
+}
+
+export interface DupesOptions extends ScanOptions {
+  /** Minimum similarity threshold (0–1). */
+  threshold?: number;
+  /** Minimum token count below which results are filtered out. */
+  minTokenCount?: number;
+  /** When set, only scan files within this list (relative paths). */
+  files?: string[];
+  /** When set, the proposed content is staged into a shadow copy before scanning. */
+  proposedWrite?: { file: string; content: string };
+}
+
+export type DeadCodeOptions = ScanOptions;
+export type AuditOptions = ScanOptions;
+
+export interface FixOptions extends ScanOptions {
+  /** Specific entry ids to fix. */
+  entryIds?: string[];
+  /** When true, the adapter applies fixes; when false, it dry-runs. */
+  apply: boolean;
+}
+
+export interface FixResult {
+  ok: boolean;
+  appliedIds: string[];
+  failedIds: { id: string; reason: string }[];
+  details?: Record<string, unknown>;
+}
+
+// ---------------------------------------------------------------------------
+// Adapter interface
+// ---------------------------------------------------------------------------
+
+export interface SlopBackend {
+  /** Identifier surfaced to score reports and queue entries. */
+  readonly id: HarnessAntiSlopBackend;
+
+  /** Quick availability check. Adapters cache the result for the lifetime of the process. */
+  isAvailable(platform: Platform): Promise<boolean>;
+
+  /** Full scan: duplicates + dead code + layer + other findings the backend supports. */
+  scan(platform: Platform, opts: ScanOptions): Promise<SlopBackendResult>;
+
+  /** Duplicate-only scan (focused for pre-edit probe). */
+  dupes(platform: Platform, opts: DupesOptions): Promise<SlopBackendResult>;
+
+  /** Dead-code-only scan (focused for post-session sweep). */
+  deadCode(platform: Platform, opts: DeadCodeOptions): Promise<SlopBackendResult>;
+
+  /** Full audit (used by Validate). */
+  audit(platform: Platform, opts: AuditOptions): Promise<SlopBackendResult>;
+
+  /** Apply mechanical auto-fixes. Returns the list of entry ids the adapter handled. */
+  fix(platform: Platform, opts: FixOptions): Promise<FixResult>;
+}
+
+/**
+ * Helper for adapters: clamp a value to a 0..1 range and return the default when undefined.
+ */
+export function clampThreshold(value: number | undefined, fallback: number): number {
+  if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+  if (value < 0) return 0;
+  if (value > 1) return 1;
+  return value;
+}