projscan 4.3.1 → 4.5.0

package/dist/types/reviewContract.d.ts

@@ -0,0 +1,9 @@
+export interface ReviewContractChange {
+    kind: 'export-added' | 'export-removed' | 'export-renamed' | 'entrypoint-changed' | 'public-export-changed' | 'signature-changed';
+    file: string;
+    symbol?: string;
+    before?: string;
+    after?: string;
+    confidence: 'high' | 'medium' | 'low';
+    why: string;
+}

package/dist/types/reviewContract.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=reviewContract.js.map

package/dist/types/reviewContract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reviewContract.js","sourceRoot":"","sources":["../../src/types/reviewContract.ts"],"names":[],"mappings":""}

package/dist/types/scanning.d.ts

@@ -0,0 +1,111 @@
+export interface ScanResult {
+    rootPath: string;
+    totalFiles: number;
+    totalDirectories: number;
+    files: FileEntry[];
+    directoryTree: DirectoryNode;
+    scanDurationMs: number;
+    scanBoundary: ScanBoundary;
+}
+export interface ScanBoundary {
+    source: 'git' | 'glob';
+    gitignoreRespected: boolean;
+    includeIgnored: boolean;
+    ignoredFileCount: number;
+}
+export interface FileEntry {
+    relativePath: string;
+    absolutePath: string;
+    extension: string;
+    sizeBytes: number;
+    directory: string;
+}
+export interface DirectoryNode {
+    name: string;
+    path: string;
+    children: DirectoryNode[];
+    fileCount: number;
+    totalFileCount: number;
+}
+export interface LanguageBreakdown {
+    primary: string;
+    languages: Record<string, LanguageStat>;
+}
+export interface LanguageStat {
+    name: string;
+    fileCount: number;
+    percentage: number;
+    extensions: string[];
+}
+export interface FrameworkResult {
+    frameworks: DetectedFramework[];
+    buildTools: string[];
+    packageManager: 'npm' | 'yarn' | 'pnpm' | 'unknown';
+}
+export interface DetectedFramework {
+    name: string;
+    version?: string;
+    category: 'frontend' | 'backend' | 'testing' | 'bundler' | 'css' | 'other';
+    confidence: 'high' | 'medium' | 'low';
+}
+export interface DependencyReport {
+    totalDependencies: number;
+    totalDevDependencies: number;
+    dependencies: Record<string, string>;
+    devDependencies: Record<string, string>;
+    risks: DependencyRisk[];
+    licenses?: DependencyLicenseSummary;
+    sizes?: DependencySizeSummary;
+    /**
+     * Per-workspace breakdown when scanning a monorepo (0.13.0+). Absent for
+     * single-package repos. The top-level `totalDependencies`,
+     * `totalDevDependencies`, `dependencies`, `devDependencies`, and `risks`
+     * fields aggregate across all workspaces (root manifest + each package).
+     * For per-package detail, read this array.
+     */
+    byWorkspace?: Array<{
+        workspace: string;
+        relativePath: string;
+        isRoot: boolean;
+        totalDependencies: number;
+        totalDevDependencies: number;
+        risks: DependencyRisk[];
+    }>;
+}
+export interface DependencyLicenseEntry {
+    name: string;
+    version: string;
+    scope: 'production' | 'development';
+    license: string | null;
+    workspace?: string;
+}
+export interface DependencyLicenseSummary {
+    packages: DependencyLicenseEntry[];
+    byLicense: Record<string, number>;
+    unknown: string[];
+    copyleft: DependencyLicenseEntry[];
+    noticeCandidates: DependencyLicenseEntry[];
+}
+export interface DependencySizeEntry {
+    name: string;
+    version: string;
+    scope: 'production' | 'development';
+    bytes: number | null;
+    formatted: string;
+    installed: boolean;
+    workspace?: string;
+}
+export interface DependencySizeSummary {
+    packages: DependencySizeEntry[];
+    largest: DependencySizeEntry[];
+    totalBytes: number;
+    formattedTotal: string;
+    missing: string[];
+}
+export interface DependencyRisk {
+    name: string;
+    reason: string;
+    severity: 'low' | 'medium' | 'high';
+    /** Workspace package name when found in a monorepo workspace manifest. Absent for the root. */
+    workspace?: string;
+}

package/dist/types/scanning.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=scanning.js.map

