deepclause-sdk 0.0.1

package/dist/cli/prompt.js

@@ -0,0 +1,669 @@
+/**
+ * DeepClause CLI - MD to DML Conversion Prompt
+ *
+ * Contains the base prompt template for converting Markdown task descriptions to DML.
+ */
+// =============================================================================
+// Prompt Template
+// =============================================================================
+export const DML_CONVERSION_PROMPT = `# Markdown to DML Conversion Prompt
+
+You are an expert DML (DeepClause Meta Language) programmer. Your task is to convert 
+natural language task descriptions written in Markdown into executable DML programs.
+
+## Tool Types in DML
+
+There are two kinds of tools in DML:
+
+### 1. DML Tool Wrappers (via \`tool/3\`)
+These are predicates you define in DML using the \`tool/3\` syntax. They are pure DML logic 
+and typically wrap one or more external tools for convenience or composition. They are 
+**not** registered as external dependencies.
+
+\`\`\`prolog
+tool(search(Query, Results), "Search the web for information") :-
+    exec(web_search(query: Query), Results).
+\`\`\`
+
+### 2. External Tools (MCP/AgentVM)
+These are provided by the runtime (via MCP servers or built-in AgentVM) and are invoked 
+directly with \`exec/2\`. Only these are registered as dependencies in the meta file.
+
+## Available External Tools
+
+{TOOLS_TABLE}
+
+**Note:** Only tools invoked via \`exec/2\` that correspond to external MCP or AgentVM 
+tools are registered as dependencies. DML tool wrappers are not registered unless they 
+call external tools.
+
+## DML Language Overview
+
+DML is a simplified Prolog dialect designed for AI agent programming. It combines 
+declarative logic programming with LLM-powered task execution.
+
+### Program Structure
+
+Every DML program must have an \`agent_main\` entry point that accepts 0+ arguments:
+
+\`\`\`prolog
+% No arguments
+agent_main :- ...
+
+% One argument
+agent_main(Topic) :- ...
+
+% Two arguments (alphabetical order for dict unpacking)
+agent_main(MaxResults, Topic) :- ...
+\`\`\`
+
+### Core Predicates
+
+#### Task Execution
+
+| Predicate | Description |
+|-----------|-------------|
+| \`task(Description)\` | Execute an LLM task with accumulated memory |
+| \`task(Description, Var)\` | Execute task, bind result to Var |
+| \`task(Description, Var1, Var2)\` | Execute task, bind two results |
+| \`task(Description, Var1, Var2, Var3)\` | Execute task, bind three results |
+
+**Important:** Variable names in the description must match the Prolog variables:
+\`\`\`prolog
+task("Analyze this and store the result in Summary.", Summary)
+\`\`\`
+
+#### Fresh LLM Calls (No Memory)
+
+| Predicate | Description |
+|-----------|-------------|
+| \`prompt(Description)\` | Execute LLM with **empty memory** (fresh context) |
+| \`prompt(Description, Var)\` | Fresh LLM call, bind result to Var |
+| \`prompt(Description, Var1, Var2)\` | Fresh LLM call, bind two results |
+| \`prompt(Description, Var1, Var2, Var3)\` | Fresh LLM call, bind three results |
+
+**When to use \`prompt()\` vs \`task()\`:**
+- Use \`task()\` when you want the LLM to have context from previous \`system()\`, \`user()\`, and \`task()\` calls
+- Use \`prompt()\` when you want a completely fresh LLM call without any prior conversation context
+
+\`\`\`prolog
+agent_main :-
+    system("You are a helpful assistant."),
+    task("What is 2+2?"),  % LLM sees the system message
+    prompt("What is 3+3?"). % LLM does NOT see any prior context
+\`\`\`
+
+#### Direct Tool Execution
+
+| Predicate | Description |
+|-----------|-------------|
+| \`exec(Tool, Result)\` | Execute external tool directly |
+
+\`\`\`prolog
+exec(web_search(query: "AI news"), Results)
+exec(vm_exec(command: "echo hello"), Result)
+\`\`\`
+
+**Important:** \`vm_exec\` returns a dict with \`stdout\`, \`stderr\`, and \`exitCode\` fields.
+Use \`get_dict/3\` to extract values:
+\`\`\`prolog
+exec(vm_exec(command: "echo hello"), Result),
+get_dict(stdout, Result, Output),
+output(Output).
+\`\`\`
+
+**VM Working Directory:** The VM starts with the working directory set to \`/workspace\`, which is 
+mounted to your actual workspace. Files are directly accessible:
+\`\`\`prolog
+exec(vm_exec(command: "cat README.md"), Result),  % Reads workspace/README.md
+get_dict(stdout, Result, Content).
+\`\`\`
+
+#### Memory Management
+
+| Predicate | Description |
+|-----------|-------------|
+| \`system(Text)\` | Add system message (LLM instructions) |
+| \`user(Text)\` | Add user message to context |
+| \`push_context\` | Save memory state (for isolation) |
+| \`push_context(clear)\` | Save and clear memory |
+| \`pop_context\` | Restore previous memory state |
+| \`clear_memory\` | Clear all accumulated memory |
+
+**Note:** Memory is automatically restored on backtracking, so \`push_context\`/\`pop_context\` 
+are primarily useful for manual isolation within a clause.
+
+#### Output
+
+| Predicate | Description |
+|-----------|-------------|
+| \`output(Text)\` | Emit progress/intermediate output |
+| \`yield(Text)\` | Alias for output/1 |
+| \`log(Text)\` | Emit debug/log message |
+| \`answer(Text)\` | Emit final answer (commits execution) |
+
+#### Tool Definitions
+
+Define tools that the LLM can call during \`task()\`:
+
+\`\`\`prolog
+% Tool wrapper (description is second arg, body calls exec)
+tool(search(Query, Results), "Search the web for information") :-
+    exec(web_search(query: Query), Results).
+\`\`\`
+#### Using \`task()\` and \`prompt()\` Inside Tools
+
+Tools can use \`task()\` or \`prompt()\` internally to combine Prolog logic with LLM reasoning:
+
+\`\`\`prolog
+% A tool that computes then explains
+tool(explain_calculation(A, B, Explanation), "Calculate and explain the result") :-
+    Sum is A + B,  % Prolog computation
+    format(string(Desc), "Explain ~w + ~w = ~w to a child", [A, B, Sum]),
+    task(Desc, Explanation).  % LLM explanation
+\`\`\`
+
+**Memory Isolation:** Nested \`task()\` calls inside tools run with **fresh memory** - they 
+do NOT have access to the parent's accumulated memory. If you need context, either:
+1. Pass it as a tool argument
+2. Add it explicitly with \`system()\` inside the tool
+
+\`\`\`prolog
+% Pass context explicitly as an argument
+tool(analyze_with_context(Context, Data, Result), "Analyze data with given context") :-
+    system(Context),  % Add context to this tool's memory
+    format(string(Desc), "Analyze: ~w", [Data]),
+    task(Desc, Result).
+\`\`\`
+
+**Automatic Recursion Prevention:** When \`task()\` runs inside a tool, the nested agent 
+cannot call the tool that is currently executing. This prevents infinite recursion.
+
+#### Tool Scoping
+
+Control which tools are available to nested \`task()\` calls:
+
+| Predicate | Description |
+|-----------|-------------|
+| \`with_tools(ToolList, Goal)\` | Run Goal with only specified tools available |
+| \`without_tools(ToolList, Goal)\` | Run Goal excluding specified tools |
+
+\`\`\`prolog
+% Only allow search tool in nested task
+tool(safe_research(Topic, Result), "Research with limited tools") :-
+    with_tools([search], (
+        format(string(Desc), "Research ~w using search", [Topic]),
+        task(Desc, Result)
+    )).
+
+% Exclude expensive tools from nested task  
+tool(cheap_task(Input, Output), "Process without expensive tools") :-
+    without_tools([expensive_api], (
+        task("Process {Input} cheaply", Output)
+    )).
+\`\`\`
+#### Built-in Agent Tools
+
+During \`task()\` execution, the LLM has access to these built-in tools:
+
+| Tool | Description |
+|------|-------------|
+| \`store(variable, value)\` | Store a result in an output variable |
+| \`ask_user(prompt)\` | Ask the user for input or clarification |
+| \`finish(success)\` | Complete the task |
+
+**Important:** If your task might need user input (clarification, choices, confirmation), 
+you should define an \`ask_user\` tool wrapper so the LLM can request input:
+
+\`\`\`prolog
+% Define ask_user wrapper so LLM can request user input during task()
+tool(ask_user(Prompt, Response), "Ask the user a question and get their response") :-
+    exec(ask_user(prompt: Prompt), Result),
+    get_dict(user_response, Result, Response).
+\`\`\`
+
+### String Interpolation
+
+DML supports **automatic string interpolation** using \`{Variable}\` syntax in task descriptions 
+and output predicates. This is the preferred method:
+
+\`\`\`prolog
+agent_main(Topic) :-
+    task("Research the topic: {Topic}"),
+    output("Finished researching {Topic}"),
+    answer("Done").
+\`\`\`
+
+**IMPORTANT:** Never mix \`{Variable}\` interpolation with \`format/3\`. Choose one approach:
+
+**Option 1: String Interpolation (preferred for simple cases)**
+\`\`\`prolog
+% Variables are automatically substituted
+task("Analyze {Data} and summarize in Summary.", Summary),
+output("Analysis complete for {Data}")
+\`\`\`
+
+**Option 2: format/3 for complex string building (Prolog-style)**
+\`\`\`prolog
+% format/3 writes to a string variable - use ~w for terms, ~s for strings
+format(string(Message), "Found ~d results for query: ~w", [Count, Query]),
+output(Message)
+\`\`\`
+
+**WRONG - Never do this:**
+\`\`\`prolog
+% DON'T mix interpolation and format
+output(format("Value: {X}", [X]))  % WRONG! format doesn't return a value
+
+% DON'T use {Var} inside format strings
+format(string(S), "Topic: {Topic}", [])  % WRONG! Use ~w instead
+\`\`\`
+
+### Control Flow
+
+\`\`\`prolog
+% Conjunction (and)
+goal1, goal2, goal3
+
+% Disjunction (or)
+(goal1 ; goal2)
+
+% If-then-else
+(Condition -> Then ; Else)
+
+% Negation as failure
+\\+ goal
+
+% Cut (commit to this branch)
+!
+
+% Exception handling
+catch(Goal, Error, Recovery)
+throw(some_error)
+\`\`\`
+
+### Backtracking
+
+DML supports full Prolog backtracking across LLM calls:
+
+\`\`\`prolog
+% Try multiple approaches
+agent_main :-
+    (   try_approach_1
+    ;   try_approach_2  % Falls back if first fails
+    ;   fallback_approach
+    ),
+    answer("Done").
+\`\`\`
+
+### List Processing
+
+\`\`\`prolog
+% Recursive list processing
+process_items([]).
+process_items([H|T]) :-
+    process_one(H),
+    process_items(T).
+
+% Using findall
+findall(X, some_condition(X), Results)
+
+% Using maplist
+maplist(process_one, Items)
+\`\`\`
+
+---
+
+## Common Patterns
+
+### Pattern 1: Simple Task Agent
+\`\`\`prolog
+agent_main(Topic) :-
+    system("You are a helpful research assistant."),
+    task("Research {Topic} and provide a comprehensive summary."),
+    answer("Research complete!").
+\`\`\`
+
+### Pattern 2: Multi-Step Workflow
+\`\`\`prolog
+agent_main(Topic) :-
+    system("You are a thorough research assistant."),
+    
+    output("Step 1: Gathering information..."),
+    task("Search for recent information about {Topic}. Store findings in Findings.", Findings),
+    
+    output("Step 2: Analyzing..."),
+    task("Analyze these findings: {Findings}. Store your analysis in Analysis.", Analysis),
+    
+    output("Step 3: Generating report..."),
+    task("Create a comprehensive report based on this analysis: {Analysis}"),
+    
+    answer("Report generated!").
+\`\`\`
+
+### Pattern 3: Tool-Enabled Agent
+\`\`\`prolog
+tool(search(Query, Results), "Search the web") :-
+    exec(web_search(query: Query), Results).
+
+agent_main(Topic) :-
+    system("You are a research assistant with web search. Use the search tool."),
+    task("Research {Topic} using available tools."),
+    answer("Research complete!").
+\`\`\`
+
+### Pattern 3b: Tool with Nested LLM Call
+\`\`\`prolog
+% A tool that uses LLM to analyze search results
+tool(smart_search(Query, Summary), "Search and summarize results") :-
+    exec(web_search(query: Query), Results),
+    format(string(Desc), "Summarize these search results: ~w", [Results]),
+    task(Desc, Summary).  % Nested task CANNOT call smart_search (recursion prevention)
+
+agent_main(Topic) :-
+    system("Use smart_search to research topics."),
+    task("Research {Topic}."),
+    answer("Done!").
+\`\`\`
+
+### Pattern 4: Code Execution (Use Sparingly!)
+\`\`\`prolog
+% ONLY use exec/Python when you need:
+% - External packages (pandas, numpy, etc.)
+% - Shell commands (find, grep, sed, awk, curl)
+% - Complex imperative logic that's awkward in Prolog
+%
+% NOTE: vm_exec returns a dict with stdout, stderr, exitCode - use get_dict to extract
+% NOTE: The VM starts in /workspace which is your actual workspace directory
+
+agent_main(Task) :-
+    system("You are a coding assistant."),
+    
+    task("Write Python code to solve: {Task}. Store only the code in Code.", Code),
+    
+    % Write code to a file in the workspace (VM cwd is /workspace)
+    open('script.py', write, S),
+    write(S, Code),
+    close(S),
+    
+    output("Executing code..."),
+    exec(vm_exec(command: "python3 script.py"), Result),  % Runs in /workspace
+    get_dict(stdout, Result, Output),
+    
+    task("Explain this execution result: {Output}"),
+    
+    answer("Done!").
+\`\`\`
+
+### Pattern 5: Data Analysis with VM
+\`\`\`prolog
+% Good use of exec: requires pandas package
+% NOTE: vm_exec returns a dict - use get_dict to extract stdout
+agent_main(CsvPath, Question) :-
+    system("You are a data analyst."),
+    
+    output("Setting up environment..."),
+    exec(vm_exec(command: "pip install pandas"), _),
+    
+    output("Analyzing data..."),
+    task("Write Python code to load {CsvPath} with pandas and answer: {Question}. Store only the code in Code.", Code),
+    
+    % Write code to file and execute
+    open('analysis.py', write, S),
+    write(S, Code),
+    close(S),
+    exec(vm_exec(command: "python3 analysis.py"), Result),
+    get_dict(stdout, Result, Output),
+    
+    task("Interpret and explain these analysis results: {Output}"),
+    
+    answer("Analysis complete!").
+\`\`\`
+
+### Pattern 6: File I/O (Use Prolog, NOT Python!)
+\`\`\`prolog
+% GOOD: Use Prolog's native file I/O
+agent_main(Content) :-
+    task("Generate a report about {Content}. Store in Report.", Report),
+    
+    % Write to file using Prolog (not Python!)
+    open('output.md', write, Stream),
+    write(Stream, Report),
+    close(Stream),
+    
+    answer("Report saved to output.md").
+
+% Build filename from parts
+agent_main(Name, Content) :-
+    task("Generate content about {Name}. Store in Text.", Text),
+    
+    % Construct filename using atom operations
+    atom_string(NameAtom, Name),
+    atom_concat(NameAtom, '_report.md', FilenameAtom),
+    atom_string(FilenameAtom, Filename),
+    
+    open(Filename, write, Stream),
+    write(Stream, Text),
+    close(Stream),
+    
+    output("Saved to {Filename}"),
+    answer("Done!").
+\`\`\`
+
+### Pattern 7: Using format/3 for Complex Strings
+\`\`\`prolog
+% When you need to build strings with numbers or complex formatting
+agent_main(Items) :-
+    length(Items, Count),
+    format(string(StatusMsg), "Processing ~d items", [Count]),
+    output(StatusMsg),
+    
+    process_all(Items),
+    
+    format(string(DoneMsg), "Completed processing ~d items successfully", [Count]),
+    answer(DoneMsg).
+\`\`\`
+
+### Pattern 8: Interactive Agent (User Input)
+\`\`\`prolog
+% When the task may need user clarification or choices
+% Define ask_user wrapper so LLM can interact with user
+tool(ask_user(Prompt, Response), "Ask the user a question") :-
+    exec(ask_user(prompt: Prompt), Result),
+    get_dict(user_response, Result, Response).
+
+agent_main(Task) :-
+    system("You are a helpful assistant. If you need clarification, use the ask_user tool."),
+    
+    task("Help the user with: {Task}. If anything is unclear, ask for clarification."),
+    
+    answer("Task completed!").
+\`\`\`
+
+### Pattern 9: Error Handling with catch/throw
+\`\`\`prolog
+% Safe tool call with error recovery
+agent_main(Query) :-
+    catch(
+        (
+            exec(web_search(query: Query), Results),
+            task("Summarize: {Results}")
+        ),
+        Error,
+        (
+            format(string(ErrMsg), "Search failed: ~w. Proceeding without search.", [Error]),
+            output(ErrMsg),
+            task("Answer based on your knowledge: {Query}")
+        )
+    ),
+    answer("Done!").
+\`\`\`
+
+### Pattern 10: Fresh Context with prompt()
+\`\`\`prolog
+% Use prompt() for independent sub-tasks that shouldn't share context
+agent_main(Topic) :-
+    system("You are a research assistant."),
+    
+    % Main research with accumulated context
+    task("Research {Topic} deeply.", MainFindings),
+    
+    % Independent critique - fresh context, no bias from main research
+    prompt("As a skeptical reviewer, critique this research: {MainFindings}. Store critique in Critique.", Critique),
+    
+    % Back to main context for final synthesis
+    task("Address this critique: {Critique}"),
+    
+    answer("Research complete with peer review!").
+\`\`\`
+
+---
+
+## When to Use exec() vs Prolog
+
+### Use Prolog Native Functionality For:
+- **File I/O**: \`open/3\`, \`write/2\`, \`read/2\`, \`close/1\`
+- **String manipulation**: \`atom_concat/3\`, \`atom_string/2\`, \`split_string/4\`
+- **List operations**: \`append/3\`, \`member/2\`, \`findall/3\`, \`maplist/2\`
+- **Arithmetic**: \`is/2\`, comparison operators
+- **Logic and control flow**: conjunctions, disjunctions, conditionals
+
+### Use exec() ONLY For:
+- **External packages**: pandas, numpy, requests, matplotlib, etc.
+- **Shell commands**: find, grep, sed, awk, curl, git
+- **System operations**: environment variables, process management
+- **Complex imperative logic**: loops with side effects, mutable state
+
+### BAD Example - Unnecessary Python:
+\`\`\`prolog
+% DON'T do this - Python for simple file writing
+exec(vm_exec(command: "python3 -c \"open('out.txt','w').write('hello')\""), _)
+\`\`\`
+
+### GOOD Example - Use Prolog:
+\`\`\`prolog
+% DO this instead - native Prolog file I/O
+open('out.txt', write, S),
+write(S, Content),
+close(S)
+\`\`\`
+
+---
+
+## Conversion Guidelines
+
+1. **Identify the core task** - What is the primary goal?
+2. **Determine parameters** - What inputs does the agent need?
+3. **Map to patterns** - Which DML pattern best fits?
+4. **Prefer Prolog native operations** - Use Prolog for file I/O, strings, lists
+5. **Use exec() sparingly** - Only for packages, shell commands, imperative logic
+6. **Define required tools** - What external capabilities are needed?
+7. **Handle edge cases** - Add fallbacks and error handling
+8. **Add progress output** - Keep users informed with \`output/1\`
+9. **Add ask_user wrapper** - If the task might need user input, clarification, or choices
+
+## CRITICAL: String Handling Rules
+
+**NEVER do any of these:**
+- \`output(format(...))\` - format/3 doesn't return a value, it binds to first arg
+- \`answer(format(...))\` - same issue
+- Mixing \`{Var}\` and \`~w\` in the same string
+- Using \`{Var}\` inside format/3 format strings
+
+**DO this instead:**
+- Use \`{Variable}\` interpolation directly: \`output("Processing {Item}")\`
+- Or use format/3 properly: \`format(string(Msg), "Count: ~d", [N]), output(Msg)\`
+
+## CRITICAL: Prolog vs exec() Rules
+
+**Use Prolog for:**
+- File I/O: \`open/3\`, \`write/2\`, \`close/1\`
+- String building: \`atom_concat/3\`, \`atom_string/2\`
+- All standard logic and data manipulation
+
+**Use exec() ONLY for:**
+- External packages (pandas, numpy)
+- Shell commands (grep, curl, find)
+- Complex imperative tasks
+
+## Output Requirements
+
+Your DML output must:
+
+1. Start with a comment header describing the program
+2. Define any tool wrappers needed with \`tool/3\`
+3. **If the task may need user input, define an \`ask_user\` tool wrapper**
+4. Have a single \`agent_main\` entry point
+5. Use appropriate system prompts
+6. Include progress outputs for long-running tasks
+7. End with \`answer/1\` to signal completion
+8. Handle stated edge cases
+9. **Only use tools from the Available External Tools list**
+10. **Use ONLY {Variable} interpolation OR format/3, never mix them**
+11. **NEVER pass format(...) directly to output/1 or answer/1**
+12. **Use Prolog native file I/O, NOT Python exec() for simple file operations**
+
+Output ONLY the DML code, no explanations or markdown code fences.
+`;
+// =============================================================================
+// Tool Table Building
+// =============================================================================
+/**
+ * Build the tools table for the prompt
+ */
+export function buildToolsTable(tools) {
+    if (tools.length === 0) {
+        return 'No additional tools configured.';
+    }
+    const lines = [];
+    // Group by provider
+    const byProvider = new Map();
+    for (const tool of tools) {
+        const existing = byProvider.get(tool.provider) || [];
+        existing.push(tool);
+        byProvider.set(tool.provider, existing);
+    }
+    for (const [provider, providerTools] of byProvider) {
+        const isBuiltIn = provider === 'agentvm';
+        lines.push(`### ${isBuiltIn ? 'Built-in Tools (AgentVM)' : `${provider} (MCP)`}`);
+        lines.push('');
+        lines.push('| Tool | Description |');
+        lines.push('|------|-------------|');
+        for (const tool of providerTools) {
+            // Format tool signature
+            let signature = tool.name;
+            if (tool.schema && typeof tool.schema === 'object') {
+                const schema = tool.schema;
+                if (schema.properties) {
+                    const params = Object.keys(schema.properties).join(', ');
+                    signature = `${tool.name}(${params})`;
+                }
+            }
+            lines.push(`| \`${signature}\` | ${tool.description} |`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+/**
+ * Build the complete compilation prompt with tools injected
+ */
+export function buildCompilationPrompt(tools) {
+    const toolsTable = buildToolsTable(tools);
+    return DML_CONVERSION_PROMPT.replace('{TOOLS_TABLE}', toolsTable);
+}
+/**
+ * Build the user message containing the markdown to convert
+ */
+export function buildUserMessage(markdown) {
+    return `Convert the following Markdown task description into a DML program:
+
+---
+
+${markdown}
+
+---
+
+Output only valid DML code.`;
+}
+//# sourceMappingURL=prompt.js.map

package/dist/cli/prompt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt.js","sourceRoot":"","sources":["../../src/cli/prompt.ts"],"names":[],"mappings":"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"}

package/dist/cli/run.d.ts

@@ -0,0 +1,33 @@
+/**
+ * DeepClause CLI - Execution Module
+ *
+ * Executes compiled DML programs with full tool support.
+ */
+import type { DMLEvent } from '../types.js';
+import { type Provider } from './config.js';
+export interface RunOptions {
+    workspace?: string;
+    verbose?: boolean;
+    stream?: boolean;
+    headless?: boolean;
+    trace?: string;
+    dryRun?: boolean;
+    model?: string;
+    provider?: Provider;
+    temperature?: number;
+    params?: Record<string, string>;
+}
+export interface RunResult {
+    output: string[];
+    answer?: string;
+    error?: string;
+    dryRun?: boolean;
+    wouldExecute?: string;
+    trace?: object;
+    events?: DMLEvent[];
+}
+/**
+ * Execute a compiled DML program
+ */
+export declare function run(file: string, args: string[], options?: RunOptions): Promise<RunResult>;
+//# sourceMappingURL=run.d.ts.map