mdcontext 0.1.0 → 0.2.0

package/src/cli/commands/context.ts

@@ -7,10 +7,16 @@
 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'
@@ -58,19 +64,39 @@ export const contextCommand = Command.make(
       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, json, pretty }) =>
+  ({
+    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 Error(
-            'At least one file is required. Usage: mdcontext context <file> [files...]',
-          ),
+          new CliValidationError({
+            message:
+              'At least one file is required. Usage: mdcontext context <file> [files...]',
+            argument: 'files',
+          }),
         )
       }
 
@@ -78,20 +104,43 @@ export const contextCommand = Command.make(
       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) => new Error(`${e._tag}: ${e.message}`)),
+            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 sectionList = buildSectionList(document)
+          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,
@@ -103,6 +152,11 @@ export const contextCommand = Command.make(
           } 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))
@@ -116,16 +170,39 @@ export const contextCommand = Command.make(
         for (const file of fileList) {
           const filePath = path.resolve(file)
           const document = yield* parseFile(filePath).pipe(
-            Effect.mapError((e) => new Error(`${e._tag}: ${e.message}`)),
+            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 } =
-            extractSectionContent(document, sectionSelector, { shallow })
+          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
           }
@@ -136,7 +213,11 @@ export const contextCommand = Command.make(
               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,
@@ -149,6 +230,11 @@ export const contextCommand = Command.make(
             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))
           }
@@ -169,6 +255,7 @@ export const contextCommand = Command.make(
         const summary = yield* summarizeFile(filePath, {
           level: level as 'brief' | 'summary' | 'full',
           maxTokens: effectiveMaxTokens,
+          exclude: excludePatterns.length > 0 ? excludePatterns : undefined,
         })
 
         if (json) {
@@ -185,6 +272,7 @@ export const contextCommand = Command.make(
         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) {

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'))