package/dist/types/scanning.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scanning.js","sourceRoot":"","sources":["../../src/types/scanning.ts"],"names":[],"mappings":""}

package/dist/types/session.d.ts

@@ -0,0 +1,42 @@
+import type { Issue } from './common.js';
+import type { PreflightSuggestedAction } from './preflight.js';
+export interface SessionCoordinationHint {
+    id: 'current-worktree-check' | 'remembered-session-context' | 'resolve-conflicts' | 'swarm-coordination' | 'agentloop-task-contract' | 'agentflight-verification';
+    label: string;
+    message: string;
+    command: string;
+}
+export interface SessionResourceSummary {
+    schemaVersion: 1;
+    sessionId: string;
+    touchedFiles: string[];
+    recentIssues: Issue[];
+    highRiskTouchedFiles: Array<{
+        file: string;
+        riskScore: number;
+    }>;
+    staleSignals: string[];
+    coordinationHints: SessionCoordinationHint[];
+    truncated?: boolean;
+}
+export interface SessionConflict {
+    kind: 'same-file' | 'import-related' | 'same-workspace' | 'taint-related' | 'hotspot-overlap';
+    files: string[];
+    message: string;
+    severity: 'warning' | 'error';
+}
+export interface SessionHandoff {
+    schemaVersion: 1;
+    summary: SessionResourceSummary;
+    remainingRisks: SessionConflict[];
+    suggestedNextActions: PreflightSuggestedAction[];
+    coordinationHints: SessionCoordinationHint[];
+    avoidRepeating: string[];
+}
+export interface RiskNowResource {
+    schemaVersion: 1;
+    conflicts: SessionConflict[];
+    touchedFiles: string[];
+    coordinationHints: SessionCoordinationHint[];
+    truncated?: boolean;
+}

package/dist/types/session.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=session.js.map

package/dist/types/session.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.js","sourceRoot":"","sources":["../../src/types/session.ts"],"names":[],"mappings":""}

package/dist/types/start.d.ts

