@dcode-dev/dcode-cli 1.0.0

package/internal/context/builder.go

@@ -0,0 +1,312 @@
+package context
+
+import (
+"fmt"
+"os"
+"path/filepath"
+"sort"
+"strings"
+"time"
+
+"github.com/ddhanush1/dcode/internal/detector"
+"github.com/ddhanush1/dcode/internal/fsutil"
+)
+
+// ProjectContext holds information about the current project
+type ProjectContext struct {
+RootDir       string
+ProjectType   *detector.ProjectType
+RelevantFiles []FileInfo
+Summary       string
+UpdatedAt     time.Time
+}
+
+// FileInfo contains metadata about a file
+type FileInfo struct {
+Path      string
+RelPath   string
+Size      int64
+ModTime   time.Time
+Language  string
+Relevance float64 // 0.0 to 1.0
+}
+
+// Builder builds project context
+type Builder struct {
+rootDir string
+}
+
+// NewBuilder creates a new context builder
+func NewBuilder(rootDir string) *Builder {
+return &Builder{rootDir: rootDir}
+}
+
+// Build analyzes the project and builds context
+func (b *Builder) Build() (*ProjectContext, error) {
+// Detect project type
+projectType, err := detector.Detect(b.rootDir)
+if err != nil {
+return nil, fmt.Errorf("failed to detect project: %w", err)
+}
+
+// Get relevant files
+files, err := b.getRelevantFiles(100) // Limit to 100 files
+if err != nil {
+return nil, fmt.Errorf("failed to scan files: %w", err)
+}
+
+// Score and sort files by relevance
+b.scoreFiles(files, projectType)
+sort.Slice(files, func(i, j int) bool {
+return files[i].Relevance > files[j].Relevance
+})
+
+// Generate summary
+summary := b.generateSummary(projectType, files)
+
+ctx := &ProjectContext{
+RootDir:       b.rootDir,
+ProjectType:   projectType,
+RelevantFiles: files,
+Summary:       summary,
+UpdatedAt:     time.Now(),
+}
+
+return ctx, nil
+}
+
+func (b *Builder) getRelevantFiles(maxFiles int) ([]FileInfo, error) {
+var files []FileInfo
+
+err := filepath.Walk(b.rootDir, func(path string, info os.FileInfo, err error) error {
+if err != nil {
+return nil // Skip errors
+}
+
+if info.IsDir() {
+// Skip common directories
+name := info.Name()
+if name == ".git" || name == "node_modules" || name == "vendor" ||
+name == "__pycache__" || name == "dist" || name == "build" {
+return filepath.SkipDir
+}
+return nil
+}
+
+// Check if file is relevant
+if detector.IsRelevantFile(path) {
+relPath, _ := filepath.Rel(b.rootDir, path)
+files = append(files, FileInfo{
+Path:      path,
+RelPath:   relPath,
+Size:      info.Size(),
+ModTime:   info.ModTime(),
+Language:  detectLanguage(path),
+Relevance: 0.5, // Default relevance
+})
+
+// Limit number of files
+if maxFiles > 0 && len(files) >= maxFiles {
+return filepath.SkipDir
+}
+}
+
+return nil
+})
+
+if err != nil && err != filepath.SkipDir {
+return nil, err
+}
+
+return files, nil
+}
+
+func (b *Builder) scoreFiles(files []FileInfo, projectType *detector.ProjectType) {
+for i := range files {
+score := 0.5 // Base score
+
+path := files[i].RelPath
+base := filepath.Base(path)
+
+// Entry points get highest priority
+for _, ep := range projectType.EntryPoints {
+if base == ep {
+score = 1.0
+break
+}
+}
+
+// Config files are important
+for _, cf := range projectType.ConfigFiles {
+if base == cf {
+score = 0.9
+break
+}
+}
+
+// Files in root directory are more relevant
+if !strings.Contains(path, string(filepath.Separator)) {
+score += 0.2
+}
+
+// Language-specific scoring
+if files[i].Language == projectType.Language {
+score += 0.1
+}
+
+// Common important files
+switch base {
+case "README.md", "README.txt", "README":
+score = 0.95
+case "Makefile", "Dockerfile", ".env":
+score = 0.85
+}
+
+// Boost test files slightly
+if strings.Contains(base, "_test") || strings.Contains(base, ".test.") {
+score += 0.05
+}
+
+// Penalize very large files
+if files[i].Size > 100*1024 { // > 100KB
+score -= 0.1
+}
+
+// Penalize generated files
+if strings.Contains(path, "generated") || strings.Contains(path, "gen") {
+score -= 0.2
+}
+
+// Ensure score is in valid range
+if score < 0 {
+score = 0
+}
+if score > 1 {
+score = 1
+}
+
+files[i].Relevance = score
+}
+}
+
+func (b *Builder) generateSummary(projectType *detector.ProjectType, files []FileInfo) string {
+var sb strings.Builder
+
+sb.WriteString("# Project Overview\n\n")
+
+// Project type info
+if projectType.Language != "" {
+sb.WriteString(fmt.Sprintf("**Language:** %s\n", projectType.Language))
+}
+if projectType.Framework != "" {
+sb.WriteString(fmt.Sprintf("**Framework:** %s\n", projectType.Framework))
+}
+if projectType.BuildSystem != "" {
+sb.WriteString(fmt.Sprintf("**Build System:** %s\n", projectType.BuildSystem))
+}
+sb.WriteString(fmt.Sprintf("**Total Files:** %d\n\n", len(files)))
+
+// Entry points
+if len(projectType.EntryPoints) > 0 {
+sb.WriteString("**Entry Points:**\n")
+for _, ep := range projectType.EntryPoints {
+sb.WriteString(fmt.Sprintf("- %s\n", ep))
+}
+sb.WriteString("\n")
+}
+
+// Top relevant files
+sb.WriteString("**Key Files (by relevance):**\n")
+count := 0
+for _, f := range files {
+if count >= 10 { // Show top 10
+break
+}
+sb.WriteString(fmt.Sprintf("- %s (%.1f%%)\n", f.RelPath, f.Relevance*100))
+count++
+}
+
+// File type breakdown
+langCount := make(map[string]int)
+for _, f := range files {
+if f.Language != "" {
+langCount[f.Language]++
+}
+}
+if len(langCount) > 0 {
+sb.WriteString("\n**File Types:**\n")
+for lang, count := range langCount {
+sb.WriteString(fmt.Sprintf("- %s: %d files\n", lang, count))
+}
+}
+
+return sb.String()
+}
+
+func detectLanguage(path string) string {
+ext := filepath.Ext(path)
+switch ext {
+case ".go":
+return "go"
+case ".py":
+return "python"
+case ".js":
+return "javascript"
+case ".ts":
+return "typescript"
+case ".tsx":
+return "tsx"
+case ".jsx":
+return "jsx"
+case ".java":
+return "java"
+case ".rs":
+return "rust"
+case ".c", ".h":
+return "c"
+case ".cpp", ".hpp":
+return "cpp"
+case ".rb":
+return "ruby"
+case ".php":
+return "php"
+case ".cs":
+return "csharp"
+case ".md":
+return "markdown"
+case ".json":
+return "json"
+case ".yaml", ".yml":
+return "yaml"
+case ".toml":
+return "toml"
+case ".sql":
+return "sql"
+default:
+return ""
+}
+}
+
+// GetTopFiles returns the top N most relevant files
+func (ctx *ProjectContext) GetTopFiles(n int) []FileInfo {
+if n > len(ctx.RelevantFiles) {
+n = len(ctx.RelevantFiles)
+}
+return ctx.RelevantFiles[:n]
+}
+
+// ReadTopFiles reads content of top N files
+func (ctx *ProjectContext) ReadTopFiles(n int) (map[string]string, error) {
+topFiles := ctx.GetTopFiles(n)
+contents := make(map[string]string)
+
+for _, f := range topFiles {
+content, err := fsutil.ReadFile(f.Path)
+if err != nil {
+continue // Skip files we can't read
+}
+contents[f.RelPath] = content
+}
+
+return contents, nil
+}

