fix: support --from <date> when ejecting

Author: harlan-zw

CLAUDE.md

@@ -35,9 +35,10 @@ skilld search "query" # Search indexed docs
 skilld search "query" -p nuxt  # Search filtered by package
 skilld cache             # Clean expired LLM cache entries
 skilld add owner/repo    # Add pre-authored skills from git repo
-skilld eject vue              # Eject skill (portable, no symlinks)
-skilld eject vue --name vue   # Eject with custom skill dir name
-skilld eject vue --out ./dir/ # Eject to custom path
+skilld eject vue                    # Eject skill (portable, no symlinks)
+skilld eject vue --name vue         # Eject with custom skill dir name
+skilld eject vue --out ./dir/       # Eject to custom path
+skilld eject vue --from 2025-07-01  # Only releases/issues since date
 ```
 
 ## Architecture

README.md

@@ -173,6 +173,9 @@ skilld eject vue --name vue
 
 # Eject to a custom path
 skilld eject vue --out ./skills/vue/
+
+# Only collect releases/issues/discussions since a date
+skilld eject vue --from 2025-07-01
 ```
 
 The ejected skill contains `SKILL.md` plus a `references/` directory with docs, issues, and releases as real files. Share it via `skilld add owner/repo` — consumers get fully functional skills with no LLM cost.
@@ -188,6 +191,7 @@ The ejected skill contains `SKILL.md` plus a `references/` directory with docs,
 | `--model`      | `-m` | config default | LLM model for skill generation (sonnet, haiku, opus, etc.) |
 | `--name`       | `-n` |                | Custom skill directory name (eject only) |
 | `--out`        | `-o` |                | Output directory path override (eject only) |
+| `--from`       |      |                | Collect releases/issues/discussions from this date (YYYY-MM-DD, eject only) |
 | `--debug`      |      | `false`        | Save raw LLM output to logs/ for each section |
 
 ## The Landscape

src/commands/sync-shared.ts

