mdcontext 0.0.1 → 0.2.0

package/src/cli/commands/context.ts

@@ -0,0 +1,285 @@
+/**
+ * CONTEXT Command
+ *
+ * Get LLM-ready summary of markdown files.
+ */
+
+import * as path from 'node:path'
+import { Args, Command, Options } from '@effect/cli'
+import { Console, Effect } from 'effect'
+import {
+  CliValidationError,
+  FileReadError,
+  ParseError,
+} from '../../errors/index.js'
+import { parseFile } from '../../parser/parser.js'
+import {
+  buildSectionList,
+  extractSectionContent,
+  filterExcludedSections,
+  formatExtractedSections,
+  formatSectionList,
+} from '../../parser/section-filter.js'
+import {
+  assembleContext,
+  formatAssembledContext,
+  formatSummary,
+  summarizeFile,
+} from '../../summarize/summarizer.js'
+import { jsonOption, prettyOption } from '../options.js'
+import { formatJson } from '../utils.js'
+
+export const contextCommand = Command.make(
+  'context',
+  {
+    files: Args.file({ name: 'files' }).pipe(
+      Args.withDescription('Markdown file(s) to summarize'),
+      Args.repeated,
+    ),
+    tokens: Options.integer('tokens').pipe(
+      Options.withAlias('t'),
+      Options.withDescription('Token budget'),
+      Options.withDefault(2000),
+    ),
+    brief: Options.boolean('brief').pipe(
+      Options.withDescription('Minimal output'),
+      Options.withDefault(false),
+    ),
+    full: Options.boolean('full').pipe(
+      Options.withDescription('Include full content'),
+      Options.withDefault(false),
+    ),
+    section: Options.text('section').pipe(
+      Options.withAlias('S'),
+      Options.withDescription(
+        'Filter by section name, number (e.g., "5.3"), or glob pattern (e.g., "Memory*")',
+      ),
+      Options.optional,
+    ),
+    sections: Options.boolean('sections').pipe(
+      Options.withDescription('List available sections'),
+      Options.withDefault(false),
+    ),
+    shallow: Options.boolean('shallow').pipe(
+      Options.withDescription('Exclude nested subsections when filtering'),
+      Options.withDefault(false),
+    ),
+    exclude: Options.text('exclude').pipe(
+      Options.withAlias('x'),
+      Options.withDescription(
+        'Exclude sections matching pattern (can be used multiple times)',
+      ),
+      Options.repeated,
+    ),
+    json: jsonOption,
+    pretty: prettyOption,
+  },
+  ({
+    files,
+    tokens,
+    brief,
+    full,
+    section,
+    sections,
+    shallow,
+    exclude,
+    json,
+    pretty,
+  }) =>
+    Effect.gen(function* () {
+      // Effect CLI Args.repeated returns an array
+      const fileList: string[] = Array.isArray(files) ? files : []
+
+      if (fileList.length === 0) {
+        yield* Effect.fail(
+          new CliValidationError({
+            message:
+              'At least one file is required. Usage: mdcontext context <file> [files...]',
+            argument: 'files',
+          }),
+        )
+      }
+
+      // Get section option value (it's an Option type)
+      const sectionSelector =
+        section._tag === 'Some' ? section.value : undefined
+
+      // Extract exclusion patterns (repeated option returns array)
+      const excludePatterns: string[] = Array.isArray(exclude) ? exclude : []
+
+      // Handle --sections flag: list available sections
+      if (sections) {
+        for (const file of fileList) {
+          const filePath = path.resolve(file)
+          const document = yield* parseFile(filePath).pipe(
+            Effect.mapError((e) =>
+              e._tag === 'ParseError'
+                ? new ParseError({
+                    message: e.message,
+                    path: filePath,
+                    ...(e.line !== undefined && { line: e.line }),
+                    ...(e.column !== undefined && { column: e.column }),
+                  })
+                : new FileReadError({
+                    path: e.path,
+                    message: e.message,
+                  }),
+            ),
+          )
+
+          let sectionList = buildSectionList(document)
+
+          // Apply exclusion filter if patterns provided
+          if (excludePatterns.length > 0) {
+            sectionList = filterExcludedSections(sectionList, excludePatterns)
+          }
+
+          if (json) {
+            const output = {
+              path: filePath,
+              title: document.title,
+              ...(excludePatterns.length > 0 && {
+                excludePatterns,
+              }),
+              sections: sectionList.map((s) => ({
+                number: s.number,
+                heading: s.heading,
+                level: s.level,
+                tokens: s.tokenCount,
+              })),
+            }
+            yield* Console.log(formatJson(output, pretty))
+          } else {
+            yield* Console.log(`# ${document.title}`)
+            yield* Console.log(`Path: ${filePath}`)
+            if (excludePatterns.length > 0) {
+              yield* Console.log(
+                `Excluded: ${excludePatterns.map((p) => `"${p}"`).join(', ')}`,
+              )
+            }
+            yield* Console.log('')
+            yield* Console.log('Available sections:')
+            yield* Console.log(formatSectionList(sectionList))
+          }
+        }
+        return
+      }
+
+      // Handle --section flag: extract specific section(s)
+      if (sectionSelector) {
+        for (const file of fileList) {
+          const filePath = path.resolve(file)
+          const document = yield* parseFile(filePath).pipe(
+            Effect.mapError((e) =>
+              e._tag === 'ParseError'
+                ? new ParseError({
+                    message: e.message,
+                    path: filePath,
+                    ...(e.line !== undefined && { line: e.line }),
+                    ...(e.column !== undefined && { column: e.column }),
+                  })
+                : new FileReadError({
+                    path: e.path,
+                    message: e.message,
+                  }),
+            ),
+          )
+
+          const {
+            sections: extractedSections,
+            matchedNumbers,
+            excludedNumbers,
+          } = extractSectionContent(document, sectionSelector, {
+            shallow,
+            exclude: excludePatterns,
+          })
+
+          if (extractedSections.length === 0) {
+            yield* Console.error(
+              `No sections found matching "${sectionSelector}" in ${file}`,
+            )
+            if (excludedNumbers.length > 0) {
+              yield* Console.error(
+                `(${excludedNumbers.length} section(s) were excluded by --exclude patterns)`,
+              )
+            }
+            yield* Console.error('Use --sections to list available sections.')
+            continue
+          }
+
+          if (json) {
+            const output = {
+              path: filePath,
+              title: document.title,
+              selector: sectionSelector,
+              shallow,
+              ...(excludePatterns.length > 0 && { excludePatterns }),
+              matchedSections: matchedNumbers,
+              ...(excludedNumbers.length > 0 && {
+                excludedSections: excludedNumbers,
+              }),
+              content: formatExtractedSections(extractedSections),
+              sections: extractedSections.map((s) => ({
+                heading: s.heading,
+                level: s.level,
+                tokens: s.metadata.tokenCount,
+              })),
+            }
+            yield* Console.log(formatJson(output, pretty))
+          } else {
+            yield* Console.log(`# ${document.title}`)
+            yield* Console.log(`Path: ${filePath}`)
+            yield* Console.log(`Sections: ${matchedNumbers.join(', ')}`)
+            if (excludedNumbers.length > 0) {
+              yield* Console.log(
+                `Excluded: ${excludedNumbers.join(', ')} (by --exclude patterns)`,
+              )
+            }
+            yield* Console.log('')
+            yield* Console.log(formatExtractedSections(extractedSections))
+          }
+        }
+        return
+      }
+
+      // Determine level
+      const level = full ? 'full' : brief ? 'brief' : 'summary'
+
+      // When --full is specified, disable token truncation
+      const effectiveMaxTokens = full ? undefined : tokens
+
+      const firstFile = fileList[0]
+      if (fileList.length === 1 && firstFile) {
+        // Single file: use summarizeFile
+        const filePath = path.resolve(firstFile)
+        const summary = yield* summarizeFile(filePath, {
+          level: level as 'brief' | 'summary' | 'full',
+          maxTokens: effectiveMaxTokens,
+          exclude: excludePatterns.length > 0 ? excludePatterns : undefined,
+        })
+
+        if (json) {
+          yield* Console.log(formatJson(summary, pretty))
+        } else {
+          yield* Console.log(
+            formatSummary(summary, { maxTokens: effectiveMaxTokens }),
+          )
+        }
+      } else {
+        // Multiple files: use assembleContext
+        // Note: assembleContext always requires a budget; use large number for --full
+        const root = process.cwd()
+        const assembled = yield* assembleContext(root, fileList, {
+          budget: full ? Number.MAX_SAFE_INTEGER : tokens,
+          level: level as 'brief' | 'summary' | 'full',
+          exclude: excludePatterns.length > 0 ? excludePatterns : undefined,
+        })
+
+        if (json) {
+          yield* Console.log(formatJson(assembled, pretty))
+        } else {
+          yield* Console.log(formatAssembledContext(assembled))
+        }
+      }
+    }),
+).pipe(Command.withDescription('Get LLM-ready summary'))

