sequant 1.18.0 → 1.20.0

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "sequant",
   "description": "Structured workflow system for Claude Code - GitHub issue resolution with spec, exec, test, and QA phases",
-  "version": "1.18.0",
+  "version": "1.20.0",
   "author": {
     "name": "sequant-io",
     "email": "hello@sequant.io"

package/README.md

@@ -49,7 +49,7 @@ Or step-by-step:
 - Git (for worktree-based isolation)
 
 **For npm installation:**
-- Node.js 18+
+- Node.js 20+
 
 **Optional MCP servers (enhanced features):**
 - `chrome-devtools` — enables `/test` for browser-based UI testing

package/dist/bin/cli.js

@@ -45,6 +45,7 @@ import { dashboardCommand } from "../src/commands/dashboard.js";
 import { stateInitCommand, stateRebuildCommand, stateCleanCommand, } from "../src/commands/state.js";
 import { syncCommand, areSkillsOutdated } from "../src/commands/sync.js";
 import { mergeCommand } from "../src/commands/merge.js";
+import { conventionsCommand } from "../src/commands/conventions.js";
 import { getManifest } from "../src/lib/manifest.js";
 const program = new Command();
 // Handle --no-color before parsing
@@ -159,6 +160,12 @@ program
     .option("--json", "Output as JSON")
     .option("-v, --verbose", "Enable verbose output")
     .action(mergeCommand);
+program
+    .command("conventions")
+    .description("View and manage codebase conventions")
+    .option("--detect", "Re-run convention detection")
+    .option("--reset", "Clear detected conventions (keep manual)")
+    .action(conventionsCommand);
 program
     .command("logs")
     .description("View and analyze workflow run logs")

package/dist/src/commands/conventions.d.ts

@@ -0,0 +1,9 @@
+/**
+ * sequant conventions - View and manage codebase conventions
+ */
+interface ConventionsOptions {
+    detect?: boolean;
+    reset?: boolean;
+}
+export declare function conventionsCommand(options: ConventionsOptions): Promise<void>;
+export {};

package/dist/src/commands/conventions.js

@@ -0,0 +1,61 @@
+/**
+ * sequant conventions - View and manage codebase conventions
+ */
+import chalk from "chalk";
+import { detectAndSaveConventions, loadConventions, formatConventions, CONVENTIONS_PATH, } from "../lib/conventions-detector.js";
+import { fileExists, writeFile } from "../lib/fs.js";
+export async function conventionsCommand(options) {
+    if (options.reset) {
+        await handleReset();
+        return;
+    }
+    if (options.detect) {
+        await handleDetect();
+        return;
+    }
+    // Default: show current conventions
+    await handleShow();
+}
+async function handleDetect() {
+    console.log(chalk.blue("Detecting codebase conventions..."));
+    const result = await detectAndSaveConventions(process.cwd());
+    const count = Object.keys(result.detected).length;
+    console.log(chalk.green(`\nDetected ${count} conventions:`));
+    console.log(formatConventions(result));
+    console.log(chalk.gray(`\nSaved to ${CONVENTIONS_PATH}`));
+}
+async function handleReset() {
+    const existing = await loadConventions();
+    if (!existing) {
+        console.log(chalk.yellow("No conventions file found. Nothing to reset."));
+        return;
+    }
+    // Keep manual entries, clear detected
+    const reset = {
+        detected: {},
+        manual: existing.manual,
+        detectedAt: "",
+    };
+    await writeFile(CONVENTIONS_PATH, JSON.stringify(reset, null, 2));
+    console.log(chalk.green("Detected conventions cleared. Manual entries preserved."));
+    if (Object.keys(existing.manual).length > 0) {
+        console.log(chalk.gray("\nManual entries kept:"));
+        for (const [key, value] of Object.entries(existing.manual)) {
+            console.log(chalk.gray(`  ${key}: ${value}`));
+        }
+    }
+}
+async function handleShow() {
+    if (!(await fileExists(CONVENTIONS_PATH))) {
+        console.log(chalk.yellow("No conventions detected yet."));
+        console.log(chalk.gray("Run 'sequant conventions --detect' or 'sequant init' to detect conventions."));
+        return;
+    }
+    const conventions = await loadConventions();
+    if (!conventions) {
+        console.log(chalk.yellow("Could not read conventions file."));
+        return;
+    }
+    console.log(formatConventions(conventions));
+    console.log(chalk.gray(`\nEdit ${CONVENTIONS_PATH} to add manual overrides.`));
+}

package/dist/src/commands/init.js

@@ -9,6 +9,7 @@ import { copyTemplates } from "../lib/templates.js";
 import { createManifest } from "../lib/manifest.js";
 import { saveConfig } from "../lib/config.js";
 import { createDefaultSettings } from "../lib/settings.js";
+import { detectAndSaveConventions } from "../lib/conventions-detector.js";
 import { fileExists, ensureDir, readFile, writeFile } from "../lib/fs.js";
 import { commandExists, isGhAuthenticated, getInstallHint, } from "../lib/system.js";
 import { shouldUseInteractiveMode, getNonInteractiveReason, } from "../lib/tty.js";
@@ -347,6 +348,17 @@ export async function initCommand(options) {
     settingsSpinner.start();
     await createDefaultSettings();
     settingsSpinner.succeed("Created default settings");
+    // Detect codebase conventions
+    const conventionsSpinner = ui.spinner("Detecting codebase conventions...");
+    conventionsSpinner.start();
+    try {
+        const conventions = await detectAndSaveConventions(process.cwd());
+        const count = Object.keys(conventions.detected).length;
+        conventionsSpinner.succeed(`Detected ${count} codebase conventions`);
+    }
+    catch {
+        conventionsSpinner.warn("Could not detect conventions (non-blocking)");
+    }
     // Copy templates (with symlinks for scripts unless --no-symlinks)
     const templatesSpinner = ui.spinner("Copying templates...");
     templatesSpinner.start();

package/dist/src/lib/conventions-detector.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Codebase conventions detector
+ *
+ * Deterministic detection of observable codebase patterns.
+ * No AI/ML — just file scanning and pattern matching.
+ */
+/** Path to conventions file */
+export declare const CONVENTIONS_PATH = ".sequant/conventions.json";
+/**
+ * A single detected convention
+ */
+export interface Convention {
+    /** Machine-readable key */
+    key: string;
+    /** Human-readable label */
+    label: string;
+    /** Detected value */
+    value: string;
+    /** How it was detected */
+    source: "detected" | "manual";
+    /** What evidence triggered detection */
+    evidence?: string;
+}
+/**
+ * Full conventions file schema
+ */
+export interface ConventionsFile {
+    /** Auto-detected conventions */
+    detected: Record<string, string>;
+    /** User-provided overrides */
+    manual: Record<string, string>;
+    /** When detection was last run */
+    detectedAt: string;
+}
+/**
+ * Run all convention detectors
+ */
+export declare function detectConventions(projectRoot: string): Promise<Convention[]>;
+/**
+ * Load existing conventions file
+ */
+export declare function loadConventions(): Promise<ConventionsFile | null>;
+/**
+ * Save conventions, preserving manual entries
+ */
+export declare function saveConventions(detected: Convention[]): Promise<ConventionsFile>;
+/**
+ * Get merged conventions (manual overrides detected)
+ */
+export declare function getMergedConventions(file: ConventionsFile): Record<string, string>;
+/**
+ * Format conventions for display
+ */
+export declare function formatConventions(file: ConventionsFile): string;
+/**
+ * Detect and save conventions in one call
+ */
+export declare function detectAndSaveConventions(projectRoot: string): Promise<ConventionsFile>;
+/**
+ * Format conventions as context for AI skills
+ */
+export declare function formatConventionsForContext(file: ConventionsFile): string;