package/internal/detector/detector.go

@@ -0,0 +1,204 @@
+package detector
+
+import (
+"os"
+"path/filepath"
+"strings"
+)
+
+// ProjectType represents the detected project type
+type ProjectType struct {
+Language    string   // go, python, javascript, typescript, etc.
+Framework   string   // gin, django, react, nextjs, etc.
+BuildSystem string   // go.mod, package.json, requirements.txt, etc.
+EntryPoints []string // main files
+ConfigFiles []string // important config files
+}
+
+// Detect analyzes a directory and determines project type
+func Detect(dir string) (*ProjectType, error) {
+pt := &ProjectType{
+EntryPoints: make([]string, 0),
+ConfigFiles: make([]string, 0),
+}
+
+// Check for various project indicators
+files, err := os.ReadDir(dir)
+if err != nil {
+return nil, err
+}
+
+for _, file := range files {
+name := file.Name()
+
+// Skip hidden files/directories
+if strings.HasPrefix(name, ".") && name != ".env" {
+continue
+}
+
+switch name {
+// Go
+case "go.mod":
+pt.Language = "go"
+pt.BuildSystem = "go.mod"
+pt.ConfigFiles = append(pt.ConfigFiles, name)
+
+// Python
+case "requirements.txt", "pyproject.toml", "setup.py", "Pipfile":
+pt.Language = "python"
+pt.BuildSystem = name
+pt.ConfigFiles = append(pt.ConfigFiles, name)
+
+// Node.js
+case "package.json":
+pt.Language = "javascript"
+pt.BuildSystem = "npm"
+pt.ConfigFiles = append(pt.ConfigFiles, name)
+
+// Rust
+case "Cargo.toml":
+pt.Language = "rust"
+pt.BuildSystem = "cargo"
+pt.ConfigFiles = append(pt.ConfigFiles, name)
+
+// Java
+case "pom.xml":
+pt.Language = "java"
+pt.BuildSystem = "maven"
+pt.ConfigFiles = append(pt.ConfigFiles, name)
+case "build.gradle":
+pt.Language = "java"
+pt.BuildSystem = "gradle"
+pt.ConfigFiles = append(pt.ConfigFiles, name)
+
+// Common entry points
+case "main.go":
+pt.EntryPoints = append(pt.EntryPoints, name)
+case "main.py", "app.py", "manage.py":
+pt.EntryPoints = append(pt.EntryPoints, name)
+case "index.js", "index.ts", "app.js", "app.ts":
+pt.EntryPoints = append(pt.EntryPoints, name)
+
+// Config files
+case ".env", "Dockerfile", "docker-compose.yml", "Makefile":
+pt.ConfigFiles = append(pt.ConfigFiles, name)
+}
+}
+
+// Detect framework based on package.json, go.mod, etc.
+pt.Framework = detectFramework(dir, pt.Language)
+
+return pt, nil
+}
+
+func detectFramework(dir, lang string) string {
+switch lang {
+case "go":
+// Check go.mod for common frameworks
+if gomod, err := os.ReadFile(filepath.Join(dir, "go.mod")); err == nil {
+content := string(gomod)
+if strings.Contains(content, "github.com/gin-gonic/gin") {
+return "gin"
+}
+if strings.Contains(content, "github.com/labstack/echo") {
+return "echo"
+}
+if strings.Contains(content, "github.com/gofiber/fiber") {
+return "fiber"
+}
+if strings.Contains(content, "github.com/spf13/cobra") {
+return "cobra-cli"
+}
+}
+
+case "python":
+// Check requirements.txt
+if req, err := os.ReadFile(filepath.Join(dir, "requirements.txt")); err == nil {
+content := strings.ToLower(string(req))
+if strings.Contains(content, "django") {
+return "django"
+}
+if strings.Contains(content, "flask") {
+return "flask"
+}
+if strings.Contains(content, "fastapi") {
+return "fastapi"
+}
+}
+
+case "javascript":
+// Check package.json
+if pkg, err := os.ReadFile(filepath.Join(dir, "package.json")); err == nil {
+content := string(pkg)
+if strings.Contains(content, "\"react\"") {
+if strings.Contains(content, "\"next\"") {
+return "nextjs"
+}
+return "react"
+}
+if strings.Contains(content, "\"vue\"") {
+return "vue"
+}
+if strings.Contains(content, "\"express\"") {
+return "express"
+}
+if strings.Contains(content, "\"@nestjs") {
+return "nestjs"
+}
+}
+}
+
+return ""
+}
+
+// IsRelevantFile determines if a file is relevant for AI context
+func IsRelevantFile(path string) bool {
+// Skip common non-relevant patterns
+skipPatterns := []string{
+"node_modules/", "vendor/", ".git/", "__pycache__/",
+".cache/", "dist/", "build/", ".next/", "target/",
+}
+
+for _, pattern := range skipPatterns {
+if strings.Contains(path, pattern) {
+return false
+}
+}
+
+base := filepath.Base(path)
+// Skip binary/media/lock files
+skipSuffixes := []string{
+".min.js", ".map", ".png", ".jpg", ".jpeg", ".gif",
+".ico", ".woff", ".woff2", ".ttf", ".eot",
+".lock", "go.sum", "package-lock.json", "yarn.lock",
+}
+
+for _, suffix := range skipSuffixes {
+if strings.HasSuffix(base, suffix) {
+return false
+}
+}
+
+// Include common source code extensions
+ext := filepath.Ext(path)
+relevantExts := []string{
+".go", ".py", ".js", ".ts", ".tsx", ".jsx",
+".java", ".c", ".cpp", ".h", ".hpp",
+".rs", ".rb", ".php", ".cs",
+".sql", ".md", ".txt", ".yml", ".yaml",
+".json", ".toml", ".xml", ".html", ".css", ".scss",
+}
+
+for _, e := range relevantExts {
+if ext == e {
+return true
+}
+}
+
+// Include files without extensions (likely scripts or configs)
+if ext == "" && !strings.HasPrefix(base, ".") {
+return true
+}
+
+return false
+}

