1bcoder 0.1.18__tar.gz → 0.1.19__tar.gz

{1bcoder-0.1.18 → 1bcoder-0.1.19}/1bcoder.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: 1bcoder
-Version: 0.1.18
+Version: 0.1.19
 Summary: AI coding assistant agent for 1B–7B local models (Ollama, LMStudio, llama.cpp). Terminal REPL with file editing, project map, agents, scripts, and parallel multi-model queries.
 Project-URL: Homepage, https://github.com/szholobetsky/1bcoder
 Project-URL: Repository, https://github.com/szholobetsky/1bcoder

{1bcoder-0.1.18 → 1bcoder-0.1.19}/1bcoder.egg-info/SOURCES.txt

@@ -27,6 +27,22 @@ _bcoder_data/agents/scan.txt
 _bcoder_data/agents/sqlite.txt
 _bcoder_data/agents/terminator.txt
 _bcoder_data/agents/websearch.txt
+_bcoder_data/deepagent_code/java_decompose.txt
+_bcoder_data/deepagent_code/java_implement.txt
+_bcoder_data/deepagent_code/js_decompose.txt
+_bcoder_data/deepagent_code/js_implement.txt
+_bcoder_data/deepagent_code/kt_decompose.txt
+_bcoder_data/deepagent_code/kt_implement.txt
+_bcoder_data/deepagent_code/mysql_decompose.txt
+_bcoder_data/deepagent_code/mysql_implement.txt
+_bcoder_data/deepagent_code/plsql_decompose.txt
+_bcoder_data/deepagent_code/plsql_implement.txt
+_bcoder_data/deepagent_code/py_decompose.txt
+_bcoder_data/deepagent_code/py_implement.txt
+_bcoder_data/deepagent_code/scala_decompose.txt
+_bcoder_data/deepagent_code/scala_implement.txt
+_bcoder_data/deepagent_code/sql_decompose.txt
+_bcoder_data/deepagent_code/sql_implement.txt
 _bcoder_data/doc/FLOWS.md
 _bcoder_data/doc/MCP.md
 _bcoder_data/doc/OLLAMA_SERVER_PARAM.md
@@ -36,7 +52,9 @@ _bcoder_data/doc/TRANSLATE.md
 _bcoder_data/flows/commit_message.py
 _bcoder_data/flows/compress.py
 _bcoder_data/flows/deepagent.py
+_bcoder_data/flows/deepagent_code.py
 _bcoder_data/flows/deepagent_md.py
+_bcoder_data/flows/deepagent_test.py
 _bcoder_data/flows/deobfuscate.py
 _bcoder_data/flows/external_help.py
 _bcoder_data/flows/grounding.py
@@ -51,7 +69,9 @@ _bcoder_data/flows/webask.py
 _bcoder_data/flows/webcrawl.py
 _bcoder_data/flows/webindex.py
 _bcoder_data/flows/__pycache__/commit_message.cpython-311.pyc
+_bcoder_data/flows/__pycache__/deepagent_code.cpython-311.pyc
 _bcoder_data/flows/__pycache__/deepagent_md.cpython-311.pyc
+_bcoder_data/flows/__pycache__/deepagent_test.cpython-311.pyc
 _bcoder_data/flows/__pycache__/rag.cpython-311.pyc
 _bcoder_data/flows/__pycache__/webcrawl.cpython-311.pyc
 _bcoder_data/proc/action-required.py

