sequant 1.12.0 → 1.13.1

package/dist/src/lib/upstream/report.js

@@ -0,0 +1,391 @@
+/**
+ * Report generation for upstream assessments
+ * Creates markdown reports for GitHub issues and local files
+ */
+/**
+ * Calculate summary counts from findings
+ */
+export function calculateSummary(findings) {
+    const summary = {
+        breakingChanges: 0,
+        deprecations: 0,
+        newTools: 0,
+        hookChanges: 0,
+        opportunities: 0,
+        noAction: 0,
+    };
+    for (const finding of findings) {
+        switch (finding.category) {
+            case "breaking":
+                summary.breakingChanges++;
+                break;
+            case "deprecation":
+                summary.deprecations++;
+                break;
+            case "new-tool":
+                summary.newTools++;
+                break;
+            case "hook-change":
+                summary.hookChanges++;
+                break;
+            case "opportunity":
+                summary.opportunities++;
+                break;
+            case "no-action":
+                summary.noAction++;
+                break;
+        }
+    }
+    return summary;
+}
+/**
+ * Get action status text for summary table
+ */
+function getActionStatus(count, category) {
+    if (count === 0) {
+        return "None";
+    }
+    switch (category) {
+        case "breaking":
+            return "Review required";
+        case "deprecation":
+            return "Review needed";
+        case "new-tool":
+        case "hook-change":
+        case "opportunity":
+            return "Issues created";
+        default:
+            return "None";
+    }
+}
+/**
+ * Format a finding for the assessment report
+ */
+function formatFinding(finding, index) {
+    const lines = [];
+    lines.push(`#### ${index + 1}. ${finding.title}`);
+    lines.push("");
+    if (finding.description !== finding.title) {
+        lines.push(`> ${finding.description}`);
+        lines.push("");
+    }
+    if (finding.matchedKeywords.length > 0) {
+        lines.push(`- **Matched keywords:** ${finding.matchedKeywords.join(", ")}`);
+    }
+    if (finding.matchedPatterns.length > 0) {
+        lines.push(`- **Matched patterns:** ${finding.matchedPatterns.join(", ")}`);
+    }
+    if (finding.sequantFiles.length > 0) {
+        lines.push(`- **Affected files:** ${finding.sequantFiles.join(", ")}`);
+    }
+    lines.push(`- **Impact:** ${finding.impact}`);
+    if (finding.issueNumber) {
+        lines.push(`- **Issue created:** #${finding.issueNumber}`);
+    }
+    if (finding.existingIssue) {
+        lines.push(`- **Existing issue:** #${finding.existingIssue}`);
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+/**
+ * Generate the assessment issue body
+ */
+export function generateAssessmentReport(assessment) {
+    const { version, releaseDate, assessmentDate, findings, summary, dryRun } = assessment;
+    const lines = [];
+    // Header
+    lines.push(`## Upstream: Claude Code ${version} Assessment`);
+    lines.push("");
+    lines.push(`**Release:** [${version}](https://github.com/anthropics/claude-code/releases/tag/${version})`);
+    lines.push(`**Released:** ${releaseDate}`);
+    lines.push(`**Assessed:** ${assessmentDate}`);
+    if (dryRun) {
+        lines.push(`**Mode:** Dry Run (no issues created)`);
+    }
+    lines.push("");
+    // Summary table
+    lines.push("### Summary");
+    lines.push("");
+    lines.push("| Category | Count | Action Required |");
+    lines.push("|----------|-------|-----------------|");
+    lines.push(`| Breaking Changes | ${summary.breakingChanges} | ${getActionStatus(summary.breakingChanges, "breaking")} |`);
+    lines.push(`| Deprecations | ${summary.deprecations} | ${getActionStatus(summary.deprecations, "deprecation")} |`);
+    lines.push(`| New Tools | ${summary.newTools} | ${getActionStatus(summary.newTools, "new-tool")} |`);
+    lines.push(`| Hook Changes | ${summary.hookChanges} | ${getActionStatus(summary.hookChanges, "hook-change")} |`);
+    lines.push(`| Opportunities | ${summary.opportunities} | ${getActionStatus(summary.opportunities, "opportunity")} |`);
+    lines.push(`| No Action | ${summary.noAction} | None |`);
+    lines.push("");
+    // Breaking Changes section
+    const breakingFindings = findings.filter((f) => f.category === "breaking");
+    lines.push("### Breaking Changes");
+    lines.push("");
+    if (breakingFindings.length === 0) {
+        lines.push("None detected.");
+    }
+    else {
+        breakingFindings.forEach((f, i) => {
+            lines.push(formatFinding(f, i));
+        });
+    }
+    lines.push("");
+    // Deprecations section
+    const deprecations = findings.filter((f) => f.category === "deprecation");
+    lines.push("### Deprecations");
+    lines.push("");
+    if (deprecations.length === 0) {
+        lines.push("None detected.");
+    }
+    else {
+        deprecations.forEach((f, i) => {
+            lines.push(formatFinding(f, i));
+        });
+    }
+    lines.push("");
+    // New Tools section
+    const newTools = findings.filter((f) => f.category === "new-tool");
+    lines.push("### New Tools");
+    lines.push("");
+    if (newTools.length === 0) {
+        lines.push("None detected.");
+    }
+    else {
+        newTools.forEach((f, i) => {
+            lines.push(formatFinding(f, i));
+        });
+    }
+    lines.push("");
+    // Hook Changes section
+    const hookChanges = findings.filter((f) => f.category === "hook-change");
+    lines.push("### Hook Changes");
+    lines.push("");
+    if (hookChanges.length === 0) {
+        lines.push("None detected.");
+    }
+    else {
+        hookChanges.forEach((f, i) => {
+            lines.push(formatFinding(f, i));
+        });
+    }
+    lines.push("");
+    // Opportunities section
+    const opportunities = findings.filter((f) => f.category === "opportunity");
+    lines.push("### Feature Opportunities");
+    lines.push("");
+    if (opportunities.length === 0) {
+        lines.push("None detected.");
+    }
+    else {
+        opportunities.forEach((f, i) => {
+            lines.push(formatFinding(f, i));
+        });
+    }
+    lines.push("");
+    // No Action section
+    const noAction = findings.filter((f) => f.category === "no-action");
+    lines.push("### No Action Required");
+    lines.push("");
+    if (noAction.length === 0) {
+        lines.push("All changes were relevant.");
+    }
+    else {
+        lines.push(`${noAction.length} changes did not require action:`);
+        lines.push("");
+        noAction.forEach((f) => {
+            lines.push(`- ${f.description}`);
+        });
+    }
+    lines.push("");
+    // Footer
+    lines.push("---");
+    lines.push("");
+    lines.push("*Generated by /upstream skill*");
+    return lines.join("\n");
+}
+/**
+ * Generate an individual issue body for an actionable finding
+ */
+export function generateFindingIssue(finding, version, assessmentIssueNumber) {
+    const lines = [];
+    // Determine issue type prefix
+    let prefix;
+    switch (finding.category) {
+        case "breaking":
+            prefix = "fix";
+            break;
+        case "deprecation":
+            prefix = "chore";
+            break;
+        default:
+            prefix = "feat";
+    }
+    // Generate title
+    const title = `${prefix}: ${finding.title} (from Claude Code ${version})`;
+    // Body
+    lines.push(`**Upstream:** Claude Code ${version}`);
+    lines.push(`**Category:** ${formatCategory(finding.category)}`);
+    if (assessmentIssueNumber) {
+        lines.push(`**Assessment:** #${assessmentIssueNumber}`);
+    }
+    lines.push("");
+    lines.push("### Context");
+    lines.push("");
+    lines.push(finding.description);
+    lines.push("");
+    if (finding.sequantFiles.length > 0) {
+        lines.push("### Affected Files");
+        lines.push("");
+        finding.sequantFiles.forEach((f) => {
+            lines.push(`- \`${f}\``);
+        });
+        lines.push("");
+    }
+    lines.push("### Opportunity");
+    lines.push("");
+    lines.push("[To be analyzed during /spec phase]");
+    lines.push("");
+    lines.push("### Proposed Implementation");
+    lines.push("");
+    lines.push("[To be determined during /spec phase]");
+    lines.push("");
+    lines.push("### Acceptance Criteria");
+    lines.push("");
+    lines.push("- [ ] AC-1: [To be defined]");
+    lines.push("");
+    lines.push("---");
+    lines.push("");
+    if (assessmentIssueNumber) {
+        lines.push(`*Auto-created by /upstream assessment #${assessmentIssueNumber}*`);
+    }
+    else {
+        lines.push("*Auto-created by /upstream skill*");
+    }
+    // Labels
+    const labels = ["upstream", "needs-triage"];
+    switch (finding.category) {
+        case "breaking":
+            labels.push("bug", "priority:high");
+            break;
+        case "deprecation":
+            labels.push("bug");
+            break;
+        default:
+            labels.push("enhancement");
+    }
+    return {
+        title,
+        body: lines.join("\n"),
+        labels,
+    };
+}
+/**
+ * Generate a batched summary issue for multiple versions
+ */
+export function generateBatchedSummaryReport(batched) {
+    const lines = [];
+    lines.push(`## Upstream: Claude Code Assessment (${batched.sinceVersion} → ${batched.toVersion})`);
+    lines.push("");
+    lines.push(`**Versions assessed:** ${batched.versions.length}`);
+    lines.push(`**From:** ${batched.sinceVersion}`);
+    lines.push(`**To:** ${batched.toVersion}`);
+    lines.push("");
+    // Summary across all versions
+    const totals = {
+        breakingChanges: 0,
+        deprecations: 0,
+        newTools: 0,
+        hookChanges: 0,
+        opportunities: 0,
+        noAction: 0,
+    };
+    for (const assessment of batched.assessments) {
+        totals.breakingChanges += assessment.summary.breakingChanges;
+        totals.deprecations += assessment.summary.deprecations;
+        totals.newTools += assessment.summary.newTools;
+        totals.hookChanges += assessment.summary.hookChanges;
+        totals.opportunities += assessment.summary.opportunities;
+        totals.noAction += assessment.summary.noAction;
+    }
+    lines.push("### Combined Summary");
+    lines.push("");
+    lines.push("| Category | Total |");
+    lines.push("|----------|-------|");
+    lines.push(`| Breaking Changes | ${totals.breakingChanges} |`);
+    lines.push(`| Deprecations | ${totals.deprecations} |`);
+    lines.push(`| New Tools | ${totals.newTools} |`);
+    lines.push(`| Hook Changes | ${totals.hookChanges} |`);
+    lines.push(`| Opportunities | ${totals.opportunities} |`);
+    lines.push("");
+    // Per-version breakdown
+    lines.push("### Per-Version Breakdown");
+    lines.push("");
+    for (const assessment of batched.assessments) {
+        const actionable = assessment.summary.breakingChanges +
+            assessment.summary.deprecations +
+            assessment.summary.newTools +
+            assessment.summary.hookChanges +
+            assessment.summary.opportunities;
+        lines.push(`#### ${assessment.version}`);
+        lines.push("");
+        lines.push(`- Released: ${assessment.releaseDate}`);
+        lines.push(`- Actionable findings: ${actionable}`);
+        if (assessment.issuesCreated.length > 0) {
+            lines.push(`- Issues created: ${assessment.issuesCreated.map((n) => `#${n}`).join(", ")}`);
+        }
+        lines.push("");
+    }
+    lines.push("---");
+    lines.push("");
+    lines.push("*Generated by /upstream skill*");
+    return lines.join("\n");
+}
+/**
+ * Generate local report markdown file
+ */
+export function generateLocalReport(assessment) {
+    const lines = [];
+    lines.push(`# Claude Code ${assessment.version} Assessment`);
+    lines.push("");
+    lines.push(`**Assessed:** ${assessment.assessmentDate}`);
+    if (assessment.previousVersion) {
+        lines.push(`**Previous:** ${assessment.previousVersion}`);
+    }
+    lines.push("");
+    // Include full assessment report
+    lines.push(generateAssessmentReport(assessment));
+    lines.push("");
+    // Add raw data section for debugging
+    lines.push("## Raw Data");
+    lines.push("");
+    lines.push("```json");
+    lines.push(JSON.stringify({
+        version: assessment.version,
+        releaseDate: assessment.releaseDate,
+        assessmentDate: assessment.assessmentDate,
+        previousVersion: assessment.previousVersion,
+        summary: assessment.summary,
+        issuesCreated: assessment.issuesCreated,
+        findingCount: assessment.findings.length,
+    }, null, 2));
+    lines.push("```");
+    return lines.join("\n");
+}
+/**
+ * Format category for display
+ */
+function formatCategory(category) {
+    switch (category) {
+        case "breaking":
+            return "Breaking Change";
+        case "deprecation":
+            return "Deprecation";
+        case "new-tool":
+            return "New Tool";
+        case "hook-change":
+            return "Hook Change";
+        case "opportunity":
+            return "Feature Opportunity";
+        case "no-action":
+            return "No Action";
+    }
+}

package/dist/src/lib/upstream/types.d.ts

@@ -0,0 +1,207 @@
+/**
+ * Types for the upstream assessment module
+ * Tracks Claude Code releases and compatibility with sequant
+ */
+/**
+ * Categories for classifying changes from upstream releases
+ */
+export type FindingCategory = "breaking" | "deprecation" | "new-tool" | "hook-change" | "opportunity" | "no-action";
+/**
+ * Impact level for a finding
+ */
+export type ImpactLevel = "high" | "medium" | "low" | "none";
+/**
+ * A single finding from release analysis
+ */
+export interface Finding {
+    /** Category of the change */
+    category: FindingCategory;
+    /** Brief title describing the change */
+    title: string;
+    /** Full description from release notes */
+    description: string;
+    /** Impact level on sequant */
+    impact: ImpactLevel;
+    /** Keywords that triggered detection */
+    matchedKeywords: string[];
+    /** Regex patterns that matched */
+    matchedPatterns: string[];
+    /** Affected sequant files from dependency map */
+    sequantFiles: string[];
+    /** GitHub issue number if created */
+    issueNumber?: number;
+    /** Existing issue number if duplicate found */
+    existingIssue?: number;
+}
+/**
+ * Summary counts for an assessment
+ */
+export interface AssessmentSummary {
+    breakingChanges: number;
+    deprecations: number;
+    newTools: number;
+    hookChanges: number;
+    opportunities: number;
+    noAction: number;
+}
+/**
+ * Complete assessment result for a release
+ */
+export interface UpstreamAssessment {
+    /** Version tag (e.g., "v2.1.29") */
+    version: string;
+    /** Release date from GitHub */
+    releaseDate: string;
+    /** Date when assessment was performed */
+    assessmentDate: string;
+    /** Previous version (for --since support) */
+    previousVersion: string | null;
+    /** All findings from the assessment */
+    findings: Finding[];
+    /** Issue numbers created during assessment */
+    issuesCreated: number[];
+    /** Summary counts by category */
+    summary: AssessmentSummary;
+    /** Whether this was a dry run */
+    dryRun: boolean;
+}
+/**
+ * Release data from GitHub API
+ */
+export interface ReleaseData {
+    /** Version tag name (e.g., "v2.1.29") */
+    tagName: string;
+    /** Release title */
+    name: string;
+    /** Release body/changelog content */
+    body: string;
+    /** Publication date */
+    publishedAt: string;
+}
+/**
+ * Tools configuration in baseline
+ */
+export interface ToolsConfig {
+    /** Core tools sequant relies on */
+    core: string[];
+    /** Optional tools that enhance functionality */
+    optional: string[];
+}
+/**
+ * Hooks configuration in baseline
+ */
+export interface HooksConfig {
+    /** Hook types sequant uses */
+    used: string[];
+    /** Files that implement hooks */
+    files: string[];
+}
+/**
+ * MCP servers configuration in baseline
+ */
+export interface McpServersConfig {
+    /** Required MCP servers */
+    required: string[];
+    /** Optional MCP servers */
+    optional: string[];
+}
+/**
+ * Permissions configuration in baseline
+ */
+export interface PermissionsConfig {
+    /** Permission patterns used */
+    patterns: string[];
+    /** Files containing permission configs */
+    files: string[];
+}
+/**
+ * Baseline configuration for sequant capabilities
+ */
+export interface Baseline {
+    /** Last assessed version (null if never assessed) */
+    lastAssessedVersion: string | null;
+    /** Schema version for migration support */
+    schemaVersion: string;
+    /** Tools configuration */
+    tools: ToolsConfig;
+    /** Hooks configuration */
+    hooks: HooksConfig;
+    /** MCP servers configuration */
+    mcpServers: McpServersConfig;
+    /** Permissions configuration */
+    permissions: PermissionsConfig;
+    /** Keywords to match in release notes */
+    keywords: string[];
+    /** Map of keywords to affected sequant files */
+    dependencyMap: Record<string, string[]>;
+}
+/**
+ * Regex patterns for detecting change types
+ */
+export interface DetectionPatterns {
+    newTool: RegExp;
+    deprecation: RegExp;
+    breaking: RegExp;
+    hook: RegExp;
+    permission: RegExp;
+    mcp: RegExp;
+}
+/**
+ * Options for running an upstream assessment
+ */
+export interface AssessmentOptions {
+    /** Specific version to assess (default: latest) */
+    version?: string;
+    /** Assess all versions since this version */
+    since?: string;
+    /** Skip issue creation */
+    dryRun?: boolean;
+    /** Force re-assessment even if already done */
+    force?: boolean;
+}
+/**
+ * Result of checking for duplicate issues
+ */
+export interface DuplicateCheckResult {
+    /** Whether a duplicate was found */
+    isDuplicate: boolean;
+    /** Existing issue number if duplicate */
+    existingIssue?: number;
+    /** Existing issue title if duplicate */
+    existingTitle?: string;
+}
+/**
+ * GitHub issue creation parameters
+ */
+export interface IssueParams {
+    /** Issue title */
+    title: string;
+    /** Issue body in markdown */
+    body: string;
+    /** Labels to apply */
+    labels: string[];
+}
+/**
+ * Result of creating an issue
+ */
+export interface IssueResult {
+    /** Created issue number */
+    number: number;
+    /** Issue URL */
+    url: string;
+}
+/**
+ * Batched assessment for multiple versions
+ */
+export interface BatchedAssessment {
+    /** All versions assessed */
+    versions: string[];
+    /** Individual assessments */
+    assessments: UpstreamAssessment[];
+    /** Summary issue number */
+    summaryIssueNumber?: number;
+    /** Start version (from --since) */
+    sinceVersion: string;
+    /** End version (latest assessed) */
+    toVersion: string;
+}

package/dist/src/lib/upstream/types.js

@@ -0,0 +1,5 @@
+/**
+ * Types for the upstream assessment module
+ * Tracks Claude Code releases and compatibility with sequant
+ */
+export {};

package/dist/src/lib/workflow/log-writer.d.ts

@@ -85,4 +85,4 @@ export declare class LogWriter {
  *
  * Utility function for creating phase logs when you have start/end times.
  */
-export declare function createPhaseLogFromTiming(phase: Phase, issueNumber: number, startTime: Date, endTime: Date, status: PhaseLog["status"], options?: Partial<Pick<PhaseLog, "error" | "iterations" | "filesModified" | "testsRun" | "testsPassed">>): PhaseLog;
+export declare function createPhaseLogFromTiming(phase: Phase, issueNumber: number, startTime: Date, endTime: Date, status: PhaseLog["status"], options?: Partial<Pick<PhaseLog, "error" | "iterations" | "filesModified" | "testsRun" | "testsPassed" | "verdict">>): PhaseLog;

package/dist/src/lib/workflow/metrics-schema.d.ts

@@ -20,8 +20,8 @@ import { z } from "zod";
  * Outcome of a workflow run
  */
 export declare const RunOutcomeSchema: z.ZodEnum<{
-    failed: "failed";
     success: "success";
+    failed: "failed";
     partial: "partial";
 }>;
 export type RunOutcome = z.infer<typeof RunOutcomeSchema>;
@@ -73,8 +73,8 @@ export declare const MetricRunSchema: z.ZodObject<{
         test: "test";
     }>>;
     outcome: z.ZodEnum<{
-        failed: "failed";
         success: "success";
+        failed: "failed";
         partial: "partial";
     }>;
     duration: z.ZodNumber;
@@ -110,8 +110,8 @@ export declare const MetricsSchema: z.ZodObject<{
             test: "test";
         }>>;
         outcome: z.ZodEnum<{
-            failed: "failed";
             success: "success";
+            failed: "failed";
             partial: "partial";
         }>;
         duration: z.ZodNumber;