@@ -0,0 +1,437 @@
+import type { PreflightSuggestedAction, PreflightVerdict } from './preflight.js';
+import type { FixFirstRecommendation, WorkplanMode, WorkplanPriority } from './workplan.js';
+import type { WorkplanHandoffPayload } from './workplanHandoff.js';
+import type { QualityScorecardVerdict } from './qualityScorecard.js';
+import type { SessionCoordinationHint } from './session.js';
+export interface StartWorkflowRecommendation {
+    id: string;
+    name: string;
+    why: string;
+    commands: string[];
+    mcpTools: string[];
+}
+export interface StartRisk {
+    id: string;
+    priority: WorkplanPriority;
+    title: string;
+    source: string;
+    files: string[];
+    command: string;
+}
+export interface StartAdoptionGap {
+    id: string;
+    status: 'info' | 'warn' | 'fail';
+    title: string;
+    summary: string;
+    command?: string;
+}
+export interface StartAdoptionLoopMetric {
+    id: string;
+    label: string;
+    target: string;
+    command?: string;
+}
+export interface StartAdoptionLoop {
+    cadence: 'every_pr';
+    why: string;
+    metrics: StartAdoptionLoopMetric[];
+    nextCommands: string[];
+}
+export interface StartFirstTenMinutesStep {
+    id: string;
+    label: string;
+    why: string;
+    command: string;
+}
+export interface StartFirstTenMinutes {
+    title: string;
+    outcome: string;
+    commands: StartFirstTenMinutesStep[];
+}
+export type StartModeSource = 'explicit' | 'intent' | 'default';
+export type StartMissionControlStatus = 'ready' | 'needs_setup' | 'needs_attention' | 'blocked';
+export interface StartRoutedIntent {
+    intent: string;
+    category: string;
+    tool: string;
+    cli: string;
+    why: string;
+    example: string;
+    confidence: 'high' | 'medium' | 'low';
+    rank: number;
+    score: number;
+    matchedKeywords: string[];
+}
+export interface StartUnresolvedInput {
+    name: string;
+    placeholder: string;
+    sourceAction: string;
+    instruction: string;
+}
+export interface StartMissionResumeReference {
+    id: string;
+    phaseId: StartExecutionPhaseId;
+    kind: StartExecutionStepKind;
+    status: StartExecutionStatus;
+    label: string;
+    instruction?: string;
+    command?: string;
+    placeholder?: string;
+}
+export interface StartMissionToolCall {
+    tool: string;
+    args?: Record<string, unknown>;
+}
+export interface StartMissionProofToolCall extends StartMissionToolCall {
+    stepId: string;
+    command: string;
+}
+export interface StartMissionProofItem {
+    stepId: string;
+    status: StartExecutionStatus;
+    label: string;
+    command: string;
+    toolCall?: StartMissionToolCall;
+}
+export interface StartMissionInputBinding {
+    inputId: string;
+    label: string;
+    placeholder: string;
+    instruction: string;
+    followUpIds: string[];
+}
+export type StartMissionResumeChecklistItemKind = 'run_current' | 'resolve_input' | 'run_follow_up' | 'run_proof' | 'confirm_done';
+export interface StartMissionResumeChecklistItem {
+    id: string;
+    kind: StartMissionResumeChecklistItemKind;
+    phaseId: StartExecutionPhaseId;
+    stepId: string;
+    status: StartExecutionStatus;
+    label: string;
+    command?: string;
+    tool?: string;
+    args?: Record<string, unknown>;
+    placeholder?: string;
+    instruction?: string;
+    blockedBy?: string[];
+    dependsOn?: string[];
+    unlocks?: string[];
+    followUpIds?: string[];
+}
+export interface StartMissionResumeFollowUp {
+    id: string;
+    phaseId: StartExecutionPhaseId;
+    kind: StartExecutionStepKind;
+    status: StartExecutionStatus;
+    label: string;
+    command?: string;
+    tool?: string;
+    args?: Record<string, unknown>;
+    blockedBy?: string[];
+    dependsOn?: string[];
+}
+export interface StartMissionResume {
+    currentStep: StartExecutionCursor;
+    status: StartExecutionStatus;
+    instruction: string;
+    prompt: string;
+    commandBlock?: string;
+    toolCall?: StartMissionToolCall;
+    followUps?: StartMissionResumeFollowUp[];
+    inputBindings?: StartMissionInputBinding[];
+    checklist?: StartMissionResumeChecklistItem[];
+    remainingProofItems?: StartMissionProofItem[];
+    remainingProofCommands?: string[];
+    remainingProofToolCalls?: StartMissionProofToolCall[];
+    unlocks?: StartMissionResumeReference[];
+    blockedBy?: StartMissionResumeReference[];
+}
+export interface StartMissionHandoff {
+    currentStep: StartExecutionCursor;
+    resume: StartMissionResume;
+    reviewGate: StartMissionReviewGate;
+    nextAction: PreflightSuggestedAction;
+    readyActions: PreflightSuggestedAction[];
+    needsInput: StartUnresolvedInput[];
+    doneWhen: string[];
+    readyProof: {
+        summary: string;
+        commands: string[];
+        toolCalls?: StartMissionProofToolCall[];
+        items?: StartMissionProofItem[];
+    };
+}
+export type StartExecutionPhaseId = 'next_action' | 'ready_now' | 'resolve_inputs' | 'follow_up' | 'proof' | 'done_when';
+export type StartExecutionStatus = 'ready' | 'blocked' | 'pending';
+export type StartExecutionStepKind = 'tool' | 'input' | 'proof' | 'criterion' | 'handoff';
+export interface StartExecutionStep {
+    id: string;
+    kind: StartExecutionStepKind;
+    status: StartExecutionStatus;
+    label: string;
+    command?: string;
+    tool?: string;
+    args?: Record<string, unknown>;
+    instruction?: string;
+    placeholder?: string;
+    dependsOn?: string[];
+    blockedBy?: string[];
+    unlocks?: string[];
+}
+export interface StartExecutionPhase {
+    id: StartExecutionPhaseId;
+    title: string;
+    status: StartExecutionStatus;
+    steps: StartExecutionStep[];
+}
+export interface StartExecutionCursor {
+    phaseId: StartExecutionPhaseId;
+    stepId: string;
+    status: StartExecutionStatus;
+    kind: StartExecutionStepKind;
+    label: string;
+    command?: string;
+    tool?: string;
+    args?: Record<string, unknown>;
+    instruction?: string;
+    placeholder?: string;
+    blockedBy?: string[];
+    unlocks?: string[];
+    reason: string;
+}
+export interface StartExecutionPlan {
+    summary: string;
+    currentPhase: StartExecutionPhaseId;
+    cursor: StartExecutionCursor;
+    phases: StartExecutionPhase[];
+}
+export interface StartMissionRunbook {
+    title: string;
+    status: StartMissionControlStatus;
+    currentPhase: StartExecutionPhaseId;
+    currentStep: StartExecutionCursor;
+    resume: StartMissionResume;
+    readyCommandBlock: string;
+    blockedInputSummary?: string;
+    markdown: string;
+}
+export interface StartMissionReviewWorktree {
+    available: boolean;
+    clean: boolean;
+    changedFileCount: number;
+    files: string[];
+    baseRef: string | null;
+    summary: string;
+    reason?: string;
+}
+export interface StartMissionReviewProof {
+    summary: string;
+    commands: string[];
+    toolCalls?: StartMissionProofToolCall[];
+    items?: StartMissionProofItem[];
+}
+export type StartMissionReviewBlockedAction = 'next_slice' | 'release' | 'publish' | 'deploy' | 'push' | 'merge' | 'version_bump';
+export interface StartMissionReviewPolicy {
+    approvalRequired: true;
+    blockedActions: StartMissionReviewBlockedAction[];
+    summary: string;
+}
+export interface StartMissionReviewDecision {
+    id: 'approve_next_slice' | 'request_changes' | 'review_version_candidate';
+    label: string;
+    description: string;
+    consequence: string;
+    reply: string;
+}
+export interface StartMissionReviewGate {
+    title: string;
+    required: true;
+    status: StartMissionControlStatus;
+    stopCondition: string;
+    reviewPrompt: string;
+    checklist: string[];
+    doneWhen: string[];
+    policy: StartMissionReviewPolicy;
+    decisions: StartMissionReviewDecision[];
+    commands: string[];
+    worktree: StartMissionReviewWorktree;
+    proof: StartMissionReviewProof;
+    markdown: string;
+}
+export type MissionRunStatus = 'not_run' | 'running' | 'passed' | 'failed' | 'unknown';
+export interface MissionProofStatusRow {
+    id: string;
+    label?: string;
+    log?: string;
+    command?: string;
+    exitCode?: number;
+}
+export interface MissionReviewDecisionRecord {
+    decision: 'approve_next_slice' | 'request_changes' | 'review_version_candidate' | string;
+    reviewer?: string;
+    at?: string;
+    note?: string;
+}
+export interface MissionOutcome {
+    schemaVersion: 1;
+    available: boolean;
+    missionDir: string;
+    status: MissionRunStatus;
+    reason?: string;
+    nextAction?: string;
+    proof: {
+        completedCommands: number;
+        failedCommands: number;
+        reruns: number;
+        totalCommands?: number;
+        failedStep?: string;
+        failedLog?: string;
+        exitCode?: number;
+        rows: MissionProofStatusRow[];
+    };
+    review: {
+        decisions: MissionReviewDecisionRecord[];
+        approvals: number;
+        changeRequests: number;
+        versionCandidateReviews: number;
+    };
+    whatChanged: string[];
+    whatRemains: string[];
+    versionCandidate: {
+        recommendation: 'run_proof' | 'wait' | 'review_candidate' | 'do_not_cut';
+        summary: string;
+    };
+    resumePrompt: string;
+}
+export interface MissionProofBaselineRun {
+    id: string;
+    status: MissionRunStatus;
+    failedGates?: number;
+    reruns?: number;
+    minutesSpent?: number;
+    reviewerApprovals?: number;
+}
+export interface MissionProofTotals {
+    missions: number;
+    passed: number;
+    failed: number;
+    running: number;
+    notRun: number;
+    unavailable: number;
+    proofCompletionRate: number;
+    reruns: number;
+    failedGates: number;
+    reviewerApprovals: number;
+}
+export interface MissionProofReport {
+    schemaVersion: 1;
+    readOnly: true;
+    rootPath: string;
+    summary: string;
+    missionControl: {
+        missions: MissionOutcome[];
+        totals: MissionProofTotals;
+    };
+    baseline?: {
+        path: string;
+        runs: MissionProofBaselineRun[];
+        totals: MissionProofTotals & {
+            minutesSpent: number;
+        };
+    };
+    comparison?: {
+        completionRateDelta: number;
+        rerunsAvoided: number;
+        failedGatesAvoided: number;
+        minutesSaved: number;
+    };
+    riskAvoided: string[];
+    nextActions: PreflightSuggestedAction[];
+}
+export interface StartMissionTaskCard {
+    title: string;
+    status: StartMissionControlStatus;
+    currentPhase: StartExecutionPhaseId;
+    currentStep: StartExecutionCursor;
+    markdown: string;
+}
+export interface StartMissionControl {
+    intent?: string;
+    status: StartMissionControlStatus;
+    headline: string;
+    whyNow: string;
+    primaryAction: PreflightSuggestedAction;
+    actionPlan: PreflightSuggestedAction[];
+    readyActions: PreflightSuggestedAction[];
+    routedIntent?: StartRoutedIntent;
+    alternatives?: StartRoutedIntent[];
+    unresolvedInputs: StartUnresolvedInput[];
+    guardrails: PreflightSuggestedAction[];
+    successCriteria: string[];
+    proofSummary: string;
+    proofCommands: string[];
+    resume: StartMissionResume;
+    handoff: StartMissionHandoff;
+    executionPlan: StartExecutionPlan;
+    runbook: StartMissionRunbook;
+    reviewGate: StartMissionReviewGate;
+    taskCard: StartMissionTaskCard;
+    outcome?: MissionOutcome;
+    handoffPrompt: string;
+}
+export interface StartReport {
+    schemaVersion: 1;
+    readOnly: true;
+    rootPath: string;
+    mode: WorkplanMode;
+    modeSource: StartModeSource;
+    modeReason: string;
+    summary: string;
+    setup: {
+        overall: 'pass' | 'warn' | 'fail' | 'info';
+        diagnostics: Array<{
+            id: string;
+            label: string;
+            status: 'pass' | 'warn' | 'fail' | 'info';
+            summary: string;
+            detail?: string;
+            command?: string;
+        }>;
+    };
+    recommendedWorkflow: StartWorkflowRecommendation;
+    firstTenMinutes: StartFirstTenMinutes;
+    missionControl: StartMissionControl;
+    coordinationHints: SessionCoordinationHint[];
+    evidence: {
+        workplanVerdict: PreflightVerdict;
+        workplanSummary: string;
+        qualityVerdict: QualityScorecardVerdict;
+        qualitySummary: string;
+        healthScore: number;
+        mcpReady: boolean;
+        riskSources: {
+            currentWorktree: {
+                kind: 'current-worktree';
+                available: boolean;
+                count: number;
+                files: string[];
+                baseRef: string | null;
+                reason?: string;
+            };
+            sessionMemory: {
+                kind: 'remembered-session';
+                touchedFiles: string[];
+                totalTouchedFiles: number;
+                note: string;
+                truncated?: boolean;
+            };
+        };
+    };
+    topRisks: StartRisk[];
+    fixFirst?: FixFirstRecommendation;
+    adoptionGaps: StartAdoptionGap[];
+    adoptionLoop?: StartAdoptionLoop;
+    nextActions: PreflightSuggestedAction[];
+    handoff?: WorkplanHandoffPayload;
+    truncated?: boolean;
+}