@@ -273,6 +273,8 @@ export async function fetchAndCacheResources(opts: {
   version: string
   useCache: boolean
   features?: FeaturesConfig
+  /** Lower-bound date for release/issue/discussion collection (ISO date) */
+  from?: string
   onProgress: (message: string) => void
 }): Promise<FetchResult> {
   const { packageName, resolved, version, useCache, onProgress } = opts
@@ -441,7 +443,7 @@ export async function fetchAndCacheResources(opts: {
     const gh = parseGitHubUrl(resolved.repoUrl)
     if (gh) {
       onProgress('Fetching issues via GitHub API')
-      const issues = await fetchGitHubIssues(gh.owner, gh.repo, 30, resolved.releasedAt).catch(() => [])
+      const issues = await fetchGitHubIssues(gh.owner, gh.repo, 30, resolved.releasedAt, opts.from).catch(() => [])
       if (issues.length > 0) {
         onProgress(`Caching ${issues.length} issues`)
         writeToCache(packageName, version, issues.map(issue => ({
@@ -469,7 +471,7 @@ export async function fetchAndCacheResources(opts: {
     const gh = parseGitHubUrl(resolved.repoUrl)
     if (gh) {
       onProgress('Fetching discussions via GitHub API')
-      const discussions = await fetchGitHubDiscussions(gh.owner, gh.repo, 20, resolved.releasedAt).catch(() => [])
+      const discussions = await fetchGitHubDiscussions(gh.owner, gh.repo, 20, resolved.releasedAt, opts.from).catch(() => [])
       if (discussions.length > 0) {
         onProgress(`Caching ${discussions.length} discussions`)
         writeToCache(packageName, version, discussions.map(d => ({
@@ -497,7 +499,7 @@ export async function fetchAndCacheResources(opts: {
     const gh = parseGitHubUrl(resolved.repoUrl)
     if (gh) {
       onProgress('Fetching releases via GitHub API')
-      const releaseDocs = await fetchReleaseNotes(gh.owner, gh.repo, version, resolved.gitRef, packageName).catch(() => [])
+      const releaseDocs = await fetchReleaseNotes(gh.owner, gh.repo, version, resolved.gitRef, packageName, opts.from).catch(() => [])
 
       // Fetch blog releases into same releases/ dir
       let blogDocs: Array<{ path: string, content: string }> = []

src/commands/sync.ts

@@ -3,7 +3,7 @@ import type { FeaturesConfig } from '../core/config.ts'
 import type { ProjectState } from '../core/skills.ts'
 import type { GitSkillSource } from '../sources/git-skills.ts'
 import type { ResolveAttempt } from '../sources/index.ts'
-import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { appendFileSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
 import * as p from '@clack/prompts'
 import { defineCommand } from 'citty'
 import { join, relative, resolve } from 'pathe'
@@ -214,6 +214,8 @@ export interface SyncOptions {
   eject?: boolean | string
   /** Override the computed skill directory name */
   name?: string
+  /** Lower-bound date for release/issue/discussion collection (ISO date, e.g. "2025-07-01") */
+  from?: string
 }
 
 export async function syncCommand(state: ProjectState, opts: SyncOptions): Promise<void> {
@@ -502,6 +504,7 @@ interface SyncConfig {
   mode?: 'add' | 'update'
   eject?: boolean | string
   name?: string
+  from?: string
 }
 
 async function syncSinglePackage(packageName: string, config: SyncConfig): Promise<void> {
@@ -664,6 +667,7 @@ async function syncSinglePackage(packageName: string, config: SyncConfig): Promi
     version,
     useCache,
     features,
+    from: config.from,
     onProgress: msg => resSpin.message(msg),
   })
   const resParts: string[] = []
@@ -682,13 +686,8 @@ async function syncSinglePackage(packageName: string, config: SyncConfig): Promi
   for (const w of resources.warnings)
     p.log.warn(`\x1B[33m${w}\x1B[0m`)
 
-  // Create symlinks or copy files (eject mode)
-  if (config.eject) {
-    ejectReferences(skillDir, packageName, cwd, version, resources.docsType, features)
-  }
-  else {
-    linkAllReferences(skillDir, packageName, cwd, version, resources.docsType, undefined, features)
-  }
+  // Create symlinks (LLM needs .skilld/ to read docs, even in eject mode)
+  linkAllReferences(skillDir, packageName, cwd, version, resources.docsType, undefined, features)
 
   // ── Phase 2: Search index (skip in eject mode — not portable) ──
   if (features.search && !config.eject) {
@@ -792,6 +791,14 @@ async function syncSinglePackage(packageName: string, config: SyncConfig): Promi
     }
   }
 
+  // Eject: clean up transient .skilld/ symlinks → copy as real files
+  if (isEject) {
+    const skilldDir = join(skillDir, '.skilld')
+    if (existsSync(skilldDir) && !config.debug)
+      rmSync(skilldDir, { recursive: true, force: true })
+    ejectReferences(skillDir, packageName, cwd, version, resources.docsType, features)
+  }
+
   // Skip agent integration in eject mode (no symlinks, no gitignore, no instructions)
   if (!isEject) {
     // Link shared dir to per-agent dirs
@@ -995,6 +1002,10 @@ export const ejectCommandDef = defineCommand({
       alias: 'o',
       description: 'Output directory path override',
     },
+    from: {
+      type: 'string',
+      description: 'Collect releases/issues/discussions from this date onward (YYYY-MM-DD)',
+    },
     ...sharedArgs,
   },
   async run({ args }) {
@@ -1021,6 +1032,7 @@ export const ejectCommandDef = defineCommand({
       debug: args.debug,
       eject: args.out || true,
       name: args.name,
+      from: args.from,
     })
   },
 })

src/sources/discussions.ts

@@ -107,14 +107,16 @@ export async function fetchGitHubDiscussions(
   repo: string,
   limit = 20,
   releasedAt?: string,
+  fromDate?: string,
 ): Promise<GitHubDiscussion[]> {
   if (!isGhAvailable())
     return []
 
   // GraphQL discussions endpoint doesn't support date filtering,
   // so we fetch latest N and filter client-side. Skip entirely
   // if the cutoff is in the past — results would be empty anyway.
-  if (releasedAt) {
+  // (Skip this check when fromDate is set — we'll filter client-side below)
+  if (!fromDate && releasedAt) {
     const cutoff = new Date(releasedAt)
     cutoff.setMonth(cutoff.getMonth() + 6)
     if (cutoff < new Date())
@@ -139,12 +141,14 @@ export async function fetchGitHubDiscussions(
     if (!Array.isArray(nodes))
       return []
 
+    const fromTs = fromDate ? new Date(fromDate).getTime() : null
     const discussions = nodes
       .filter((d: any) => d.author && !BOT_USERS.has(d.author.login))
       .filter((d: any) => {
         const cat = (d.category?.name || '').toLowerCase()
         return !LOW_VALUE_CATEGORIES.has(cat)
       })
+      .filter((d: any) => !fromTs || new Date(d.createdAt).getTime() >= fromTs)
       .map((d: any) => {
         // Process answer — tag maintainer status
         let answer: string | undefined

src/sources/issues.ts

@@ -289,10 +289,17 @@ function fetchIssuesByState(
   state: 'open' | 'closed',
   count: number,
   releasedAt?: string,
+  fromDate?: string,
 ): GitHubIssue[] {
   const fetchCount = Math.min(count * 3, 100)
   let datePart = ''
-  if (state === 'closed') {
+  if (fromDate) {
+    // Explicit lower bound: only issues from this date onward
+    datePart = state === 'closed'
+      ? `+closed:>=${fromDate}`
+      : `+created:>=${fromDate}`
+  }
+  else if (state === 'closed') {
     if (releasedAt) {
       // For older versions, include issues closed up to 6 months after release
       const date = new Date(releasedAt)
@@ -459,6 +466,7 @@ export async function fetchGitHubIssues(
   repo: string,
   limit = 30,
   releasedAt?: string,
+  fromDate?: string,
 ): Promise<GitHubIssue[]> {
   if (!isGhAvailable())
     return []
@@ -468,8 +476,8 @@ export async function fetchGitHubIssues(
 
   try {
     // Fetch more than needed so type quotas have a pool to draw from
-    const open = fetchIssuesByState(owner, repo, 'open', Math.min(openCount * 2, 100), releasedAt)
-    const closed = fetchIssuesByState(owner, repo, 'closed', Math.min(closedCount * 2, 50), releasedAt)
+    const open = fetchIssuesByState(owner, repo, 'open', Math.min(openCount * 2, 100), releasedAt, fromDate)
+    const closed = fetchIssuesByState(owner, repo, 'closed', Math.min(closedCount * 2, 50), releasedAt, fromDate)
     const all = [...open, ...closed]
     const selected = applyTypeQuotas(all, limit)
     enrichWithComments(owner, repo, selected)

src/sources/releases.ts

@@ -143,11 +143,12 @@ async function fetchAllReleases(owner: string, repo: string): Promise<GitHubRele
  * Falls back to generic tags (v1.2.3) only if no package-specific found.
  * If installedVersion is provided, filters out releases newer than it.
  */
-export function selectReleases(releases: GitHubRelease[], packageName?: string, installedVersion?: string): GitHubRelease[] {
+export function selectReleases(releases: GitHubRelease[], packageName?: string, installedVersion?: string, fromDate?: string): GitHubRelease[] {
   // Check if this looks like a monorepo (has package-prefixed tags)
   const hasMonorepoTags = packageName && releases.some(r => tagMatchesPackage(r.tag, packageName))
   const installedSv = installedVersion ? parseSemver(installedVersion) : null
   const installedIsPrerelease = installedVersion ? isPrerelease(installedVersion) : false
+  const fromTs = fromDate ? new Date(fromDate).getTime() : null
 
   const filtered = releases.filter((r) => {
     const ver = extractVersion(r.tag, hasMonorepoTags ? packageName : undefined)
@@ -162,6 +163,13 @@ export function selectReleases(releases: GitHubRelease[], packageName?: string,
     if (hasMonorepoTags && packageName && !tagMatchesPackage(r.tag, packageName))
       return false
 
+    // Date lower bound: skip releases published before fromDate
+    if (fromTs) {
+      const pubDate = r.publishedAt || r.createdAt
+      if (pubDate && new Date(pubDate).getTime() < fromTs)
+        return false
+    }
+
     // Prerelease handling: include only when installed is also prerelease and same major.minor
     if (r.prerelease) {
       if (!installedIsPrerelease || !installedSv)
@@ -176,15 +184,17 @@ export function selectReleases(releases: GitHubRelease[], packageName?: string,
     return true
   })
 
-  return filtered
+  const sorted = filtered
     .sort((a, b) => {
       const verA = extractVersion(a.tag, hasMonorepoTags ? packageName : undefined)
       const verB = extractVersion(b.tag, hasMonorepoTags ? packageName : undefined)
       if (!verA || !verB)
         return 0
       return compareSemver(parseSemver(verB)!, parseSemver(verA)!)
     })
-    .slice(0, 20)
+
+  // No cap when fromDate is set — include all matching releases
+  return fromDate ? sorted : sorted.slice(0, 20)
 }
 
 /**
@@ -311,9 +321,10 @@ export async function fetchReleaseNotes(
   installedVersion: string,
   gitRef?: string,
   packageName?: string,
+  fromDate?: string,
 ): Promise<CachedDoc[]> {
   const releases = await fetchAllReleases(owner, repo)
-  const selected = selectReleases(releases, packageName, installedVersion)
+  const selected = selectReleases(releases, packageName, installedVersion, fromDate)
 
   if (selected.length > 0) {
     // Detect changelog-redirect pattern: short stubs that just link to CHANGELOG.md