sequant 1.20.3 → 2.0.1

package/dist/src/lib/assess-comment-parser.d.ts

@@ -0,0 +1,137 @@
+/**
+ * Assess Comment Parser
+ *
+ * Detects and parses /assess command output from GitHub issue comments.
+ * This is the unified parser that handles both the new /assess format
+ * and the legacy /solve format for backward compatibility.
+ *
+ * When an assess comment exists, its phase recommendations take precedence
+ * over content analysis (but not over labels).
+ *
+ * @example
+ * ```typescript
+ * import { findAssessComment, parseAssessWorkflow } from './assess-comment-parser';
+ *
+ * const comments = [
+ *   { body: "Some regular comment" },
+ *   { body: "## Assess Analysis\n\n→ PROCEED — Ready.\n\n<!-- assess:phases=spec,exec,qa -->" },
+ * ];
+ *
+ * const assessComment = findAssessComment(comments);
+ * if (assessComment) {
+ *   const workflow = parseAssessWorkflow(assessComment.body);
+ *   // workflow: { phases: ['spec', 'exec', 'qa'], action: 'PROCEED', ... }
+ * }
+ * ```
+ */
+import type { Phase } from "./workflow/types.js";
+import type { PhaseSignal } from "./phase-signal.js";
+/**
+ * The 6 fixed actions that /assess can recommend
+ */
+export type AssessAction = "PROCEED" | "CLOSE" | "MERGE" | "REWRITE" | "CLARIFY" | "PARK";
+/**
+ * Result of parsing an assess comment (superset of SolveWorkflowResult)
+ */
+export interface AssessWorkflowResult {
+    /** Phases recommended by assess (only meaningful for PROCEED) */
+    phases: Phase[];
+    /** Whether quality loop is recommended */
+    qualityLoop: boolean;
+    /** The issue numbers mentioned in the assess comment */
+    issueNumbers: number[];
+    /** Raw workflow string (e.g., "spec → exec → qa") */
+    workflowString?: string;
+    /** The recommended action (one of the 6 fixed actions) */
+    action?: AssessAction;
+}
+/**
+ * Backward-compatible alias for AssessWorkflowResult
+ */
+export type SolveWorkflowResult = AssessWorkflowResult;
+/**
+ * Comment structure (simplified from GitHub API)
+ */
+export interface IssueComment {
+    body: string;
+    author?: {
+        login: string;
+    };
+    createdAt?: string;
+}
+/**
+ * Structured data extracted from HTML comment markers
+ */
+export interface AssessMarkers {
+    /** Recommended phases */
+    phases?: string[];
+    /** Whether quality loop is recommended */
+    qualityLoop?: boolean;
+    /** The recommended action */
+    action?: AssessAction;
+}
+/**
+ * Backward-compatible alias for AssessMarkers
+ */
+export type SolveMarkers = AssessMarkers;
+/**
+ * Check if a comment is an assess command output (new format)
+ */
+export declare function isAssessComment(body: string): boolean;
+/**
+ * Check if a comment is a solve command output (legacy format)
+ * @deprecated Use isAssessComment instead
+ */
+export declare function isSolveComment(body: string): boolean;
+/**
+ * Find the most recent assess/solve comment from a list of comments
+ */
+export declare function findAssessComment(comments: IssueComment[]): IssueComment | null;
+/**
+ * Find the most recent solve comment from a list of comments
+ * @deprecated Use findAssessComment instead
+ */
+export declare function findSolveComment(comments: IssueComment[]): IssueComment | null;
+/**
+ * Parse HTML comment markers from a comment body
+ *
+ * Supports both `assess:` and `solve:` prefixes.
+ * When both are present, `assess:` markers take precedence.
+ */
+export declare function parseAssessMarkers(body: string): AssessMarkers;
+/**
+ * Parse HTML comment markers (backward-compatible alias)
+ * @deprecated Use parseAssessMarkers instead
+ */
+export declare function parseSolveMarkers(body: string): AssessMarkers;
+/**
+ * Parse an assess/solve comment to extract workflow information
+ */
+export declare function parseAssessWorkflow(body: string): AssessWorkflowResult;
+/**
+ * Parse a solve comment to extract workflow information
+ * @deprecated Use parseAssessWorkflow instead
+ */
+export declare function parseSolveWorkflow(body: string): AssessWorkflowResult;
+/**
+ * Convert assess workflow result to phase signals
+ */
+export declare function assessWorkflowToSignals(workflow: AssessWorkflowResult): PhaseSignal[];
+/**
+ * Convert solve workflow result to phase signals
+ *
+ * Preserves "/solve" wording in reason strings for backward compatibility
+ * with existing tests and consumers.
+ *
+ * @deprecated Use assessWorkflowToSignals instead
+ */
+export declare function solveWorkflowToSignals(workflow: AssessWorkflowResult): PhaseSignal[];
+/**
+ * Check if assess/solve comment covers the current issue
+ */
+export declare function assessCoversIssue(workflow: AssessWorkflowResult, issueNumber: number): boolean;
+/**
+ * Check if solve comment covers the current issue
+ * @deprecated Use assessCoversIssue instead
+ */
+export declare function solveCoversIssue(workflow: AssessWorkflowResult, issueNumber: number): boolean;