package/dist/types/start.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=start.js.map

package/dist/types/start.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"start.js","sourceRoot":"","sources":["../../src/types/start.ts"],"names":[],"mappings":""}

package/dist/types/trial.d.ts

@@ -0,0 +1,27 @@
+import type { DogfoodReport, DogfoodWebsiteProof, FeedbackSummaryReport } from './dogfood.js';
+import type { PreflightSuggestedAction } from './preflight.js';
+export type TrialVerdict = 'adopt' | 'pilot' | 'tune' | 'setup';
+export interface TrialReport {
+    schemaVersion: 1;
+    readOnly: true;
+    rootPath: string;
+    verdict: TrialVerdict;
+    summary: string;
+    activation: {
+        status: 'pass' | 'warn' | 'fail';
+        setupOverall: 'pass' | 'warn' | 'fail';
+        healthScore: number;
+        mcpReady: boolean;
+        adoptionLoopReady: boolean;
+        firstPrCommand: string;
+        feedbackCommand: string;
+    };
+    feedback?: FeedbackSummaryReport;
+    dogfood: DogfoodReport;
+    decision: {
+        adoptable: boolean;
+        reasons: string[];
+    };
+    websiteProof: DogfoodWebsiteProof;
+    nextCommands: PreflightSuggestedAction[];
+}

package/dist/types/trial.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=trial.js.map

package/dist/types/trial.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trial.js","sourceRoot":"","sources":["../../src/types/trial.ts"],"names":[],"mappings":""}