package/internal/diffutil/diffutil.go

@@ -0,0 +1,30 @@
+package diffutil
+
+import (
+	"strings"
+
+	"github.com/pmezard/go-difflib/difflib"
+)
+
+func Unified(fromName, toName, fromContent, toContent string) string {
+	u := difflib.UnifiedDiff{
+		A:        difflib.SplitLines(normalizeNewline(fromContent)),
+		B:        difflib.SplitLines(normalizeNewline(toContent)),
+		FromFile: fromName,
+		ToFile:   toName,
+		Context:  3,
+	}
+	text, err := difflib.GetUnifiedDiffString(u)
+	if err != nil {
+		return "(diff unavailable)"
+	}
+	if strings.TrimSpace(text) == "" {
+		return "(no changes)"
+	}
+	return text
+}
+
+func normalizeNewline(s string) string {
+	// avoid CRLF noise
+	return strings.ReplaceAll(s, "\r\n", "\n")
+}

package/internal/fsutil/fsutil.go

@@ -0,0 +1,35 @@
+package fsutil
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"time"
+)
+
+func ReadFile(path string) (string, error) {
+	b, err := os.ReadFile(path)
+	if err != nil {
+		return "", err
+	}
+	return string(b), nil
+}
+
+// WriteFileAtomic writes content to path using a temp file + rename.
+func WriteFileAtomic(path string, content []byte, perm os.FileMode) error {
+	dir := filepath.Dir(path)
+	base := filepath.Base(path)
+	tmp := filepath.Join(dir, fmt.Sprintf(".%s.%d.tmp", base, time.Now().UnixNano()))
+	if err := os.WriteFile(tmp, content, perm); err != nil {
+		return err
+	}
+	return os.Rename(tmp, path)
+}
+
+func FilePermOrDefault(path string, def os.FileMode) os.FileMode {
+	st, err := os.Stat(path)
+	if err != nil {
+		return def
+	}
+	return st.Mode()
+}