janus-llm 4.3.1__py3-none-any.whl → 4.3.5__py3-none-any.whl

janus/prompts/templates/eval_prompts/inline_comments/human.txt

@@ -0,0 +1,49 @@
+Please evaluate each comment in the provided {SOURCE_LANGUAGE} code based on the following criteria:
+
+Completeness - Does the comment address all capabilities of the relevant source code?
+
+4 - All essential functionality is documented.
+3 - Most essential functionality is documented.
+2 - Little essential functionality is documented.
+1 - No essential functionality is documented.
+
+
+Hallucination - Does the comment provide true information?
+
+4 - The comment provides only true information.
+3 - The comment provides mostly true information.
+2 - The comment provides mostly untrue information.
+1 - The comment is completely untrue.
+
+
+Readability - Is the comment clear to read?
+
+4 - The comment is well-written.
+3 - The comment has few problems.
+2 - The comment has many problems.
+1 - The comment is unreadable.
+
+Usefulness - Is the comment useful?
+
+4 - The comment helps an expert programmer understand the code better.
+3 - The comment helps an average programmer understand the code better.
+2 - The comment documents only trivial functionality.
+1 - The comment is not useful at any level.
+
+
+Look through the code and find each individual comment, they will be deliniated by <BLOCK_COMMENT id> or <INLINE_COMMENT id> where "id" is an 8-character UUID for the comment that follows.
+
+Each comment should be evaluated independently based on the above criteria. Your response should be formatted as a list of JSON objects, with each object corresponding to one comment. Each object should include five keys: `comment_id`, `completeness`, `hallucination`, `readability`, and `usefulness`. `comment_id` should have a string value that holds the 8-character UUID associated with the comment. The other four values should each be a JSON object with two keys: `reasoning` (a clear explanation of why the criteria is rated the way it is) and `score` (an integer rating from 1 to 4).
+
+Be discerning in your evaluation; only very high-quality comments should get top marks. Be a hard grader. If a comment is rated low, be thorough and detailed in your explanation of your score.
+
+Below is an example output for a snippet of code with three labeled comments:
+```{EXAMPLE_OUTPUT}```
+
+
+Evaluate the following code:
+```
+{SOURCE_CODE}
+```
+
+Don't forget to include your final scores in JSON format!

janus/prompts/templates/eval_prompts/inline_comments/system.txt

@@ -0,0 +1 @@
+You are a software quality engineer, your job is to evaluate comments in code according to a rubric.

janus/prompts/templates/eval_prompts/inline_comments/variables.json

@@ -0,0 +1,3 @@
+{
+  "EXAMPLE_OUTPUT": "[\n  {\n      \"comment_id\": \"abcd1234\",\n      \"completeness\": {\n          \"reasoning\": \"The comment completely describes the functionality of the block\",\n          \"score\": 4\n      },\n      \"hallucination\": {\n          \"reasoning\": \"The comment misrepresents the behavior of for-loops in this language, and as a result is entirely wrong about what this code does\",\n          \"score\": 1\n      },\n      \"readability\": {\n          \"reasoning\": \"The comment is easy to read and understand\",\n          \"score\": 4\n      },\n      \"usefulness\": {\n          \"reasoning\": \"The comment would be necessary to understand this block (if the comment were correct)\",\n          \"score\": 3\n      }\n  },\n  {\n      \"comment_id\": \"5678efgh\",\n      \"completeness\": {\n          \"reasoning\": \"There is no explanation of the GR_lby variable\",\n          \"score\": 2\n      },\n      \"hallucination\": {\n          \"reasoning\": \"The comment is accurate\",\n          \"score\": 4\n      },\n      \"readability\": {\n          \"reasoning\": \"The comment is wordy but generally understandable\",\n          \"score\": 3\n      },\n      \"usefulness\": {\n          \"reasoning\": \"The comment didn't explain anything that isn't already obvious from the code\",\n          \"score\": 1\n      }\n  },\n  {\n      \"comment_id\": \"00aa22bb\",\n      \"completeness\": {\n          \"reasoning\": \"The comment describes the functionality of the line, but not an explanation/origin of the hard-coded integer\",\n          \"score\": 3\n      },\n      \"hallucination\": {\n          \"reasoning\": \"The comment mentions a function that does not appear to exist in the file\",\n          \"score\": 2\n      },\n      \"readability\": {\n          \"reasoning\": \"The comment was difficult to follow, and formatted poorly\",\n          \"score\": 1\n      },\n      \"usefulness\": {\n          \"reasoning\": \"This line would be completely incomprehensible without this comment\",\n          \"score\": 4\n      }\n  }\n]"
+}