package/src/cli/commands/duplicates.ts

@@ -0,0 +1,122 @@
+/**
+ * DUPLICATES Command
+ *
+ * Detect and display duplicate content in markdown files.
+ */
+
+import * as path from 'node:path'
+import { Args, Command, Options } from '@effect/cli'
+import { Console, Effect, Option } from 'effect'
+import { detectDuplicates } from '../../duplicates/index.js'
+import { jsonOption, prettyOption } from '../options.js'
+import { formatJson, getIndexInfo } from '../utils.js'
+
+export const duplicatesCommand = Command.make(
+  'duplicates',
+  {
+    path: Args.directory({ name: 'path' }).pipe(
+      Args.withDescription('Directory to search for duplicates'),
+      Args.withDefault('.'),
+    ),
+    minLength: Options.integer('min-length').pipe(
+      Options.withDescription(
+        'Minimum content length (characters) to consider for duplicate detection',
+      ),
+      Options.withDefault(50),
+    ),
+    pathPattern: Options.text('path').pipe(
+      Options.withAlias('p'),
+      Options.withDescription('Filter by document path pattern (glob)'),
+      Options.optional,
+    ),
+    json: jsonOption,
+    pretty: prettyOption,
+  },
+  ({ path: dirPath, minLength, pathPattern, json, pretty }) =>
+    Effect.gen(function* () {
+      const resolvedDir = path.resolve(dirPath)
+
+      // Check for index
+      const indexInfo = yield* Effect.promise(() => getIndexInfo(resolvedDir))
+
+      if (!indexInfo.exists && !json) {
+        yield* Console.log('No index found.')
+        yield* Console.log('')
+        yield* Console.log('Run: mdcontext index /path/to/docs')
+        return
+      }
+
+      // Determine the actual index root
+      const indexRoot = indexInfo.indexRoot ?? resolvedDir
+
+      // Run duplicate detection
+      const result = yield* detectDuplicates(indexRoot, {
+        minContentLength: minLength,
+        pathPattern: Option.getOrUndefined(pathPattern),
+      })
+
+      if (json) {
+        const output = {
+          sectionsAnalyzed: result.sectionsAnalyzed,
+          duplicatePairs: result.duplicatePairs,
+          sectionsWithDuplicates: result.sectionsWithDuplicates,
+          groupCount: result.groups.length,
+          groups: result.groups.map((g) => ({
+            primary: {
+              path: g.primary.documentPath,
+              heading: g.primary.heading,
+              line: g.primary.startLine,
+            },
+            duplicates: g.duplicates.map((d) => ({
+              path: d.documentPath,
+              heading: d.heading,
+              line: d.startLine,
+            })),
+            method: g.method,
+            similarity: g.similarity,
+          })),
+        }
+        yield* Console.log(formatJson(output, pretty))
+      } else {
+        yield* Console.log('Duplicate Content Analysis')
+        yield* Console.log('')
+        yield* Console.log(`  Sections analyzed: ${result.sectionsAnalyzed}`)
+        yield* Console.log(`  Duplicate groups:  ${result.groups.length}`)
+        yield* Console.log(`  Duplicate pairs:   ${result.duplicatePairs}`)
+        yield* Console.log(
+          `  Sections involved: ${result.sectionsWithDuplicates}`,
+        )
+        yield* Console.log('')
+
+        if (result.groups.length === 0) {
+          yield* Console.log('No duplicates found.')
+        } else {
+          yield* Console.log('Duplicate Groups:')
+          yield* Console.log('')
+
+          for (let i = 0; i < result.groups.length; i++) {
+            const group = result.groups[i]!
+            const methodBadge =
+              group.method === 'exact'
+                ? '[exact]'
+                : `[~${Math.round(group.similarity * 100)}%]`
+
+            yield* Console.log(`  Group ${i + 1} ${methodBadge}`)
+            yield* Console.log(
+              `    ${group.primary.documentPath}:${group.primary.startLine}`,
+            )
+            yield* Console.log(`      ${group.primary.heading}`)
+
+            for (const dup of group.duplicates) {
+              yield* Console.log('')
+              yield* Console.log(
+                `    Also in: ${dup.documentPath}:${dup.startLine}`,
+              )
+              yield* Console.log(`      ${dup.heading}`)
+            }
+            yield* Console.log('')
+          }
+        }
+      }
+    }),
+).pipe(Command.withDescription('Detect duplicate content in markdown files'))