package/dist/src/lib/assess-comment-parser.js

@@ -0,0 +1,344 @@
+/**
+ * Assess Comment Parser
+ *
+ * Detects and parses /assess command output from GitHub issue comments.
+ * This is the unified parser that handles both the new /assess format
+ * and the legacy /solve format for backward compatibility.
+ *
+ * When an assess comment exists, its phase recommendations take precedence
+ * over content analysis (but not over labels).
+ *
+ * @example
+ * ```typescript
+ * import { findAssessComment, parseAssessWorkflow } from './assess-comment-parser';
+ *
+ * const comments = [
+ *   { body: "Some regular comment" },
+ *   { body: "## Assess Analysis\n\n→ PROCEED — Ready.\n\n<!-- assess:phases=spec,exec,qa -->" },
+ * ];
+ *
+ * const assessComment = findAssessComment(comments);
+ * if (assessComment) {
+ *   const workflow = parseAssessWorkflow(assessComment.body);
+ *   // workflow: { phases: ['spec', 'exec', 'qa'], action: 'PROCEED', ... }
+ * }
+ * ```
+ */
+/**
+ * Markers that indicate an assess comment (new format)
+ */
+const ASSESS_MARKERS = [
+    "## Assess Analysis",
+    "## Assess Workflow",
+    "*Generated by `/assess",
+];
+/**
+ * Markers that indicate a solve comment (legacy format)
+ */
+const SOLVE_MARKERS = [
+    "## Solve Analysis",
+    "## Solve Workflow for Issues:",
+    "## Solve Workflow for Issue:",
+    "### Recommended Workflow",
+    "*📝 Generated by `/solve",
+];
+/**
+ * All markers (both assess and solve)
+ */
+const ALL_MARKERS = [...ASSESS_MARKERS, ...SOLVE_MARKERS];
+/**
+ * Pattern to extract phases from workflow string
+ * Matches: `/spec`, `/exec`, `/test`, `/qa`, etc.
+ * Also matches without slash: `spec`, `exec`, `test`, `qa` (for arrow notation)
+ */
+const PHASE_PATTERN = /\/?(?<!\w)(spec|exec|test|qa|security-review|testgen|loop)(?!\w)/g;
+/**
+ * Pattern to detect quality loop recommendation
+ */
+const QUALITY_LOOP_PATTERNS = [
+    /quality\s*loop.*auto-enable/i,
+    /--quality-loop/i,
+    /quality\s*loop.*recommended/i,
+    /enable.*quality\s*loop/i,
+];
+/**
+ * Pattern to extract structured data from HTML comment markers
+ * Matches both: <!-- assess:phases=exec,qa --> and <!-- solve:phases=exec,qa -->
+ */
+const HTML_MARKER_PATTERN = /<!--\s*(?:assess|solve):(\w[\w-]*)=([\w,.-]*)\s*-->/g;
+/**
+ * Pattern to extract assess-specific HTML markers (takes precedence)
+ */
+const ASSESS_HTML_MARKER_PATTERN = /<!--\s*assess:(\w[\w-]*)=([\w,.-]*)\s*-->/g;
+/**
+ * Pattern to extract issue numbers from header
+ * Matches: "## Solve Workflow for Issues: 123, 456" or "#123"
+ */
+const ISSUE_NUMBER_PATTERN = /#?(\d+)/g;
+/**
+ * Valid assess actions
+ */
+const VALID_ACTIONS = [
+    "PROCEED",
+    "CLOSE",
+    "MERGE",
+    "REWRITE",
+    "CLARIFY",
+    "PARK",
+];
+// ─── Detection Functions ────────────────────────────────────────────────────
+/**
+ * Check if a comment is an assess command output (new format)
+ */
+export function isAssessComment(body) {
+    return ALL_MARKERS.some((marker) => body.includes(marker));
+}
+/**
+ * Check if a comment is a solve command output (legacy format)
+ * @deprecated Use isAssessComment instead
+ */
+export function isSolveComment(body) {
+    return isAssessComment(body);
+}
+/**
+ * Find the most recent assess/solve comment from a list of comments
+ */
+export function findAssessComment(comments) {
+    for (let i = comments.length - 1; i >= 0; i--) {
+        if (isAssessComment(comments[i].body)) {
+            return comments[i];
+        }
+    }
+    return null;
+}
+/**
+ * Find the most recent solve comment from a list of comments
+ * @deprecated Use findAssessComment instead
+ */
+export function findSolveComment(comments) {
+    return findAssessComment(comments);
+}
+// ─── Parsing Functions ──────────────────────────────────────────────────────
+/**
+ * Parse phases from a workflow string
+ */
+function parseWorkflowString(workflowString) {
+    const phases = [];
+    const matches = workflowString.matchAll(PHASE_PATTERN);
+    for (const match of matches) {
+        const phase = match[1];
+        if (!phases.includes(phase)) {
+            phases.push(phase);
+        }
+    }
+    return phases;
+}
+/**
+ * Parse HTML comment markers from a comment body
+ *
+ * Supports both `assess:` and `solve:` prefixes.
+ * When both are present, `assess:` markers take precedence.
+ */
+export function parseAssessMarkers(body) {
+    const markers = {};
+    // First pass: collect all markers (both assess: and solve:)
+    const allMatches = body.matchAll(HTML_MARKER_PATTERN);
+    for (const match of allMatches) {
+        applyMarker(markers, match[1], match[2]);
+    }
+    // Second pass: assess: markers override solve: markers
+    const assessMatches = body.matchAll(ASSESS_HTML_MARKER_PATTERN);
+    for (const match of assessMatches) {
+        applyMarker(markers, match[1], match[2]);
+    }
+    return markers;
+}
+/**
+ * Apply a single marker key-value pair to the markers object
+ */
+function applyMarker(markers, key, value) {
+    switch (key) {
+        case "phases":
+            markers.phases = value.split(",").filter(Boolean);
+            break;
+        case "quality-loop":
+            markers.qualityLoop = value === "true";
+            break;
+        case "action":
+            if (VALID_ACTIONS.includes(value)) {
+                markers.action = value;
+            }
+            break;
+    }
+}
+/**
+ * Parse HTML comment markers (backward-compatible alias)
+ * @deprecated Use parseAssessMarkers instead
+ */
+export function parseSolveMarkers(body) {
+    return parseAssessMarkers(body);
+}
+/**
+ * Parse an assess/solve comment to extract workflow information
+ */
+export function parseAssessWorkflow(body) {
+    const result = {
+        phases: [],
+        qualityLoop: false,
+        issueNumbers: [],
+    };
+    // Extract action from "→ ACTION — reason" line
+    const actionMatch = body.match(/→\s*(PROCEED|CLOSE|MERGE|REWRITE|CLARIFY|PARK)\s*[—-]/);
+    if (actionMatch) {
+        result.action = actionMatch[1];
+    }
+    // Extract issue numbers from header (both old and new formats)
+    const headerMatch = body.match(/## (?:Assess|Solve) (?:Workflow for Issues?|Analysis)(?::\s*|\s+for\s+)([^\n]+)/i);
+    if (headerMatch) {
+        const numberMatches = headerMatch[1].matchAll(ISSUE_NUMBER_PATTERN);
+        for (const match of numberMatches) {
+            const num = parseInt(match[1], 10);
+            if (!isNaN(num) && !result.issueNumbers.includes(num)) {
+                result.issueNumbers.push(num);
+            }
+        }
+    }
+    // Try HTML comment markers first (most reliable, machine-readable)
+    const markers = parseAssessMarkers(body);
+    // Action from markers overrides inline detection
+    if (markers.action) {
+        result.action = markers.action;
+    }
+    if (markers.phases && markers.phases.length > 0) {
+        result.phases = markers.phases;
+        result.workflowString = markers.phases.join(" → ");
+    }
+    if (markers.qualityLoop !== undefined) {
+        result.qualityLoop = markers.qualityLoop;
+    }
+    // If we got phases from markers, we're done with phase detection
+    if (result.phases.length > 0) {
+        return result;
+    }
+    // Find workflow lines (e.g., "/spec 152" or "spec → exec → qa")
+    const lines = body.split("\n");
+    // First pass: look for arrow notation (most reliable)
+    for (const line of lines) {
+        if (line.includes("→") || line.includes("->")) {
+            const phases = parseWorkflowString(line);
+            if (phases.length > 0) {
+                result.phases = phases;
+                result.workflowString = line.trim();
+                break;
+            }
+        }
+    }
+    // Second pass: if no arrow notation found, collect phases from multiple lines
+    if (result.phases.length === 0) {
+        const collectedPhases = [];
+        for (const line of lines) {
+            if (line.includes("/spec") ||
+                line.includes("/exec") ||
+                line.includes("/test") ||
+                line.includes("/qa")) {
+                const linePhases = parseWorkflowString(line);
+                for (const phase of linePhases) {
+                    if (!collectedPhases.includes(phase)) {
+                        collectedPhases.push(phase);
+                    }
+                }
+            }
+        }
+        if (collectedPhases.length > 0) {
+            result.phases = collectedPhases;
+            result.workflowString = collectedPhases.map((p) => `/${p}`).join(" → ");
+        }
+    }
+    // If no phases found from lines, try full body
+    if (result.phases.length === 0) {
+        result.phases = parseWorkflowString(body);
+    }
+    // Check for quality loop recommendation (if not already set by markers)
+    if (!result.qualityLoop) {
+        for (const pattern of QUALITY_LOOP_PATTERNS) {
+            if (pattern.test(body)) {
+                result.qualityLoop = true;
+                break;
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Parse a solve comment to extract workflow information
+ * @deprecated Use parseAssessWorkflow instead
+ */
+export function parseSolveWorkflow(body) {
+    return parseAssessWorkflow(body);
+}
+// ─── Signal Conversion ──────────────────────────────────────────────────────
+/**
+ * Convert assess workflow result to phase signals
+ */
+export function assessWorkflowToSignals(workflow) {
+    const signals = [];
+    for (const phase of workflow.phases) {
+        signals.push({
+            phase,
+            source: "assess",
+            confidence: "high",
+            reason: `Recommended by /assess command: ${workflow.workflowString || phase}`,
+        });
+    }
+    if (workflow.qualityLoop) {
+        signals.push({
+            phase: "quality-loop",
+            source: "assess",
+            confidence: "high",
+            reason: "Quality loop recommended by /assess command",
+        });
+    }
+    return signals;
+}
+/**
+ * Convert solve workflow result to phase signals
+ *
+ * Preserves "/solve" wording in reason strings for backward compatibility
+ * with existing tests and consumers.
+ *
+ * @deprecated Use assessWorkflowToSignals instead
+ */
+export function solveWorkflowToSignals(workflow) {
+    const signals = [];
+    for (const phase of workflow.phases) {
+        signals.push({
+            phase,
+            source: "solve",
+            confidence: "high",
+            reason: `Recommended by /solve command: ${workflow.workflowString || phase}`,
+        });
+    }
+    if (workflow.qualityLoop) {
+        signals.push({
+            phase: "quality-loop",
+            source: "solve",
+            confidence: "high",
+            reason: "Quality loop recommended by /solve command",
+        });
+    }
+    return signals;
+}
+// ─── Utility Functions ──────────────────────────────────────────────────────
+/**
+ * Check if assess/solve comment covers the current issue
+ */
+export function assessCoversIssue(workflow, issueNumber) {
+    return workflow.issueNumbers.includes(issueNumber);
+}
+/**
+ * Check if solve comment covers the current issue
+ * @deprecated Use assessCoversIssue instead
+ */
+export function solveCoversIssue(workflow, issueNumber) {
+    return assessCoversIssue(workflow, issueNumber);
+}

package/dist/src/lib/ci/config.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Repository-level CI configuration loader.
+ *
+ * Reads .github/sequant.yml (or .sequant/ci.json) for repo-level defaults
+ * that are merged with workflow inputs. This lets teams set default agents,
+ * phases, and cost controls without editing workflow files.
+ */
+import { type CIConfig } from "./types.js";
+/**
+ * Load CI configuration from the repository.
+ *
+ * Checks (in order):
+ * 1. .github/sequant.yml (YAML — parsed as simple key: value)
+ * 2. .sequant/ci.json (JSON)
+ *
+ * Returns CI_DEFAULTS if no config file is found.
+ */
+export declare function loadCIConfig(repoRoot: string): CIConfig;
+/**
+ * Merge config with defaults (for display/documentation purposes).
+ */
+export declare function resolveConfig(config: CIConfig): Required<CIConfig>;

package/dist/src/lib/ci/config.js

@@ -0,0 +1,134 @@
+/**
+ * Repository-level CI configuration loader.
+ *
+ * Reads .github/sequant.yml (or .sequant/ci.json) for repo-level defaults
+ * that are merged with workflow inputs. This lets teams set default agents,
+ * phases, and cost controls without editing workflow files.
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { CI_DEFAULTS } from "./types.js";
+const VALID_PHASES = new Set([
+    "spec",
+    "security-review",
+    "testgen",
+    "exec",
+    "test",
+    "qa",
+    "loop",
+]);
+const VALID_AGENTS = new Set(["claude-code", "aider", "codex"]);
+/**
+ * Load CI configuration from the repository.
+ *
+ * Checks (in order):
+ * 1. .github/sequant.yml (YAML — parsed as simple key: value)
+ * 2. .sequant/ci.json (JSON)
+ *
+ * Returns CI_DEFAULTS if no config file is found.
+ */
+export function loadCIConfig(repoRoot) {
+    // Try .github/sequant.yml first
+    const yamlPath = join(repoRoot, ".github", "sequant.yml");
+    const yamlConfig = tryLoadYaml(yamlPath);
+    if (yamlConfig)
+        return yamlConfig;
+    // Fall back to .sequant/ci.json
+    const jsonPath = join(repoRoot, ".sequant", "ci.json");
+    const jsonConfig = tryLoadJson(jsonPath);
+    if (jsonConfig)
+        return jsonConfig;
+    return {};
+}
+/**
+ * Parse a simple YAML config file (key: value, no nested structures).
+ * Avoids adding a YAML parser dependency for a simple flat config.
+ */
+function tryLoadYaml(path) {
+    let content;
+    try {
+        content = readFileSync(path, "utf-8");
+    }
+    catch {
+        return null;
+    }
+    const parsed = {};
+    for (const line of content.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+            continue;
+        const colonIdx = trimmed.indexOf(":");
+        if (colonIdx === -1)
+            continue;
+        const key = trimmed.slice(0, colonIdx).trim();
+        const value = trimmed.slice(colonIdx + 1).trim();
+        parsed[key] = value;
+    }
+    return normalizeConfig(parsed);
+}
+/**
+ * Load and parse a JSON config file.
+ */
+function tryLoadJson(path) {
+    try {
+        const content = readFileSync(path, "utf-8");
+        const parsed = JSON.parse(content);
+        return normalizeConfig(parsed);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Normalize a raw config object into validated CIConfig.
+ */
+function normalizeConfig(raw) {
+    const config = {};
+    if (typeof raw.agent === "string" && VALID_AGENTS.has(raw.agent)) {
+        config.agent = raw.agent;
+    }
+    if (typeof raw.phases === "string") {
+        const phases = raw.phases
+            .split(",")
+            .map((p) => p.trim())
+            .filter((p) => VALID_PHASES.has(p));
+        if (phases.length > 0)
+            config.phases = phases;
+    }
+    else if (Array.isArray(raw.phases)) {
+        const phases = raw.phases
+            .filter((p) => typeof p === "string")
+            .filter((p) => VALID_PHASES.has(p));
+        if (phases.length > 0)
+            config.phases = phases;
+    }
+    if (typeof raw.timeout === "number" && raw.timeout >= 60) {
+        config.timeout = raw.timeout;
+    }
+    else if (typeof raw.timeout === "string") {
+        const n = parseInt(raw.timeout, 10);
+        if (!isNaN(n) && n >= 60)
+            config.timeout = n;
+    }
+    if (typeof raw.qualityLoop === "boolean") {
+        config.qualityLoop = raw.qualityLoop;
+    }
+    else if (typeof raw.qualityLoop === "string") {
+        config.qualityLoop = raw.qualityLoop === "true";
+    }
+    const maxRuns = typeof raw.maxConcurrentRuns === "number"
+        ? raw.maxConcurrentRuns
+        : typeof raw.maxConcurrentRuns === "string"
+            ? parseInt(raw.maxConcurrentRuns, 10)
+            : NaN;
+    if (!isNaN(maxRuns) && maxRuns >= 1) {
+        config.maxConcurrentRuns = maxRuns;
+    }
+    return config;
+}
+/**
+ * Merge config with defaults (for display/documentation purposes).
+ */
+export function resolveConfig(config) {
+    return { ...CI_DEFAULTS, ...config };
+}

package/dist/src/lib/ci/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * CI integration module — provides everything needed to run sequant
+ * workflows from GitHub Actions or other CI/CD systems.
+ */
+export { loadCIConfig, resolveConfig } from "./config.js";
+export { parseInputs, validateInputs } from "./inputs.js";
+export type { RawActionInputs } from "./inputs.js";
+export { getFailureLabels, getStartLabels, getStartRemoveLabels, getSuccessLabels, labelCommands, } from "./labels.js";
+export { formatMultiOutputs, formatOutputs, formatSummary, outputCommands, } from "./outputs.js";
+export { detectTrigger } from "./triggers.js";
+export { CI_DEFAULTS, COMMENT_TRIGGER_PATTERN, LIFECYCLE_LABELS, TRIGGER_LABELS, } from "./types.js";
+export type { ActionInputs, ActionOutputs, CIConfig, GitHubContext, GitHubEventPayload, TriggerResult, TriggerType, } from "./types.js";

package/dist/src/lib/ci/index.js

@@ -0,0 +1,10 @@
+/**
+ * CI integration module — provides everything needed to run sequant
+ * workflows from GitHub Actions or other CI/CD systems.
+ */
+export { loadCIConfig, resolveConfig } from "./config.js";
+export { parseInputs, validateInputs } from "./inputs.js";
+export { getFailureLabels, getStartLabels, getStartRemoveLabels, getSuccessLabels, labelCommands, } from "./labels.js";
+export { formatMultiOutputs, formatOutputs, formatSummary, outputCommands, } from "./outputs.js";
+export { detectTrigger } from "./triggers.js";
+export { CI_DEFAULTS, COMMENT_TRIGGER_PATTERN, LIFECYCLE_LABELS, TRIGGER_LABELS, } from "./types.js";

package/dist/src/lib/ci/inputs.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Input parsing and validation for the GitHub Action.
+ *
+ * Parses raw string inputs from action.yml into validated ActionInputs,
+ * applying defaults and merging with repo-level configuration.
+ */
+import type { ActionInputs, CIConfig } from "./types.js";
+/**
+ * Raw inputs as received from GitHub Actions (all strings).
+ */
+export interface RawActionInputs {
+    issues?: string;
+    phases?: string;
+    agent?: string;
+    timeout?: string;
+    "quality-loop"?: string;
+    "api-key"?: string;
+}
+/**
+ * Parse and validate action inputs, merging with repo config.
+ *
+ * Merge precedence: workflow inputs > config file > action defaults
+ */
+export declare function parseInputs(raw: RawActionInputs, config?: CIConfig): ActionInputs;
+/**
+ * Validate that required inputs are present and well-formed.
+ * Returns an array of error messages (empty = valid).
+ */
+export declare function validateInputs(inputs: ActionInputs): string[];