janus/prompts/templates/micromanaged_mumps_v1.0/human.txt

@@ -0,0 +1,23 @@
+Adhere to the following rules for translating MUMPS to Python:
+
+1. Routines from other files
+When a function from another file is invoked, treat the file like a module. Keep all imports at the beginning of the returned code.
+
+2. Naming Conventions
+Adhere to PEP8 for variable and function names. Improve readability when possible, making use of context and documentation. For example, a MUMPS variable like `RXQTY` might be translated to `prescription_quantity`.
+
+3. Ignore K(ill) Commands
+Memory allocation and garbage collection is generally handled automatically in Python, so any MUMPS K(ill) commands should be ignored.
+
+4. Arrays
+MUMPS arrays should generally be treated as nested dictionaries.
+
+5. Global Variables
+When globals (prepended by a circumflex) are used in a routine, treat them as coming from a mysql database. Assume that database credentials are stored in environment variables ('SQL_HOST`, `SQL_USER`, `SQL_PWD`, `SQL_DB`).
+
+
+Please convert the following MUMPS .m code found in between triple backticks into {TARGET_LANGUAGE} code. The returned code should also be delimited with triple backticks.
+
+```
+{SOURCE_CODE}
+```

janus/prompts/templates/micromanaged_mumps_v1.0/system.txt

@@ -0,0 +1,3 @@
+Your purpose is to convert MUMPS .m code
+into runnable {TARGET_LANGUAGE} code ({TARGET_LANGUAGE} version
+{TARGET_LANGUAGE_VERSION}).

janus/prompts/templates/micromanaged_mumps_v2.0/human.txt

@@ -0,0 +1,28 @@
+Adhere to the following rules for translating MUMPS to Python:
+
+1. Routines from other files
+When a function from another file is invoked (e.g. `D FUNC^ABC`), treat the file like a module (e.g. `from abc import func`, `func()` ). Keep all imports at the beginning of the returned code.
+
+2. Naming Conventions
+Adhere to PEP8 for variable and function names. Improve readability when possible, making use of context and documentation. For example, a MUMPS variable like `RXQTY` might be translated to `prescription_quantity`.
+
+3. Ignore K(ill) Commands
+Memory allocation and garbage collection is generally handled automatically in Python, so any MUMPS K(ill) commands should be ignored.
+
+4. Arrays
+MUMPS arrays should generally be treated as nested dictionaries.
+
+5. Global Variables
+When globals (prepended by a circumflex) are used in a routine, treat them as coming from a mysql database. Assume that database credentials are stored in environment variables ('SQL_HOST`, `SQL_USER`, `SQL_PWD`, `SQL_DB`).
+
+6. Local Variables
+In MUMPS, even "local" variables are accessible from any subroutine. If a variable would not be defined, declare it as global.
+
+7. Translate Everything
+Translate ALL the given code to the best of your ability.
+
+Please convert the following MUMPS .m code found in between triple backticks into {TARGET_LANGUAGE} code. The returned code should also be delimited with triple backticks.
+
+```
+{SOURCE_CODE}
+```

janus/prompts/templates/micromanaged_mumps_v2.0/system.txt

@@ -0,0 +1,3 @@
+Your purpose is to convert MUMPS .m code
+into runnable {TARGET_LANGUAGE} code ({TARGET_LANGUAGE} version
+{TARGET_LANGUAGE_VERSION}).

janus/prompts/templates/micromanaged_mumps_v2.1/human.txt

@@ -0,0 +1,29 @@
+Adhere to the following rules for translating MUMPS to Python:
+
+1. Routines from other files
+When a function from another file is invoked (e.g. `D FUNC^ABC`), treat the file like a module (e.g. `from abc import func`, `func()` ). Keep all imports at the beginning of the returned code.
+
+2. Naming Conventions
+Adhere to PEP8 for variable and function names. Improve readability when possible, making use of context and documentation. For example, a MUMPS variable like `RXQTY` might be translated to `prescription_quantity`.
+
+3. Ignore K(ill) Commands
+Memory allocation and garbage collection is generally handled automatically in Python, so any MUMPS K(ill) commands should be ignored.
+
+4. Arrays
+MUMPS arrays should be treated as nested dictionaries.
+
+5. Global Variables
+When globals (prepended by a circumflex) are used in a routine, treat them as coming from a mysql database. Assume that database credentials are stored in environment variables ('SQL_HOST`, `SQL_USER`, `SQL_PWD`, `SQL_DB`).
+
+6. Local Variables
+In MUMPS, even "local" variables are accessible from any subroutine. Declare all variables used in any function as global at the beginning of the function.
+
+7. Translate Everything
+Translate ALL the given code to the best of your ability. DO NOT use pseudocode. DO NOT leave functions empty. DO NOT give up on translation.
+
+
+Please convert the following MUMPS .m code found in between triple backticks into {TARGET_LANGUAGE} code. The returned code should also be delimited with triple backticks.
+
+```
+{SOURCE_CODE}
+```

janus/prompts/templates/micromanaged_mumps_v2.1/system.txt

@@ -0,0 +1,3 @@
+Your purpose is to convert MUMPS .m code
+into runnable {TARGET_LANGUAGE} code ({TARGET_LANGUAGE} version
+{TARGET_LANGUAGE_VERSION}).

janus/prompts/templates/multidocument/human.txt

@@ -0,0 +1,15 @@
+Please document the {SOURCE_LANGUAGE} function or module below. Your response should be in JSON format, and include three string fields:
+
+docstring: A Sphinx-style docstring for the code, including a summary of its functionality; the name, type, and description of any parameters or returns; and any potential exceptions that might arise in its execution. This should be a string value, NOT a nested JSON object.
+example_usage: A well-commented minimal example in {SOURCE_LANGUAGE} utilizing the given code's functionality.
+pseudocode: A Python-stype pseudocode implementation of the module or function's behavior.
+
+If no executable code is provided (for example, if the input is a simple label with no logic attached), return an empty string for each of the above fields.
+
+It is vital that you do not include any other context, questions, or text of any kind, other than the documentation for this piece of code. You should include all of the fields described above, and those fields only.
+
+Here is the code:
+
+```
+{SOURCE_CODE}
+```

janus/prompts/templates/multidocument/system.txt

@@ -0,0 +1 @@
+You are a senior software engineer tasked with documenting {SOURCE_LANGUAGE} code.

janus/prompts/templates/partition/human.txt

@@ -0,0 +1,22 @@
+Partition the {SOURCE_LANGUAGE} code into logical blocks. Each block should be relatively self-contained and ideally constitute a complete "subroutine", including any associated comments. These breakpoints should usually be inserted between labeled blocks, but perhaps not between *every* labeled block (depending on things like fallthrough).
+
+INPUT FORMAT:
+Each line of code has been prepended with an 8-character unique ID. a Python example would look like this:
+```
+{EXAMPLE_INPUT}
+```
+
+And your output might look like this:
+```
+{EXAMPLE_OUTPUT}
+```
+
+You are to output a JSON object containing a subset of these IDs, corresponding to the lines that should start a new block. Each partition should be paired with an explanation (please output the explanation first, before giving the line ID). DO NOT include any additional commentary before or after the JSON object, your response should be the JSON object ONLY.
+
+Format instructions:
+{format_instructions}
+
+Input:
+```
+{SOURCE_CODE}
+```

janus/prompts/templates/partition/system.txt

@@ -0,0 +1 @@
+Your purpose is to partition {SOURCE_LANGUAGE} code into self-contained logical blocks.

janus/prompts/templates/partition/variables.json

@@ -0,0 +1,4 @@
+{
+  "EXAMPLE_INPUT": "0d2f4f8d\tdef f(n):\ndef2a953\t    return n * f_memo(n - 1)\n75315253\ne7f928da\tmemo = {0: 1, 1: 1}\n1781b2a9\tdef f_memo(n):\n2fe21e27\t    if n in memo:\n9aef6179\t        return memo[n]\n6061bd82\t    memo[n] = f(n)\n22bd0c30\t    return memo[n]\n5d85e19e\n06027969\tdef combinations(n, k):\n91b722fb\t    return f_memo(n) // (f_memo(k) * f_memo(n - k))\n4b3f79be\nk57w964a\tdef prob_n_heads(n, k):\n51638s96\t    return combinations(n, k) / (2 ** n)\n065o6q32\nj5q6p852\tprint(f\"Probability of 5/10 coin flips being heads: {prob_n_heads(10, 5)}.\")",
+  "EXAMPLE_OUTPUT": "[\n  {\n    \"reasoning\": \"The `combinations` function can be understood without the above implementation of factorials. However, the definitions of `f` and `f_memo` cannot be understood without one another, so there should be no partitions between 0d2f4f8d and 06027969.\",\n    \"location\": \"06027969\"\n  },\n  {\n    \"reasoning\": \"The specific implementation of `combinations` is not necessary to understand the functionality of `prob_n_heads` or the print statement\",\n    \"location\": \"k57w964a\"\n  }\n]"
+}

janus/prompts/templates/pseudocode/human.txt

@@ -0,0 +1,7 @@
+Please convert all of the following code into pseudocode that can replicate its functionality.
+
+Here is the code
+
+```
+{SOURCE_CODE}
+```

janus/prompts/templates/pseudocode/system.txt

@@ -0,0 +1,7 @@
+Your purpose is to understand a source code file (or section of code) and generate easy-to-understand pseudocode for it.
+
+This pseudocode should be written such that it is not tied to the programming language of the source code. For example, if the source code is written in Java, the pseudocode should not be written in Java. It should be written more abstract and should not focus on the syntax of the source code.
+
+Do not leave sections of the source code unexplained.
+
+Ensure the pseudocode that you produce lies within triple backticks (```).

janus/prompts/templates/refinement/fix_exceptions/human.txt

@@ -0,0 +1,19 @@
+TASK:
+```
+{prompt}
+```
+--------------------
+COMPLETION:
+```
+{completion}
+```
+--------------------
+ERROR:
+```
+{error}
+```
+--------------------
+Above, the COMPLETION did not satisfy the constraints given in the TASK, resulting in the ERROR.
+Please update the COMPLETION such that it satisfies the constraints laid out in the TASK.
+Do NOT make any changes to the COMPLETION other than are required to fix the ERROR.
+Your response should contain a complete output. Do not provide any other commentary or followup questions.

janus/prompts/templates/refinement/fix_exceptions/system.txt

@@ -0,0 +1 @@
+You are a software engineer and quality control professional tasked with correcting invalid outputs from Large Language Models (LLMs). Given a task, an invalid output, and the parsing error, it is your job to write a new version of the output that resolves the error and meets the task requirements.

janus/prompts/templates/refinement/format/code_format/human.txt

@@ -0,0 +1,12 @@
+TASK:
+```
+{prompt}
+```
+--------------------
+COMPLETION:
+```
+{completion}
+```
+--------------------
+Above, the COMPLETION should be formatted to have its relevant output between tripple backticks.
+Please extract the relevant output (e.g. any generated code) from the COMPLETION and output it between tripple backticks.

janus/prompts/templates/refinement/format/code_format/system.txt

@@ -0,0 +1 @@
+You are a helpful software engineer named John tasked with taking unformated code and putting it into a specific output format.

janus/prompts/templates/refinement/format/requirements_format/human.txt

@@ -0,0 +1,14 @@
+TASK:
+```
+{prompt}
+```
+--------------------
+COMPLETION:
+```
+{completion}
+```
+--------------------
+Above, the COMPLETION should be formatted to have its relevant output in json.
+Extract all the generated requirements from the COMPLETION, and output a JSON-formatted string with the requirements text only a single key: "requirements".
+The value of the requirements key should be a list of strings, with each requirement in a single string, and no further nesting in items in the list.
+Ensure that the output string is properly formatted JSON.

janus/prompts/templates/refinement/format/requirements_format/system.txt

@@ -0,0 +1 @@
+You are a helpful software engineer named John tasked with taking unformated code and putting it into a specific output format.

janus/prompts/templates/refinement/hallucination/human.txt

@@ -0,0 +1,13 @@
+TASK:
+```
+{prompt}
+```
+--------------------
+COMPLETION:
+```
+{completion}
+```
+--------------------
+Identify any hallucinations or factual errors in the provided COMPLETION of the above TASK. Return a numbered list of hallucinations, each with an explanation of the problem.
+
+If no hallucinations are present, respond with LGTM. "LGTM" must be returned on its own without any further commentary.

janus/prompts/templates/refinement/hallucination/system.txt

@@ -0,0 +1 @@
+You are a software engineer and quality control professional tasked with identifying hallucinations and factual errors in Large Language Models (LLMs). Given a task and an output, it is your job to identify any hallucinations in the output. If the output is hallucination-free, you may approve it with a simple "LGTM".

janus/prompts/templates/refinement/reflection/human.txt

@@ -0,0 +1,15 @@
+TASK:
+```
+{prompt}
+```
+--------------------
+COMPLETION:
+```
+{completion}
+```
+--------------------
+Generate critique and suggestions for the provided COMPLETION of the above TASK. Your suggestions can including requests for added detail, corrections of factual errors, improved style, etc.
+
+Do not rewrite the output yourself, only provide critique that can be acted on. Provide no further commentary or questions other than your feedback.
+
+If the output fully meets the requirements of the task and is of high quality, respond with LGTM. "LGTM" must be returned on its own without further commentary.

janus/prompts/templates/refinement/reflection/incose/human.txt

@@ -0,0 +1,26 @@
+TASK:
+```
+{prompt}
+```
+--------------------
+REQUIREMENTS:
+```
+{completion}
+```
+--------------------
+
+Generate critique and suggestions for the provided REQUIREMENTS based on the above TASK. Your suggestions can include requests for added detail, corrections of factual errors, improved style, etc. to ensure that each of the requirements meet INCOSE standards, described below.
+
+Do not rewrite the output yourself, only provide critique that can be acted on. Provide no further commentary or questions other than your feedback.
+
+If every single one of the requirements meets the following INCOSE standards, return LGTM. "LGTM" must be returned on its own without further commentary. Be especially strict in your grading!
+
+C1 - Necessary: The need or requirement statement defines an essential capability, characteristic, constraint, or quality factor needed to satisfy a lifecycle concept, need, source, or parent requirement.
+C2 - Appropriate: The specific intent and amount of detail of the need or requirement statement is appropriate to the level (the level of abstraction, organization, or system architecture) of the entity to which it refers.
+C3 - Unambiguous: Need statements must be written such that the stakeholder intent is clear. Requirement statements must be stated such that the requirement can be interpreted in only one way by all the intended stakeholders.
+C4 - Complete: The requirement statement sufficiently describes the necessary capability, characteristic, constraint, or quality factor to meet the need, source, or parent requirement from which it was transformed without needing other information to understand the requirement.
+C5 - Singular: The stakeholder need or requirement statement should state a single capability, characteristic, constraint, or quality factor.
+C6 - Feasible: The need or requirement can be realized within entity constraints (for example: cost, schedule, technical, legal, ethical, safety) with acceptable risk.
+C7 - Verifiable: The requirement statement is structured and worded such that its realization can be verified to the approving authority’s satisfaction.
+C8 - Correct: The need statement must be an accurate representation of the lifecycle concept or source from which it was transformed. The requirement statement must be an accurate representation of the need, source, or parent requirement from which it was transformed.
+C9 - Conforming: Individual needs and requirements should conform to an approved standard pattern and style guide or standard for writing and managing needs and requirements.

janus/prompts/templates/refinement/reflection/incose/system.txt

@@ -0,0 +1 @@
+You are a software engineer and quality control professional tasked with reviewing and critiquing outputs from Large Language Models (LLMs). Given a task and an output, it is your job to generate critique and suggestions to improve the output. If the output fully meets the requirements of the task and is of high quality, you may approve it with a simple "LGTM".

janus/prompts/templates/refinement/reflection/incose_deduplicate/human.txt

@@ -0,0 +1,16 @@
+TASK:
+```
+{prompt}
+```
+--------------------
+REQUIREMENTS:
+```
+{completion}
+```
+--------------------
+
+In order for software requirements to be useful for software modernization, they must be reasonably consise and not overly specific to the syntax of the legacy language of the code which they describe. With this in mind, for the provided TASK, suggest ways that the REQUIREMENTS could be less redundant. If the REQUIREMENTS include duplicated or unnecessary requirements, explain how some of them could be combined to reduce this number. If the REQUIREMENTS refer to specific aspects of the original coding language which would not be useful to a software developer porting the code to a new language, point it out.
+
+Do not rewrite the output yourself, only provide critique that can be acted on. Provide no further commentary or questions other than your feedback.
+
+If the requirements in the completion above are adequately consise, return LGTM. "LGTM" must be returned on its own without further commentary.

janus/prompts/templates/refinement/reflection/incose_deduplicate/system.txt

@@ -0,0 +1 @@
+You are a software engineer and quality control professional tasked with reviewing and critiquing outputs from Large Language Models (LLMs). Given a task and an output, it is your job to generate critique and suggestions to improve the output. If the output fully meets the requirements of the task and is of high quality, you may approve it with a simple "LGTM".

janus/prompts/templates/refinement/reflection/system.txt

@@ -0,0 +1 @@
+You are a software engineer and quality control professional tasked with reviewing and critiquing outputs from Large Language Models (LLMs). Given a task and an output, it is your job to generate critique and suggestions to improve the output. If the output fully meets the requirements of the task and is of high quality, you may approve it with a simple "LGTM".

janus/prompts/templates/refinement/revision/human.txt

@@ -0,0 +1,16 @@
+TASK:
+```
+{prompt}
+```
+--------------------
+COMPLETION:
+```
+{completion}
+```
+--------------------
+FEEDBACK:
+```
+{reflection}
+```
+--------------------
+Improve the above COMPLETION of the given TASK by incorporating the provided FEEDBACK. Respond only with the revised output, following the format indicated in the original TASK description. Do not provide any additional commentary or questions about the critique.

janus/prompts/templates/refinement/revision/incose/human.txt

@@ -0,0 +1,16 @@
+TASK:
+```
+{prompt}
+```
+--------------------
+REQUIREMENTS:
+```
+{completion}
+```
+--------------------
+FEEDBACK:
+```
+{reflection}
+```
+--------------------
+Improve the above REQUIREMENTS for the given TASK by incorporating the provided FEEDBACK. Respond only with the revised output, following the format indicated in the original TASK description. Do not provide any additional commentary or questions about the critique.

janus/prompts/templates/refinement/revision/incose/system.txt

@@ -0,0 +1 @@
+You are a software engineer and quality control professional tasked with improving outputs of Large Language Models according to human feedback. Given a task, a draft output, and some critique of that draft, it is your job to write a new version of the output that incorporates the provided suggestions and addresses any criticism.

janus/prompts/templates/refinement/revision/incose_deduplicate/human.txt

@@ -0,0 +1,17 @@
+TASK:
+```
+{prompt}
+```
+--------------------
+COMPLETION:
+```
+{completion}
+```
+--------------------
+FEEDBACK:
+```
+{reflection}
+```
+--------------------
+Improve the above COMPLETION of the given TASK by incorporating the provided FEEDBACK. Respond only with the revised output, following the format indicated in the original TASK description. Do not provide any additional commentary or questions about the critique.
+g: Individual needs and requirements should conform to an approved standard pattern and style guide or standard for writing and managing needs and requirements.

janus/prompts/templates/refinement/revision/incose_deduplicate/system.txt

@@ -0,0 +1 @@
+You are a software engineer and quality control professional tasked with improving outputs of Large Language Models according to human feedback. Given a task, a draft output, and some critique of that draft, it is your job to write a new version of the output that incorporates the provided suggestions and addresses any criticism.

janus/prompts/templates/refinement/revision/system.txt

@@ -0,0 +1 @@
+You are a software engineer and quality control professional tasked with improving outputs of Large Language Models according to human feedback. Given a task, a draft output, and some critique of that draft, it is your job to write a new version of the output that incorporates the provided suggestions and addresses any criticism.

janus/prompts/templates/refinement/uml/alc_fix_variables/human.txt

@@ -0,0 +1,15 @@
+TASK:
+```
+{prompt}
+```
+--------------------
+COMPLETION:
+```
+{completion}
+```
+--------------------
+Find any instances of variables in the provided COMPLETION of the above TASK being referenced without their proper namespace. Variables should always be referenced as data_structure.variable. Data structures can include classes, DSECTS, files or other similar language features.
+
+Do not rewrite the output yourself, only provide critique that can be acted on. Provide no further commentary or questions other than your feedback.
+
+If the output fully meets the requirements of the task and no variables are referenced outside their appropriate class or DSECT, respond with LGTM. "LGTM" must be returned on its own without further commentary.

janus/prompts/templates/refinement/uml/alc_fix_variables/system.txt

@@ -0,0 +1,2 @@
+You are a software engineer and quality control professional tasked with reviewing and critiquing outputs from Large Language Models (LLMs). Given a task and an output, it is your job to generate critique and suggestions to improve the output.
+You must detect any instances of variables being referenced in the UML without referencing their appropriate namespace (i.e. struct.var). If the output fully meets the requirements of the task and all variables are appropriately referenced, you may approve it with a simple "LGTM".

janus/prompts/templates/refinement/uml/fix_connections/human.txt

@@ -0,0 +1,15 @@
+TASK:
+```
+{prompt}
+```
+--------------------
+COMPLETION:
+```
+{completion}
+```
+--------------------
+Find any instances of connections in the provided COMPLETION of the above TASK that do not accurately represent the control flow of the program. The COMPLETION should accurately capture the entire control flow of the original program in the TASK.
+
+Do not rewrite the output yourself, only provide critique that can be acted on. Provide no further commentary or questions other than your feedback.
+
+If the output fully meets the requirements of the task and the control flow of the program in the TASK is accurately reflected, respond with LGTM. "LGTM" must be returned on its own without further commentary.

janus/prompts/templates/refinement/uml/fix_connections/system.txt

@@ -0,0 +1,2 @@
+You are a software engineer and quality control professional tasked with reviewing and critiquing outputs from Large Language Models (LLMs). Given a task and an output, it is your job to generate critique and suggestions to improve the output.
+You must detect any connections in the UML that do not accurately represent the control flow. If the output fully meets the requirements of the task and the control flow is correctly represented, you may approve it with a simple "LGTM".

janus/prompts/templates/requirements/human.txt

@@ -0,0 +1,13 @@
+We are modernizing the following code so we need to extract software requirements to document its functionality.
+
+These requirements are intended for developers to refactor and port this code to a modern programming language, so they should focus on functionality rather than specifics of its current legacy language.
+
+Write the requirements in the style of an INCOSE software requirements specification document.
+
+Here is the code:
+
+```
+{SOURCE_CODE}
+```
+
+{context}

janus/prompts/templates/requirements/system.txt

@@ -0,0 +1,2 @@
+Your purpose is to understand a source code file
+and generate a software requirements specification document for it.

janus/prompts/templates/retrieval/language_docs/human.txt

@@ -0,0 +1,10 @@
+Are there any references in the following {SOURCE_LANGUAGE} source code to uncommon or obscure built-in language functionality e.g. stand library calls, opcode, etc. that you do not understand and may be present in a language reference manual?
+
+If so, return a short, comma-separated list of functions or opcodes to reference the manual for. Do not return any basic language functionality.
+
+If not, return 'NODOCS'. 'NODOCS' must be returned on its own without further commentary.
+
+Here is the code:
+```
+{SOURCE_CODE}
+```

janus/prompts/templates/retrieval/language_docs/system.txt

@@ -0,0 +1 @@
+You are a software engineer and quality control professional tasked with providing context to source code by suggesting aspects of the code which could be made more clear by referencing a language manual. Given some source code, it is your job to pick out standard library calls or instructions which could be clarified with a reference. If there are no such code features, you may skip with process with the response "NODOCS".

janus/prompts/templates/simple/human.txt

@@ -0,0 +1,16 @@
+Please convert the following {SOURCE_LANGUAGE} .{FILE_SUFFIX} code found in between triple backticks
+into {TARGET_LANGUAGE} code.
+
+If the given code is incomplete, assume it is translated elsewhere.
+If the given code is missing variable definitions, assume they are assigned elsewhere.
+If there are incomplete statements that haven't been closed out, assume they are closed out in other translations.
+If the code has comments, keep ALL of them.
+If it only consists of ONLY comments, assume the code that is represented by those comments is translated elsewhere.
+
+Some more things to remember:
+(1) follow standard styling practice for the target language
+(2) make sure the language is typed correctly
+
+```
+{SOURCE_CODE}
+```

janus/prompts/templates/simple/system.txt

@@ -0,0 +1,3 @@
+Your purpose is to convert {SOURCE_LANGUAGE} {FILE_SUFFIX} code
+into runnable {TARGET_LANGUAGE} code ({TARGET_LANGUAGE} version
+{TARGET_LANGUAGE_VERSION}).

janus/refiners/format.py

@@ -0,0 +1,49 @@
+from typing import Any
+
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.prompt_values import PromptValue
+from langchain_core.runnables import RunnableSerializable
+
+from janus.llm.models_info import MODEL_PROMPT_ENGINES, JanusModel
+from janus.parsers.parser import JanusParser
+from janus.refiners.refiner import JanusRefiner
+
+
+class FormatRefiner(JanusRefiner):
+    format_chain: RunnableSerializable
+
+    def __init__(
+        self,
+        llm: JanusModel,
+        parser: JanusParser,
+        max_retries: int,
+        prompt_template_name: str,
+    ):
+        format_prompt = MODEL_PROMPT_ENGINES[llm.short_model_id](
+            source_language="text",
+            prompt_template=prompt_template_name,
+        ).prompt
+        format_chain = format_prompt | llm | StrOutputParser()
+        super().__init__(
+            format_chain=format_chain, parser=parser, max_retries=max_retries
+        )
+
+    def parse_completion(
+        self, completion: str, prompt_value: PromptValue, **kwargs
+    ) -> Any:
+        completion = self.format_chain.invoke(
+            dict(completion=completion, prompt=prompt_value.to_string())
+        )
+        return self.parser.parse(completion)
+
+
+class CodeFormatRefiner(FormatRefiner):
+    def __init__(self, llm: JanusModel, parser: JanusParser, max_retries: int):
+        super().__init__(llm, parser, max_retries, "refinement/format/code_format")
+
+
+class RequirementsFormatRefiner(FormatRefiner):
+    def __init__(self, llm: JanusModel, parser: JanusParser, max_retries: int):
+        super().__init__(
+            llm, parser, max_retries, "refinement/format/requirements_format"
+        )