18 | No completeness data available
19 |
20 | `);
21 | return;
22 | }
23 |
24 | // Calculate overall statistics
25 | const totalFiles = completenessData.files.length;
26 | let totalClasses = 0;
27 | let totalClassesWithDocs = 0;
28 | let totalFunctions = 0;
29 | let totalFunctionsWithDocs = 0;
30 |
31 | completenessData.files.forEach(file => {
32 | if (file.classes) {
33 | totalClasses += file.classes.length;
34 | totalClassesWithDocs += file.classes.filter(c => c.has_docstring).length;
35 | }
36 | if (file.functions) {
37 | totalFunctions += file.functions.length;
38 | totalFunctionsWithDocs += file.functions.filter(f => f.has_docstring).length;
39 | }
40 | });
41 |
42 | const classCompleteness = totalClasses > 0 ? Math.round((totalClassesWithDocs / totalClasses) * 100) : 0;
43 | const functionCompleteness = totalFunctions > 0 ? Math.round((totalFunctionsWithDocs / totalFunctions) * 100) : 0;
44 | const totalComponents = totalClasses + totalFunctions;
45 | const totalComponentsWithDocs = totalClassesWithDocs + totalFunctionsWithDocs;
46 | const overallCompleteness = totalComponents > 0 ? Math.round((totalComponentsWithDocs / totalComponents) * 100) : 0;
47 |
48 | // Create the HTML for the completeness view
49 | let html = `
50 |
51 |
64 |
65 | Overall Completeness: ${overallCompleteness}%
52 |
53 |
54 |
55 |
56 |
63 |
57 | Classes: ${totalClassesWithDocs}/${totalClasses} (${classCompleteness}%)
58 |
59 |
60 | Functions: ${totalFunctionsWithDocs}/${totalFunctions} (${functionCompleteness}%)
61 |
62 | Files (${totalFiles})
66 |
67 |
68 |
69 |
132 |
133 | `;
134 |
135 | // Update the completeness data container
136 | $('#completeness-data').html(html);
137 | }
--------------------------------------------------------------------------------
/src/evaluator/segment.py:
--------------------------------------------------------------------------------
1 | # Copyright (c) Meta Platforms, Inc. and affiliates
2 | import re
3 |
4 | def parse_google_style_docstring(docstring):
5 | """
6 | A robust parser for Google-style docstrings that have multiple possible
7 | labels for each section.
8 |
9 | For example, any of the lines in EXAMPLE_LABELS indicates the start of the "examples" section.
10 | """
11 |
12 | # Define all recognized sections. The key is the canonical name (lowercase).
13 | # The value is a set of synonyms (also lowercase).
14 | SECTION_LABELS = {
15 | "summary": {"summary:", "short description:", "brief:", "overview:"},
16 | "description": {"description:", "desc:", "details:", "detailed description:", "long description:"},
17 | "parameters": {"parameters:", "params:", "args:", "arguments:", "keyword args:", "keyword arguments:", "**kwargs:"},
18 | "attributes": {"attributes:", "members:", "member variables:", "instance variables:", "properties:", "vars:", "variables:"},
19 | "returns": {"returns:", "return:", "return value:", "return values:"},
20 | "raises": {"raises:", "exceptions:", "throws:", "raise:", "exception:", "throw:"},
21 | "examples": {"example:", "examples:", "usage:", "usage example:", "usage examples:", "example usage:"},
22 | }
23 |
24 | # Prepare a dictionary to hold the parsed content for each canonical key
25 | parsed_content = {key: [] for key in SECTION_LABELS.keys()}
26 |
27 | # Split by lines; if docstring uses Windows line endings, .splitlines() handles that gracefully
28 | lines = docstring.strip().splitlines()
29 |
30 | # -- 1) Fallback: no explicit sections at all in the entire docstring --
31 | # If no recognized label appears anywhere, treat the first line as summary, rest as description.
32 | has_section_labels = False
33 | for line in lines:
34 | line_lower = line.strip().lower()
35 | for labels in SECTION_LABELS.values():
36 | for label in labels:
37 | if line_lower.startswith(label):
38 | has_section_labels = True
39 | break
40 | if has_section_labels:
41 | break
42 | if has_section_labels:
43 | break
44 |
45 | if len(lines) > 0 and not has_section_labels:
46 | parsed_content["summary"] = [lines[0]]
47 | if len(lines) > 1:
48 | parsed_content["description"] = lines[1:]
49 | # Convert lists to single strings
50 | return {key: "\n".join(value).strip() for key, value in parsed_content.items()}
51 |
52 | # -- 2) Partial Fallback for the first line only --
53 | # If the first line doesn't match any known label, treat it as summary and then
54 | # switch to "description" until an explicit label is found.
55 | current_section = None # keep track of which section we're in
56 |
57 | first_line = lines[0].strip().lower() if lines else ""
58 | if not any(first_line.startswith(label) for labels in SECTION_LABELS.values() for label in labels):
59 | if lines:
60 | # Save first line as summary
61 | parsed_content["summary"] = [lines[0]]
62 | # Make the current section "description"
63 | current_section = "description"
64 | lines = lines[1:] # We'll handle the rest below
65 |
66 | for line in lines:
67 | # We'll do a trimmed, lowercase version of the line to check for a header
68 | # but keep original_line if you want to preserve original indentation or case.
69 | trimmed_line = line.strip().lower()
70 |
71 | # Check if the trimmed line (minus trailing colon, if present) matches a known section
72 | # We'll also handle any trailing colon, extra spaces, etc.
73 | # e.g. " Parameters: " -> "parameters:"
74 | # We only match a line if it starts exactly with that label.
75 | # If you want more flexible matching (like partial lines), you can adapt this.
76 | matched_section = None
77 | for canonical_name, synonyms in SECTION_LABELS.items():
78 | # Each synonym might be "parameters:", "args:", etc.
79 | # We'll see if the trimmed_line starts exactly with one of them.
80 | for synonym in synonyms:
81 | # If line starts with the synonym, we treat it as a new section.
82 | # Example: "PARAMETERS:" -> synonyms might contain "parameters:" in lowercase
83 | if trimmed_line.startswith(synonym):
84 | matched_section = canonical_name
85 | # Extract leftover text on the same line, after the label
86 | leftover = line.strip()[len(synonym):].strip()
87 | if leftover:
88 | parsed_content[matched_section].append(leftover)
89 | break
90 |
91 | if matched_section:
92 | break
93 |
94 | # If matched_section is not None, we found a new section header
95 | if matched_section is not None:
96 | # Switch to that section
97 | current_section = matched_section
98 | # No need to append the header line to content - we've already handled any content after the label
99 | else:
100 | # Otherwise, accumulate this line under the current section if we have one
101 | if current_section is not None:
102 | parsed_content[current_section].append(line)
103 |
104 | # Convert list of lines to a single string for each section,
105 | # with consistent line breaks, and strip extra whitespace
106 | for section in parsed_content:
107 | parsed_content[section] = "\n".join(parsed_content[section]).strip()
108 |
109 | return parsed_content
110 |
111 |
112 | # ------------------------------ Example Usage ------------------------------
113 | if __name__ == "__main__":
114 | sample_docstring = """
115 | Summary:
116 | Provides a utility for processing and managing data through a structured workflow.
117 |
118 | Description:
119 | This class is designed to facilitate data processing tasks by integrating with the `DataProcessor` class.
120 | It retrieves and manipulates data.
121 |
122 | Parameters:
123 | param1: This is the first parameter.
124 | param2: This is the second parameter.
125 |
126 | Attributes:
127 | data: Stores the current data.
128 |
129 | Example:
130 | ```python
131 | helper = HelperClass()
132 | helper.process_data()
133 | print(helper.data)
134 | ```
135 | """
136 |
137 | result = parse_google_style_docstring(sample_docstring)
138 |
139 | # Print out each section
140 | for section_name, content in result.items():
141 | print("SECTION:", section_name.upper())
142 | print("CONTENT:\n", content)
143 | print("-" * 40)
144 |
--------------------------------------------------------------------------------
/src/agent/reader.py:
--------------------------------------------------------------------------------
1 | # Copyright (c) Meta Platforms, Inc. and affiliates
2 | from dataclasses import dataclass
3 | from enum import Enum
4 | from typing import Any, Dict, List, Optional, Tuple
5 |
6 | from .base import BaseAgent
7 |
8 |
9 | class CodeComponentType(Enum):
10 | """Enum for different types of code components."""
11 |
12 | FUNCTION = "function"
13 | METHOD = "method"
14 | CLASS = "class"
15 |
16 |
17 | @dataclass
18 | class InformationRequest:
19 | """Data class for structured information requests."""
20 |
21 | internal_requests: List[str]
22 | external_requests: List[str]
23 |
24 |
25 | class Reader(BaseAgent):
26 | """Agent responsible for determining if more context is needed for docstring generation."""
27 |
28 | def __init__(self, config_path: Optional[str] = None):
29 | """Initialize the Reader agent.
30 |
31 | Args:
32 | config_path: Optional path to the configuration file
33 | """
34 | super().__init__("Reader", config_path)
35 | self.system_prompt = """You are a Reader agent responsible for determining if more context
36 | is needed to generate a high-quality docstring. You should analyze the code component and
37 | current context to make this determination.
38 |
39 | You have access to two types of information sources:
40 |
41 | 1. Internal Codebase Information (from local code repository):
42 | For Functions:
43 | - Code components called within the function body
44 | - Places where this function is called
45 |
46 | For Methods:
47 | - Code components called within the method body
48 | - Places where this method is called
49 | - The class this method belongs to
50 |
51 | For Classes:
52 | - Code components called in the __init__ method
53 | - Places where this class is instantiated
54 | - Complete class implementation beyond __init__
55 |
56 | 2. External Open Internet retrieval Information:
57 | - External Retrieval is extremely expensive. Only request external open internet retrieval information if the component involves a novel, state of the art, recently-proposed algorithms or techniques.
58 | (e.g. computing a novel loss function (NDCG Loss, Alignment and Uniformity Loss, etc), certain novel metrics (Cohen's Kappa, etc), specialized novel ideas)
59 | - Each query should be a clear, natural language question
60 |
61 | Your response should:
62 | 1. First provide a free text analysis of the current code and context
63 | 2. Explain what additional information might be needed (if any)
64 | 3. Include an | File | 71 |Classes | 72 |Functions | 73 |Completeness | 74 |
|---|---|---|---|
| ${file.file.split('/').pop()} | 117 |${classesWithDocs}/${classes.length} | 118 |${functionsWithDocs}/${functions.length} | 119 |120 | 123 | ${fileCompleteness}% 124 | | 125 |
4 | 
5 |
49 |
50 | For more details on the agentic framework, see the [Agent Component README](./src/agent/README.md).
51 |
52 | ## Installation
53 |
54 | 1. Clone the repository:
55 | ```bash
56 | git clone