@oss-autopilot/core 1.8.0 → 1.10.0

package/dist/commands/comments.js

@@ -185,6 +185,17 @@ export async function runClaim(options) {
             updatedAt: new Date().toISOString(),
             vetted: false,
         });
+        // Push state to Gist if in Gist mode.
+        // If getStateManagerAsync was not called before this command ran,
+        // isGistMode() will be false and checkpoint is correctly skipped.
+        try {
+            if (stateManager.isGistMode()) {
+                await stateManager.checkpoint();
+            }
+        }
+        catch {
+            /* best-effort */
+        }
     }
     catch (error) {
         console.error(`Warning: Comment posted on ${options.issueUrl} but failed to save to local state: ${error instanceof Error ? error.message : error}`);

package/dist/commands/config.js

@@ -3,7 +3,6 @@
  * Shows or updates configuration
  */
 import { getStateManager } from '../core/index.js';
-import { ValidationError } from '../core/errors.js';
 import { ISSUE_SCOPES } from '../core/types.js';
 import { validateGitHubUsername } from './validation.js';
 function validateScope(value) {
@@ -106,14 +105,6 @@ export async function runConfig(options) {
         case 'issueListPath':
             stateManager.updateConfig({ issueListPath: value || undefined });
             break;
-        case 'scoreThreshold': {
-            const threshold = Number(value);
-            if (!Number.isInteger(threshold) || threshold < 1 || threshold > 10) {
-                throw new ValidationError(`Invalid value for scoreThreshold: "${value}". Must be an integer between 1 and 10.`);
-            }
-            stateManager.updateConfig({ scoreThreshold: threshold });
-            break;
-        }
         default:
             throw new Error(`Unknown config key: ${options.key}`);
     }

package/dist/commands/daily.js

@@ -424,11 +424,21 @@ async function executeDailyCheckInternal(token) {
     const { prs, failures, mergedCounts, closedCounts, monthlyCounts, monthlyClosedCounts, openedFromMerged, openedFromClosed, recentlyClosedPRs, recentlyMergedPRs, commentedIssues, } = await fetchPRData(prMonitor, token);
     // Phase 2: Update repo scores (signals, star counts, trust sync)
     await updateRepoScores(prMonitor, prs, mergedCounts, closedCounts);
-    // Phase 3: Persist monthly analytics (batch the 3 monthly setter calls).
+    // Phase 3: Persist monthly analytics and store merged/closed PR history.
     // try-catch: analytics are supplementary — save failure should not crash the daily check.
     try {
         getStateManager().batch(() => {
             updateMonthlyAnalytics(prs, monthlyCounts, monthlyClosedCounts, openedFromMerged, openedFromClosed);
+            // Store recently merged/closed PRs in the persistent arrays.
+            // This ensures the mergedPRs/closedPRs ledger is populated even when
+            // the dashboard is never opened (which has its own fetch path).
+            // addMergedPRs/addClosedPRs deduplicate by URL, so overlaps are safe.
+            if (recentlyMergedPRs.length > 0) {
+                getStateManager().addMergedPRs(recentlyMergedPRs.map((pr) => ({ url: pr.url, title: pr.title, mergedAt: pr.mergedAt })));
+            }
+            if (recentlyClosedPRs.length > 0) {
+                getStateManager().addClosedPRs(recentlyClosedPRs.map((pr) => ({ url: pr.url, title: pr.title, closedAt: pr.closedAt })));
+            }
         });
     }
     catch (error) {
@@ -440,7 +450,20 @@ async function executeDailyCheckInternal(token) {
     // Phase 4: Partition PRs, generate and save digest
     const { activePRs, shelvedPRs, digest } = partitionPRs(prMonitor, prs, recentlyClosedPRs, recentlyMergedPRs);
     // Phase 5: Build structured output (capacity, dismiss filter, action menu)
-    return generateDigestOutput(digest, activePRs, shelvedPRs, commentedIssues, failures, previousLastDigestAt);
+    const result = generateDigestOutput(digest, activePRs, shelvedPRs, commentedIssues, failures, previousLastDigestAt);
+    // Checkpoint: push state to Gist if in Gist mode.
+    // If getStateManagerAsync was not called before this command ran,
+    // isGistMode() will be false and checkpoint is correctly skipped.
+    try {
+        const sm = getStateManager();
+        if (sm.isGistMode()) {
+            await sm.checkpoint();
+        }
+    }
+    catch (err) {
+        warn(MODULE, `Gist checkpoint failed: ${errorMessage(err)}`);
+    }
+    return result;
 }
 /**
  * Run the daily PR check and return a deduplicated digest.

package/dist/commands/index.d.ts

@@ -63,6 +63,7 @@ export { runCheckIntegration } from './check-integration.js';
 export { runDetectFormatters } from './detect-formatters.js';
 /** Scan for locally cloned repos. */
 export { runLocalRepos } from './local-repos.js';
+export type { ErrorCode } from '../formatters/json.js';
 export type { DailyOutput, SearchOutput, StartupOutput, StatusOutput, TrackOutput } from '../formatters/json.js';
 export type { VetOutput, CommentsOutput, PostOutput, ClaimOutput } from '../formatters/json.js';
 export type { ConfigOutput, DetectFormattersOutput, ParseIssueListOutput, ParsedIssueItem, CheckIntegrationOutput, LocalReposOutput, } from '../formatters/json.js';

package/dist/commands/setup.d.ts

@@ -24,7 +24,6 @@ export interface SetupCompleteOutput {
         projectCategories: ProjectCategory[];
         preferredOrgs: string[];
         scope: IssueScope[];
-        scoreThreshold: number;
     };
 }
 export interface SetupPrompt {

package/dist/commands/setup.js

@@ -14,14 +14,6 @@ function parsePositiveInt(value, settingName) {
     }
     return parsed;
 }
-/** Parse and validate an integer within a specific range [min, max]. */
-function parseBoundedInt(value, settingName, min, max) {
-    const parsed = Number(value);
-    if (!Number.isInteger(parsed) || parsed < min || parsed > max) {
-        throw new ValidationError(`Invalid value for ${settingName}: "${value}". Must be an integer between ${min} and ${max}.`);
-    }
-    return parsed;
-}
 /**
  * Interactive setup wizard or direct setting application.
  *
@@ -78,10 +70,6 @@ export async function runSetup(options) {
                         stateManager.updateConfig({ labels: value.split(',').map((l) => l.trim()) });
                         results[key] = value;
                         break;
-                    case 'showHealthCheck':
-                        stateManager.updateConfig({ showHealthCheck: value !== 'false' });
-                        results[key] = value !== 'false' ? 'true' : 'false';
-                        break;
                     case 'squashByDefault':
                         if (value === 'ask') {
                             stateManager.updateConfig({ squashByDefault: 'ask' });
@@ -92,12 +80,6 @@ export async function runSetup(options) {
                             results[key] = value !== 'false' ? 'true' : 'false';
                         }
                         break;
-                    case 'scoreThreshold': {
-                        const threshold = parseBoundedInt(value, 'scoreThreshold', 1, 10);
-                        stateManager.updateConfig({ scoreThreshold: threshold });
-                        results[key] = String(threshold);
-                        break;
-                    }
                     case 'minStars': {
                         const stars = Number(value);
                         if (!Number.isInteger(stars) || stars < 0) {
@@ -239,7 +221,6 @@ export async function runSetup(options) {
                 projectCategories: config.projectCategories ?? [],
                 preferredOrgs: config.preferredOrgs ?? [],
                 scope: config.scope ?? [],
-                scoreThreshold: config.scoreThreshold,
             },
         };
     }
@@ -296,13 +277,6 @@ export async function runSetup(options) {
                 default: [],
                 type: 'list',
             },
-            {
-                setting: 'scoreThreshold',
-                prompt: 'Minimum vet score (1-10) for issues to keep after vetting? Issues below this are auto-filtered.',
-                current: config.scoreThreshold,
-                default: 6,
-                type: 'number',
-            },
             {
                 setting: 'aiPolicyBlocklist',
                 prompt: 'Repos with anti-AI contribution policies to block (owner/repo, comma-separated)?',

package/dist/commands/startup.js

@@ -7,6 +7,7 @@
  * `node cli.bundle.cjs startup --json` call, reducing UI noise in Claude Code.
  */
 import * as fs from 'fs';
+import * as path from 'path';
 import { execFile } from 'child_process';
 import { getStateManager, getGitHubToken, getCLIVersion, detectGitHubUsername } from '../core/index.js';
 import { errorMessage } from '../core/errors.js';
@@ -102,15 +103,36 @@ export function detectIssueList() {
     if (!issueListPath)
         return undefined;
     // 4. Count available/completed items
+    let availableCount = 0;
+    let completedCount = 0;
     try {
         const content = fs.readFileSync(issueListPath, 'utf-8');
-        const { availableCount, completedCount } = countIssueListItems(content);
-        return { path: issueListPath, source, availableCount, completedCount };
+        ({ availableCount, completedCount } = countIssueListItems(content));
     }
     catch (error) {
         console.error(`[STARTUP] Failed to read issue list at ${issueListPath}:`, errorMessage(error));
-        return { path: issueListPath, source, availableCount: 0, completedCount: 0 };
     }
+    // 5. Detect skipped issues file
+    let skippedIssuesPath;
+    // Check config first
+    try {
+        const stateManager = getStateManager();
+        const configuredSkipPath = stateManager.getState().config.skippedIssuesPath;
+        if (configuredSkipPath && fs.existsSync(configuredSkipPath)) {
+            skippedIssuesPath = configuredSkipPath;
+        }
+    }
+    catch {
+        /* fall through */
+    }
+    // Probe default path: same directory as issue list, named skipped-issues.md
+    if (!skippedIssuesPath && issueListPath) {
+        const defaultSkipPath = path.join(path.dirname(issueListPath), 'skipped-issues.md');
+        if (fs.existsSync(defaultSkipPath)) {
+            skippedIssuesPath = defaultSkipPath;
+        }
+    }
+    return { path: issueListPath, source, availableCount, completedCount, skippedIssuesPath };
 }
 /**
  * Open a URL in the default system browser.

package/dist/core/errors.d.ts

@@ -39,3 +39,9 @@ export declare function getHttpStatusCode(error: unknown): number | undefined;
 export declare function isRateLimitError(error: unknown): boolean;
 /** Return true for errors that should propagate (not degrade gracefully): rate limits, auth failures, abuse detection. */
 export declare function isRateLimitOrAuthError(err: unknown): boolean;
+/**
+ * Map an unknown error to a structured ErrorCode for JSON output.
+ * Checks custom error classes, HTTP status codes (Octokit errors),
+ * and error message patterns in priority order.
+ */
+export declare function resolveErrorCode(err: unknown): import('../formatters/json.js').ErrorCode;

package/dist/core/errors.js

@@ -75,3 +75,40 @@ export function isRateLimitOrAuthError(err) {
     }
     return false;
 }
+/**
+ * Map an unknown error to a structured ErrorCode for JSON output.
+ * Checks custom error classes, HTTP status codes (Octokit errors),
+ * and error message patterns in priority order.
+ */
+export function resolveErrorCode(err) {
+    // Check our custom error classes first
+    if (err instanceof ConfigurationError)
+        return 'CONFIGURATION';
+    if (err instanceof ValidationError)
+        return 'VALIDATION';
+    // Check HTTP status codes (Octokit errors)
+    const status = getHttpStatusCode(err);
+    if (status === 401)
+        return 'AUTH_REQUIRED';
+    if (status === 403) {
+        const msg = errorMessage(err).toLowerCase();
+        if (msg.includes('rate limit') || msg.includes('abuse detection'))
+            return 'RATE_LIMITED';
+        return 'AUTH_REQUIRED';
+    }
+    if (status === 404)
+        return 'NOT_FOUND';
+    if (status === 429)
+        return 'RATE_LIMITED';
+    // Check error message patterns
+    const msg = errorMessage(err).toLowerCase();
+    if (msg.includes('enotfound') ||
+        msg.includes('econnrefused') ||
+        msg.includes('econnreset') ||
+        msg.includes('etimedout') ||
+        msg.includes('fetch failed'))
+        return 'NETWORK';
+    if (msg.includes('state') && (msg.includes('corrupt') || msg.includes('invalid')))
+        return 'STATE_CORRUPTED';
+    return 'UNKNOWN';
+}

package/dist/core/gist-state-store.d.ts

@@ -0,0 +1,169 @@
+/**
+ * Gist-based persistence layer for oss-autopilot state.
+ *
+ * Manages a single private GitHub Gist that stores `state.json` (structured state)
+ * and potentially freeform markdown documents. Provides an in-memory file cache
+ * for session-scoped reads and a local cache write-through for degraded-mode fallback.
+ *
+ * Bootstrap flow:
+ *  1. Check for locally stored Gist ID file (`~/.oss-autopilot/gist-id`)
+ *  2. If found, fetch that Gist directly via `GET /gists/:id`
+ *  3. If not found locally, search the user's Gists for description `oss-autopilot-state`
+ *  4. If found via search, store the ID locally and fetch it
+ *  5. If not found anywhere, create a new private Gist with seed files and store the ID
+ *  6. Cache all Gist file contents in memory for session-scoped reads
+ *  7. Write state to a local cache file for fallback
+ */
+import { AgentState } from './types.js';
+/** Well-known Gist description used for search-based discovery. */
+export declare const GIST_DESCRIPTION = "oss-autopilot-state";
+/** Primary state file name inside the Gist. */
+export declare const STATE_FILE_NAME = "state.json";
+/** Result of a successful bootstrap. */
+export interface BootstrapResult {
+    gistId: string;
+    state: AgentState;
+    created: boolean;
+    /** True when state was loaded from local cache due to API failure. */
+    degraded?: boolean;
+}
+/**
+ * Minimal Octokit-shaped interface for the Gist API methods we use.
+ * Accepts the real ThrottledOctokit or a plain mock object in tests.
+ */
+export interface OctokitLike {
+    gists: {
+        get: (params: {
+            gist_id: string;
+        }) => Promise<{
+            data: GistResponseData;
+        }>;
+        list: (params: {
+            per_page: number;
+            page: number;
+        }) => Promise<{
+            data: GistListItem[];
+        }>;
+        create: (params: {
+            description: string;
+            public: boolean;
+            files: Record<string, {
+                content: string;
+            }>;
+        }) => Promise<{
+            data: GistResponseData;
+        }>;
+        update: (params: {
+            gist_id: string;
+            files: Record<string, {
+                content: string;
+            }>;
+        }) => Promise<{
+            data: GistResponseData;
+        }>;
+    };
+}
+/** Shape of a single Gist in a list response (subset). */
+interface GistListItem {
+    id: string;
+    description: string | null;
+}
+/** Shape of a full Gist response (subset). */
+interface GistResponseData {
+    id: string;
+    description: string | null;
+    files: Record<string, {
+        filename: string;
+        content?: string;
+    } | null>;
+}
+/**
+ * Gist-backed state store with in-memory file cache and local write-through.
+ */
+export declare class GistStateStore {
+    private gistId;
+    readonly cachedFiles: Map<string, string>;
+    readonly dirtyFiles: Set<string>;
+    private readonly octokit;
+    constructor(octokit: OctokitLike);
+    /**
+     * Bootstrap the Gist store: locate or create the backing Gist,
+     * populate the in-memory cache, and write the local cache file.
+     */
+    bootstrap(): Promise<BootstrapResult>;
+    /**
+     * Bootstrap with migration from an existing local state.
+     * If a Gist already exists (found via local ID or search), uses it — no migration needed.
+     * If no Gist exists, creates one seeded with the provided existingState instead of a fresh state.
+     * @returns BootstrapResult extended with `migrated: true` if a new Gist was created from local state
+     */
+    bootstrapWithMigration(existingState: AgentState): Promise<BootstrapResult & {
+        migrated: boolean;
+    }>;
+    /** Return the resolved Gist ID (available after bootstrap). */
+    getGistId(): string | null;
+    /**
+     * Mark a file as dirty so it will be included in the next `push()` call.
+     */
+    markDirty(filename: string): void;
+    /**
+     * Read a freeform document from the in-memory cache.
+     * Returns null if the file has not been loaded (or does not exist in the Gist).
+     * Synchronous — all Gist contents are loaded into memory at bootstrap.
+     */
+    getDocument(filename: string): string | null;
+    /**
+     * Write a freeform document into the in-memory cache and mark it dirty
+     * so it will be included in the next `push()` call.
+     */
+    setDocument(filename: string, content: string): void;
+    /**
+     * Return all filenames in the in-memory cache whose names start with `prefix`.
+     * Useful for listing all guidelines files (e.g. prefix `guidelines--`).
+     */
+    listDocuments(prefix: string): string[];
+    /**
+     * Stage new state JSON for the next `push()`. Updates the in-memory cache
+     * for `state.json` and marks it dirty.
+     */
+    setState(stateJson: string): void;
+    /**
+     * Push all dirty files to the backing Gist. Retries once on failure.
+     *
+     * Returns `true` on success (or when there is nothing to push).
+     * Returns `false` if both attempts fail.
+     * Throws if the Gist ID has not been resolved yet (bootstrap not called).
+     */
+    push(): Promise<boolean>;
+    /**
+     * Fetch a Gist by ID, populate the in-memory cache, parse state,
+     * and write the local cache file.
+     */
+    private fetchAndCache;
+    /**
+     * Parse `state.json` from the in-memory cache. Handles v2 migration
+     * by running through the Zod schema (which requires version: 3).
+     * Falls back to fresh state if the file is missing or unparseable.
+     */
+    private parseStateFromCache;
+    /**
+     * Search the authenticated user's Gists for one with the well-known description.
+     * Pages through up to 10 pages (100 Gists per page) to find it.
+     */
+    private searchForGist;
+    /**
+     * Create a new private Gist with seed files and store it in memory.
+     */
+    private createGist;
+    /**
+     * Create a new private Gist seeded with the provided state (for migration).
+     */
+    private createGistFromState;
+    /** Read the locally persisted Gist ID, or return null if not found. */
+    private readLocalGistId;
+    /** Persist the Gist ID locally for fast lookup on next session. */
+    private writeLocalGistId;
+    /** Write state to the local cache file for degraded-mode fallback. */
+    private writeLocalStateCache;
+}
+export {};