{1bcoder-0.1.18 → 1bcoder-0.1.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: 1bcoder
-Version: 0.1.18
+Version: 0.1.19
 Summary: AI coding assistant agent for 1B–7B local models (Ollama, LMStudio, llama.cpp). Terminal REPL with file editing, project map, agents, scripts, and parallel multi-model queries.
 Project-URL: Homepage, https://github.com/szholobetsky/1bcoder
 Project-URL: Repository, https://github.com/szholobetsky/1bcoder

1bcoder-0.1.19/_bcoder_data/deepagent_code/java_decompose.txt

@@ -0,0 +1,41 @@
+You have a team of programmers. Each one will implement exactly one method.
+Your job is to write the MAIN method that USES their methods.
+
+Imagine all helper methods are ALREADY IMPLEMENTED by your team.
+You don't know HOW they work inside. You just know what they accept and return.
+Your job: call them in the right order, pass the right data between them.
+
+RULES:
+- Each helper call: Type result = helperName(args);  // one-line description
+- Do NOT implement the helpers. They already exist. Just USE them.
+- You CAN use loops, if-statements, try/catch, variables — any Java you need.
+- But heavy logic should go INTO a helper method, not into this method.
+- Output ONLY the code in a single code fence.
+
+EXAMPLE — task: "process batch of user registrations"
+
+```java
+public class RegistrationService {
+    public Map<String, Object> processBatch(String usersFile) {
+        List<Map<String, String>> users = readUsersFromFile(usersFile);  // parse CSV into list of maps
+        Map<String, Object> report = new HashMap<>();
+        report.put("success", 0);
+        report.put("failed", 0);
+        for (Map<String, String> user : users) {
+            ValidationResult vr = validateUser(user);  // check required fields
+            if (!vr.isValid()) {
+                report.put("failed", (int) report.get("failed") + 1);
+                continue;
+            }
+            UserRecord record = createUserRecord(user);  // insert into database
+            String token = generateConfirmationToken(record);  // create email token
+            sendConfirmationEmail(record, token);  // send welcome email
+            report.put("success", (int) report.get("success") + 1);
+        }
+        saveReport(report);  // write report to file
+        return report;
+    }
+}
+```
+
+Now do the same for the task below.

1bcoder-0.1.19/_bcoder_data/deepagent_code/java_implement.txt

@@ -0,0 +1,5 @@
+You are implementing a single Java method.
+Write ONLY the method with its body. Keep it to 5-15 lines.
+Include necessary imports at the top.
+Do not call undefined helper methods — use only JDK standard library.
+Output ONLY the code in a single code fence.

1bcoder-0.1.19/_bcoder_data/deepagent_code/js_decompose.txt

@@ -0,0 +1,43 @@
+You have a team of programmers. Each one will implement exactly one function.
+Your job is to write the MAIN function that USES their functions.
+
+Imagine all helper functions are ALREADY IMPLEMENTED by your team.
+You don't know HOW they work inside. You just know what they accept and return.
+Your job: call them in the right order, pass the right data between them.
+
+RULES:
+- Each helper call: const result = helperName(args);  // one-line description
+- Do NOT implement the helpers. They already exist. Just USE them.
+- You CAN use loops, if-statements, try/catch, variables — any JavaScript you need.
+- But heavy logic should go INTO a helper function, not into this function.
+- Use async/await if the helpers might be async.
+- Output ONLY the code in a single code fence.
+
+EXAMPLE — task: "process batch of user registrations"
+
+```javascript
+async function processBatch(usersFile) {
+    const users = readUsersFromFile(usersFile);  // parse CSV file into array of objects
+    const report = { success: 0, failed: 0, errors: [] };
+    for (const user of users) {
+        const [valid, errors] = validateUser(user);  // check required fields and formats
+        if (!valid) {
+            report.failed++;
+            report.errors.push(errors);
+            continue;
+        }
+        const record = await createUserRecord(user);  // insert into database
+        const token = generateConfirmationToken(record);  // create email token
+        await sendConfirmationEmail(record, token);  // send welcome email
+        report.success++;
+    }
+    await saveReport(report);  // write report to file
+    return report;
+}
+```
+
+The programmer who writes validateUser will handle all validation details.
+The programmer who writes createUserRecord will handle the database.
+You just wire them together.
+
+Now do the same for the task below.

1bcoder-0.1.19/_bcoder_data/deepagent_code/js_implement.txt

@@ -0,0 +1,6 @@
+You are implementing a single JavaScript function.
+Write ONLY the function with its body. Keep it to 5-15 lines.
+Use modern JS: const, arrow functions, async/await where appropriate.
+Use require() for Node.js built-in modules if needed.
+Do not call undefined helper functions — use only built-in or well-known npm modules.
+Output ONLY the code in a single code fence. No explanations before or after.

1bcoder-0.1.19/_bcoder_data/deepagent_code/kt_decompose.txt

@@ -0,0 +1,38 @@
+You have a team of programmers. Each one will implement exactly one function.
+Your job is to write the MAIN function that USES their functions.
+
+Imagine all helper functions are ALREADY IMPLEMENTED by your team.
+You don't know HOW they work inside. You just know what they accept and return.
+Your job: call them in the right order, pass the right data between them.
+
+RULES:
+- Each helper call: val result = helperName(args)  // one-line description
+- Do NOT implement the helpers. They already exist. Just USE them.
+- You CAN use loops, if, when, try/catch, variables — any Kotlin you need.
+- But heavy logic should go INTO a helper function, not into this function.
+- Use Kotlin idioms: val/var, data classes, nullable types where appropriate.
+- Output ONLY the code in a single code fence.
+
+EXAMPLE — task: "process batch of user registrations"
+
+```kotlin
+fun processBatch(usersFile: String): Map<String, Any> {
+    val users = readUsersFromFile(usersFile)  // parse CSV into list of maps
+    val report = mutableMapOf<String, Any>("success" to 0, "failed" to 0)
+    for (user in users) {
+        val (valid, errors) = validateUser(user)  // check required fields
+        if (!valid) {
+            report["failed"] = (report["failed"] as Int) + 1
+            continue
+        }
+        val record = createUserRecord(user)  // insert into database
+        val token = generateConfirmationToken(record)  // create email token
+        sendConfirmationEmail(record, token)  // send welcome email
+        report["success"] = (report["success"] as Int) + 1
+    }
+    saveReport(report)  // write report to file
+    return report
+}
+```
+
+Now do the same for the task below.

1bcoder-0.1.19/_bcoder_data/deepagent_code/kt_implement.txt

@@ -0,0 +1,6 @@
+You are implementing a single Kotlin function.
+Write ONLY the function with its body. Keep it to 5-15 lines.
+Use Kotlin idioms: val, data classes, extension functions, nullable types.
+Include necessary imports at the top.
+Do not call undefined helper functions — use only Kotlin stdlib.
+Output ONLY the code in a single code fence.

1bcoder-0.1.19/_bcoder_data/deepagent_code/mysql_decompose.txt

@@ -0,0 +1,20 @@
+You are a MySQL database architect writing stored procedures.
+Your team will create all tables, functions, and procedures you need.
+
+Write MySQL code that USES database objects as if they ALREADY EXIST.
+You don't create them — just reference them in your code.
+
+RULES:
+- Write queries and procedures that reference tables, functions
+- Add a comment above each block explaining what it does
+- Do NOT write CREATE statements. Just USE the objects.
+- You CAN use cursors, loops, IF/THEN, CASE — any MySQL you need.
+- But complex calculations should be in a FUNCTION, not inline.
+- Use MySQL syntax (DELIMITER, BEGIN/END).
+- Output ONLY the code in a single code fence.
+
+The team who writes each table will define all columns.
+The team who writes each function will handle the logic.
+You just write code that uses them.
+
+Now do the same for the task below.

1bcoder-0.1.19/_bcoder_data/deepagent_code/mysql_implement.txt

@@ -0,0 +1,4 @@
+You are implementing a single MySQL database object.
+Write the COMPLETE CREATE statement with full body.
+Use MySQL syntax (DELIMITER, BEGIN/END).
+Output ONLY the code in a single code fence.

1bcoder-0.1.19/_bcoder_data/deepagent_code/plsql_decompose.txt

@@ -0,0 +1,20 @@
+You are an Oracle database architect writing PL/SQL code.
+Your team will create all tables, functions, procedures, and packages you need.
+
+Write PL/SQL that USES database objects as if they ALREADY EXIST.
+You don't create them — just reference them in your code.
+
+RULES:
+- Write queries and PL/SQL blocks that reference tables, functions, procedures
+- Add a comment above each block explaining what it does
+- Do NOT write CREATE statements. Just USE the objects.
+- You CAN use cursors, loops, IF/THEN, exceptions — any PL/SQL you need.
+- But complex calculations should be in a FUNCTION, not inline.
+- Use Oracle PL/SQL syntax.
+- Output ONLY the code in a single code fence.
+
+The team who writes each table will define all columns.
+The team who writes each function will handle the logic.
+You just write code that uses them.
+
+Now do the same for the task below.

1bcoder-0.1.19/_bcoder_data/deepagent_code/plsql_implement.txt

@@ -0,0 +1,4 @@
+You are implementing a single Oracle PL/SQL database object.
+Write the COMPLETE CREATE statement with full body.
+Use Oracle PL/SQL syntax (CREATE OR REPLACE, BEGIN/END, /).
+Output ONLY the code in a single code fence.

1bcoder-0.1.19/_bcoder_data/deepagent_code/py_decompose.txt

@@ -0,0 +1,39 @@
+You have a team of programmers. Each one will implement exactly one function.
+Your job is to write the MAIN function that USES their functions.
+
+Imagine all helper functions are ALREADY IMPLEMENTED by your team.
+You don't know HOW they work inside. You just know what they accept and return.
+Your job: call them in the right order, pass the right data between them.
+
+RULES:
+- Each helper call: result = helper_name(args)  # one-line description
+- Do NOT implement the helpers. They already exist. Just USE them.
+- You CAN use loops, if-statements, try/except, variables — any Python you need.
+- But heavy logic should go INTO a helper function, not into this function.
+- Output ONLY the code in a single code fence.
+
+EXAMPLE — task: "process batch of user registrations"
+
+```python
+def process_batch(users_file: str) -> dict:
+    users = read_users_from_file(users_file)  # parse CSV file into list of dicts
+    report = {"success": 0, "failed": 0, "errors": []}
+    for user in users:
+        valid, errors = validate_user(user)  # check required fields and formats
+        if not valid:
+            report["failed"] += 1
+            report["errors"].append(errors)
+            continue
+        record = create_user_record(user)  # insert into database
+        token = generate_confirmation_token(record)  # create email token
+        send_confirmation_email(record, token)  # send welcome email
+        report["success"] += 1
+    save_report(report)  # write report to file
+    return report
+```
+
+The programmer who writes validate_user will handle all validation details.
+The programmer who writes create_user_record will handle the database.
+You just wire them together.
+
+Now do the same for the task below.

1bcoder-0.1.19/_bcoder_data/deepagent_code/py_implement.txt

@@ -0,0 +1,6 @@
+You are implementing a single Python function.
+Write ONLY the function with its body. Keep it to 5-15 lines.
+Include type hints in the signature.
+Add imports inside the function or at the top if needed.
+Do not call undefined helper functions — use only stdlib or well-known libraries.
+Output ONLY the code in a single code fence. No explanations before or after.

1bcoder-0.1.19/_bcoder_data/deepagent_code/scala_decompose.txt

@@ -0,0 +1,40 @@
+You have a team of programmers. Each one will implement exactly one method.
+Your job is to write the MAIN object/class that USES their methods.
+
+Imagine all helper methods are ALREADY IMPLEMENTED by your team.
+You don't know HOW they work inside. You just know what they accept and return.
+Your job: call them in the right order, pass the right data between them.
+
+RULES:
+- Each helper call: val result = helperName(args)  // one-line description
+- Do NOT implement the helpers. They already exist. Just USE them.
+- You CAN use for/yield, match, if, try/catch — any Scala you need.
+- But heavy logic should go INTO a helper method, not into this method.
+- Use Scala idioms: case classes, Option, immutable vals.
+- Output ONLY the code in a single code fence.
+
+EXAMPLE — task: "process batch of user registrations"
+
+```scala
+object RegistrationService {
+  def processBatch(usersFile: String): Map[String, Any] = {
+    val users = readUsersFromFile(usersFile)  // parse CSV into list of maps
+    var success = 0
+    var failed = 0
+    for (user <- users) {
+      val (valid, errors) = validateUser(user)  // check required fields
+      if (!valid) { failed += 1 }
+      else {
+        val record = createUserRecord(user)  // insert into database
+        val token = generateConfirmationToken(record)  // create email token
+        sendConfirmationEmail(record, token)  // send welcome email
+        success += 1
+      }
+    }
+    saveReport(Map("success" -> success, "failed" -> failed))  // write report
+    Map("success" -> success, "failed" -> failed)
+  }
+}
+```
+
+Now do the same for the task below.

1bcoder-0.1.19/_bcoder_data/deepagent_code/scala_implement.txt

@@ -0,0 +1,6 @@
+You are implementing a single Scala method or object.
+Write ONLY the method/object with its body. Keep it to 5-15 lines.
+Use Scala idioms: case classes, Option, pattern matching, immutability.
+Include necessary imports at the top.
+Do not call undefined helper methods — use only Scala stdlib.
+Output ONLY the code in a single code fence.

1bcoder-0.1.19/_bcoder_data/deepagent_code/sql_decompose.txt

@@ -0,0 +1,46 @@
+You are a database architect writing SQL queries.
+Your team will create all tables, functions, views, and procedures you need.
+
+Write SQL that USES database objects as if they ALREADY EXIST.
+You don't create them — just reference them in your queries.
+
+RULES:
+- Write queries that reference tables, functions, views that your team will create
+- Add a comment above each query explaining what it does
+- Do NOT write CREATE statements. Just USE the objects.
+- You CAN use JOINs, subqueries, WHERE, GROUP BY, HAVING — any SQL you need.
+- But complex calculations should be in a FUNCTION, not inline.
+- Output ONLY the code in a single code fence.
+
+EXAMPLE — task: "find departments where average salary exceeds company median"
+
+```sql
+-- Get company-wide median salary (function handles the calculation)
+-- Uses: median_salary() function, employees table, departments table
+
+-- Main query: departments with above-median average salary
+SELECT
+    d.department_name,
+    AVG(e.salary) AS avg_salary,
+    median_salary() AS company_median    -- function to be implemented
+FROM employees e                         -- table to be created
+JOIN departments d ON e.dept_id = d.id   -- table to be created
+GROUP BY d.department_name
+HAVING AVG(e.salary) > median_salary();
+
+-- Detailed: list overpaid employees in those departments
+SELECT e.employee_name, e.salary, d.department_name
+FROM employees e
+JOIN departments d ON e.dept_id = d.id
+WHERE d.department_name IN (
+    SELECT department_name
+    FROM department_salary_summary    -- view to be created
+    WHERE is_above_median = TRUE
+);
+```
+
+The team who writes the employees table will define all columns.
+The team who writes median_salary() will handle the math.
+You just write queries that use them.
+
+Now do the same for the task below.

1bcoder-0.1.19/_bcoder_data/deepagent_code/sql_implement.txt

@@ -0,0 +1,4 @@
+You are implementing a single SQL database object (table, function, procedure, trigger, or view).
+Write the COMPLETE CREATE statement with full body.
+Use PostgreSQL syntax by default.
+Output ONLY the code in a single code fence.