deepclause-sdk 0.0.88 → 0.1.0

package/dist/system/assets/skills/deep-planner.dml

@@ -1,412 +0,0 @@
-% Deep planner — generates a multi-strategy DML plan with k agent_main clauses.
-% Prolog backtracking tries strategies one by one; answer/1 commits on success.
-
-tool(consult_recipes(Query, Result),
-     "Search the recipe library for workflow guidance, conventions, and reusable approaches relevant to the requested plan.") :-
-    exec(consult_recipes(query: Query, max_results: 3), Result).
-
-tool(search_web(Query, Results),
-     "Search the web for current documentation, examples, and implementation guidance relevant to the requested plan.") :-
-    exec(web_search(query: Query), Results).
-
-tool(fetch_url(Url, Content),
-     "Fetch the text content of a web page by URL for focused documentation research.") :-
-    exec(url_fetch(url: Url), Result),
-    get_dict(body, Result, Content).
-
-tool(download_file(Url, FilePath, Size), "Download a file from a URL and save it to disk. Returns the file path and size.") :-
-    exec(url_fetch(url: Url, save_to: FilePath), Result),
-    get_dict(file_path, Result, FilePath),
-    get_dict(size, Result, Size).
-
-tool(run_bash(Command, Output), "Run a shell command in the workspace.") :-
-    exec(bash(command: Command), Output).
-
-tool(list_skills(Skills),
-     "List reusable local skills in the current workspace catalog before reinventing an existing capability.") :-
-    exec(list_skills, Skills).
-
-tool(run_skill(Slug, Args, Result),
-     "Run an existing local child skill when it can help produce a better plan. Args is a JSON array of arguments.") :-
-    exec(run_skill(slug: Slug, args: Args), Result).
-
-tool(ask_user(Prompt, Response),
-    "Ask the user for clarification, plan preferences, revisions, or approval during plan creation.") :-
-    exec(ask_user(prompt: Prompt), Result),
-    get_dict(user_response, Result, Response).
-
-agent_main(Request) :-
-    load_dml_reference(DmlReference),
-    load_dml_compiler_prompt(CompilerPrompt),
-    load_coding_workflow_recipe(CodingWorkflowRecipe),
-    resolve_model_info(ModelId, Complexity, Reasoning, TaskCount),
-    format(string(SystemPrompt), "You create multi-strategy execution plans for DeepClause.
-
-Current user request:
-~w
-
-A multi-strategy plan contains multiple agent_main clauses. Prolog tries them in order — if the first strategy's tasks fail, it backtracks and tries the next strategy. answer/1 commits on success.
-
-Your job:
-1. Generate a short slug for the plan file.
-2. Generate ~w fundamentally different strategies for the request.
-3. For each strategy, generate a task list with tool assignments, reasoning effort, and recipe queries.
-4. The assembler will create a DML file with one agent_main clause per strategy, plus a fallback.
-
-Rules:
-- Each strategy must use a genuinely different approach or architecture.
-- Each strategy needs 3 to 8 focused tasks.
-- Tasks should be plain natural-language execution steps, not code.
-- If the model supports reasoning, assign reasoning effort per task.
-- The generated plan uses with_tools, with_reasoning, and with_recipe for scoping.
-
-DML language reference:
-
-~s
-
-DML compiler guidance:
-
-~s", [Request, TaskCount, DmlReference, CompilerPrompt]),
-    system(SystemPrompt),
-
-    task("Create a short file-safe slug for this request: '{Request}'.
-Requirements:
-- lowercase letters, digits, and underscores only
-- 2 to 6 words when possible
-- no file extension
-Store only the slug in PlanSlug.", string(PlanSlug)),
-
-    generate_strategies(Request, TaskCount, Strategies),
-
-    generate_all_strategy_tasks(Request, Strategies, StrategyPlans),
-
-    make_directory_path('plans'),
-    format(string(FilePath), "plans/~w.dml", [PlanSlug]),
-
-    build_review_message(FilePath, StrategyPlans, ReviewMessage),
-    output(ReviewMessage),
-
-    output("Assembling multi-strategy plan file..."),
-    assemble_multi_strategy_dml(StrategyPlans, CodingWorkflowRecipe, PlanDml),
-    exec(write_file(path: FilePath, content: PlanDml), _),
-    exec(validate_dml(dml_file: FilePath), ValidationResult),
-    finish_plan_creation(FilePath, PlanSlug, ValidationResult, ReviewMessage).
-
-%% resolve_model_info(-ModelId, -Complexity, -Reasoning, -TaskCount)
-resolve_model_info(ModelId, Complexity, Reasoning, TaskCount) :-
-    (   catch(
-            (   param(model_info, ModelInfo),
-                is_dict(ModelInfo),
-                get_dict(modelId, ModelInfo, ModelId),
-                (   get_dict(complexity, ModelInfo, C) -> Complexity = C ; Complexity = medium ),
-                (   get_dict(reasoning, ModelInfo, R), R == true -> Reasoning = true ; Reasoning = false )
-            ),
-            _,
-            fail
-        )
-    ->  true
-    ;   ModelId = "unknown",
-        Complexity = medium,
-        Reasoning = false
-    ),
-    task_count_for_complexity(Complexity, TaskCount).
-
-task_count_for_complexity("high", "3").
-task_count_for_complexity("medium", "3").
-task_count_for_complexity("low", "3").
-task_count_for_complexity(high, "3").
-task_count_for_complexity(medium, "3").
-task_count_for_complexity(low, "3").
-
-%% generate_strategies(+Request, +TaskCount, -Strategies)
-%% Generates k strategy descriptions as a list of strings.
-generate_strategies(Request, TaskCount, Strategies) :-
-    task("Generate {TaskCount} fundamentally different strategies for this request:
-
-'{Request}'
-
-Requirements:
-- Each strategy must use a genuinely different approach, architecture, or methodology.
-- For coding tasks: different tech stacks, patterns, or libraries.
-- For non-coding tasks: different analytical frameworks, data sources, or presentation formats.
-- Each strategy should be plausibly capable of solving the request.
-- Return each strategy as a single string: a short name, then a colon, then a brief approach description.
-- One strategy per line.
-
-Store the list of strategy strings in Strategies.", list(string(Strategies))).
-
-%% generate_all_strategy_tasks(+Request, +Strategies, -StrategyPlans)
-%% For each strategy, generates a task list with tool/reasoning/recipe assignments.
-generate_all_strategy_tasks(_Request, [], []).
-generate_all_strategy_tasks(Request, [Strategy|RestStrategies], [plan{strategy: Strategy, steps: Steps}|RestPlans]) :-
-    generate_strategy_tasks(Request, Strategy, Steps),
-    generate_all_strategy_tasks(Request, RestStrategies, RestPlans).
-
-%% generate_strategy_tasks(+Request, +Strategy, -Steps)
-%% Generates tasks for a single strategy with tool assignments.
-generate_strategy_tasks(Request, Strategy, Steps) :-
-    (   param(model_info, ModelInfo)
-    ->  (   get_dict(reasoning, ModelInfo, R), R == true
-        ->  ReasoningNote = "The execution model supports reasoning. Assign reasoning effort per task: none, low, medium, or high."
-        ;   ReasoningNote = "The execution model does not support reasoning. Set reasoning to 'none' for all tasks."
-        )
-    ;   ReasoningNote = "Set reasoning to 'none' for all tasks."
-    ),
-    task("Break this strategy into 3 to 8 focused execution tasks.
-
-Request: {Request}
-Strategy: {Strategy}
-
-Available tools (use ONLY these exact names):
-- run_bash: Run a shell command (file I/O, tests, git, etc.)
-- run_skill: Run an existing local skill
-- consult_recipes: Search recipe library for workflow guidance
-- search_web: Search the web for documentation or examples
-- search_news: Search recent news
-- fetch_url: Fetch a web page by URL
-- download_file: Download a file from a URL
-- create_new_skill: Create a new reusable skill
-- ask_user: Ask the user a clarifying question
-- inform_user: Send a status update
-
-Note: There is no separate save_file or read_file tool. File operations go through run_bash.
-
-{ReasoningNote}
-
-Also specify a recipe query for each task if relevant (NONE otherwise).
-
-Return four ordered lists aligned 1:1:
-- TaskDescriptions: plain task descriptions.
-- ToolSpecs: each item must be either ALL or a comma-separated list of exact tool names from the available tools list above.
-- ReasoningSpecs: each item must be exactly one of none, low, medium, high.
-- RecipeSpecs: each item must be either NONE or a recipe query string.
-
-Store the ordered task descriptions in TaskDescriptions.
-Store the ordered tool specs in ToolSpecs.
-Store the ordered reasoning specs in ReasoningSpecs.
-Store the ordered recipe specs in RecipeSpecs.", list(string(TaskDescriptions)), list(string(ToolSpecs)), list(string(ReasoningSpecs)), list(string(RecipeSpecs))),
-    (   build_plan_steps_from_specs(TaskDescriptions, ToolSpecs, ReasoningSpecs, RecipeSpecs, Steps)
-    ->  true
-    ;   fallback_plan_steps_from_strategy(Strategy, Steps)
-    ).
-
-%% Valid tool names that exist in conductor_tool_definitions
-valid_plan_tool(run_bash).
-valid_plan_tool(run_skill).
-valid_plan_tool(consult_recipes).
-valid_plan_tool(search_web).
-valid_plan_tool(search_news).
-valid_plan_tool(fetch_url).
-valid_plan_tool(download_file).
-valid_plan_tool(create_new_skill).
-valid_plan_tool(ask_user).
-valid_plan_tool(inform_user).
-
-default_plan_tools([run_bash, run_skill, consult_recipes, search_web, search_news, fetch_url, download_file, create_new_skill, ask_user, inform_user]).
-
-build_plan_steps_from_specs([], [], [], [], []).
-build_plan_steps_from_specs([Desc|RestDesc], [ToolSpec|RestTools], [ReasoningSpec|RestReasoning], [RecipeSpec|RestRecipes], [plan_step{description: Desc, tools: Tools, reasoning: Reasoning, recipe: Recipe}|RestSteps]) :-
-    normalize_tools_spec(ToolSpec, Tools),
-    normalize_reasoning_spec(ReasoningSpec, Reasoning),
-    normalize_recipe_spec(RecipeSpec, Recipe),
-    build_plan_steps_from_specs(RestDesc, RestTools, RestReasoning, RestRecipes, RestSteps).
-
-normalize_tools_spec(Raw, Tools) :-
-    format(string(Text), "~w", [Raw]),
-    string_lower(Text, Lower),
-    (   Lower = "all"
-    ->  default_plan_tools(Tools)
-    ;   split_string(Text, ",", " []\t\n", Parts0),
-        include(non_empty_string, Parts0, Parts),
-        findall(ToolAtom,
-            ( member(Part, Parts),
-              tool_name_string_to_atom(Part, ToolAtom),
-              valid_plan_tool(ToolAtom)
-            ),
-            ValidTools),
-        (   ValidTools = []
-        ->  default_plan_tools(Tools)
-        ;   Tools = ValidTools
-        )
-    ).
-
-normalize_reasoning_spec(Raw, Reasoning) :-
-    format(string(Text), "~w", [Raw]),
-    string_lower(Text, Lower),
-    normalize_reasoning_label(Lower, Reasoning).
-
-normalize_reasoning_label("high", "high").
-normalize_reasoning_label("medium", "medium").
-normalize_reasoning_label("low", "low").
-normalize_reasoning_label("none", "none").
-normalize_reasoning_label(_, "none").
-
-normalize_recipe_spec(Raw, Recipe) :-
-    format(string(Text0), "~w", [Raw]),
-    normalize_space(string(Text), Text0),
-    string_lower(Text, Lower),
-    (   Lower = ""
-    ->  Recipe = "none"
-    ;   Lower = "none"
-    ->  Recipe = "none"
-    ;   Recipe = Text
-    ).
-
-tool_name_string_to_atom(Text, Atom) :-
-    string_lower(Text, Lower),
-    atom_string(Atom, Lower).
-
-non_empty_string(Text) :-
-    Text \= "".
-
-%% fallback_plan_steps_from_strategy(+Strategy, -Steps)
-fallback_plan_steps_from_strategy(Strategy, [plan_step{description: Strategy, tools: Tools, reasoning: "none", recipe: "none"}]) :-
-    default_plan_tools(Tools).
-
-%% assemble_multi_strategy_dml(+StrategyPlans, +CodingWorkflowRecipe, -PlanDml)
-assemble_multi_strategy_dml(StrategyPlans, CodingWorkflowRecipe, PlanDml) :-
-    conductor_tool_definitions(ToolBlock),
-    build_strategy_clauses(StrategyPlans, CodingWorkflowRecipe, Clauses),
-    format(string(PlanDml), "% Generated DeepClause multi-strategy plan.~n% Prolog tries strategies in order; answer/1 commits on success.~n~n~s~n~n~s~nagent_main :-~n    answer(\"All strategies failed.\").~n", [ToolBlock, Clauses]).
-
-%% build_strategy_clauses(+StrategyPlans, +CodingWorkflowRecipe, -Clauses)
-build_strategy_clauses([], _, "").
-build_strategy_clauses([Plan|Rest], CodingWorkflowRecipe, Clauses) :-
-    Strategy = Plan.strategy,
-    Steps = Plan.steps,
-    build_system_prompt_for_strategy(Strategy, CodingWorkflowRecipe, SystemPrompt),
-    build_task_lines(Steps, TaskLines),
-    format(string(StratOutput), "Starting strategy: ~w", [Strategy]),
-    format(string(StratAnswer), "Completed via strategy: ~w", [Strategy]),
-    format(string(Clause), "agent_main :-~n    system(~q),~n    output(~q),~n~s    answer(~q).~n~n", [SystemPrompt, StratOutput, TaskLines, StratAnswer]),
-    build_strategy_clauses(Rest, CodingWorkflowRecipe, RestClauses),
-    string_concat(Clause, RestClauses, Clauses).
-
-%% build_system_prompt_for_strategy(+Strategy, +CodingWorkflowRecipe, -SystemPrompt)
-build_system_prompt_for_strategy(Strategy, CodingWorkflowRecipe, SystemPrompt) :-
-    format(string(SystemPrompt), "You are executing a generated DeepClause plan using this strategy:~n~nStrategy: ~w~n~nFollow the DeepClause Coding Workflow:~n- Start from a concrete anchor (file, command, or implementation surface)~n- Read only enough context to form one falsifiable hypothesis~n- Prefer the smallest edit that tests that hypothesis~n- Run the narrowest validation before widening scope~n- If validation fails, repair the same slice before opening new work~n~n~w~n~nScratchpad:~n- Use run_bash to write important findings to .deepclause.tmp/scratchpad.md (append with >>).~n- Record: environment details, what worked, what failed, file paths created, dependencies installed, error messages.~n- If this strategy fails, a different strategy will be tried automatically. The next strategy can read the scratchpad to learn from your attempt.~n- Read the scratchpad at the start: run_bash('cat .deepclause.tmp/scratchpad.md 2>/dev/null || echo empty').~n- Use tools deliberately and consult recipes when relevant.", [Strategy, CodingWorkflowRecipe]).
-
-%% build_task_lines(+PlanSteps, -TaskLines)
-build_task_lines([], "").
-build_task_lines([Step|Rest], TaskLines) :-
-    build_single_task_line(Step, Line),
-    build_task_lines(Rest, RestLines),
-    string_concat(Line, RestLines, TaskLines).
-
-build_single_task_line(Step, Line) :-
-    Desc = Step.description,
-    Tools = Step.tools,
-    Reasoning = Step.reasoning,
-    Recipe = Step.recipe,
-
-    format(string(InnerTask), "with_tools(~w, task(~q))", [Tools, Desc]),
-
-    (   Reasoning \= "none"
-    ->  format(string(WithReasoning), "with_reasoning(~n        ~w~n    , ~w)", [InnerTask, Reasoning])
-    ;   WithReasoning = InnerTask
-    ),
-
-    (   Recipe \= "none"
-    ->  format(string(Line), "    with_recipe(~n        ~w~n    , '~w'),~n", [WithReasoning, Recipe])
-    ;   format(string(Line), "    ~w,~n", [WithReasoning])
-    ).
-
-%% build_review_message(+FilePath, +StrategyPlans, -ReviewMessage)
-build_review_message(FilePath, StrategyPlans, ReviewMessage) :-
-    length(StrategyPlans, Count),
-    build_strategy_review_lines(StrategyPlans, 1, StrategyLines),
-    format(string(ReviewMessage), "Proposed multi-strategy plan~n- Output file: ~w~n- Strategies: ~w~n~n~s", [FilePath, Count, StrategyLines]).
-
-build_strategy_review_lines([], _, "").
-build_strategy_review_lines([Plan|Rest], Num, Lines) :-
-    Strategy = Plan.strategy,
-    Steps = Plan.steps,
-    length(Steps, StepCount),
-    format(string(Current), "~w. ~w (~w tasks)~n", [Num, Strategy, StepCount]),
-    NextNum is Num + 1,
-    build_strategy_review_lines(Rest, NextNum, RestLines),
-    string_concat(Current, RestLines, Lines).
-
-finish_plan_creation(FilePath, PlanSlug, ValidationResult, FinalPlanReview) :-
-    get_dict(valid, ValidationResult, true),
-    output("Multi-strategy plan validated successfully."),
-    format(string(Message), "I've created a multi-strategy plan in ~w.\n\n~s\nRun it with /run ~w or /~w.", [FilePath, FinalPlanReview, FilePath, PlanSlug]),
-    answer(Message).
-
-finish_plan_creation(FilePath, _, ValidationResult, _) :-
-    format(string(Message), "I wrote ~w, but the plan failed validation: ~w", [FilePath, ValidationResult]),
-    answer(Message).
-
-conductor_tool_definitions(ToolBlock) :-
-    atomics_to_string([
-        '% --- Tool predicates (full tool set) ---',
-        '',
-        'tool(run_skill(Slug, Args, Result), "Run an existing skill. Slug is the skill slug (e.g. ''deep-research''). Args is a JSON array of string arguments. Returns the skill result.") :-',
-        '',
-        '    exec(run_skill(slug: Slug, args: Args), Result).',
-        '',
-        'tool(consult_recipes(Query, Result), "Search the recipe library for workflow guidance and conventions. Query is a natural-language description. Returns matching recipe metadata and content.") :-',
-        '',
-        '    exec(consult_recipes(query: Query, max_results: 3), Result).',
-        '',
-        'tool(search_web(Query, Results), "Search the web for current information. Returns search results.") :-',
-        '',
-        '    exec(web_search(query: Query), Results).',
-        '',
-        'tool(search_news(Query, Results), "Search recent news articles. Returns news results.") :-',
-        '',
-        '    exec(news_search(query: Query), Results).',
-        '',
-        'tool(fetch_url(Url, Content), "Fetch the content of a web page by URL. Returns the page body as text.") :-',
-        '',
-        '    exec(url_fetch(url: Url), Result),',
-        '    get_dict(body, Result, Content).',
-        '',
-        'tool(download_file(Url, FilePath, Size), "Download a file from a URL and save it to disk. Returns the file path and size.") :-',
-        '',
-        '    exec(url_fetch(url: Url, save_to: FilePath), Result),',
-        '    get_dict(file_path, Result, FilePath),',
-        '    get_dict(size, Result, Size).',
-        '',
-        'tool(run_bash(Command, Output), "Run a shell command in the workspace.") :-',
-        '',
-        '    exec(bash(command: Command), Output).',
-        '',
-        'tool(create_new_skill(Spec, Result), "Create and deploy a new reusable skill from a natural language spec.") :-',
-        '',
-        '    exec(create_skill(spec: Spec), Result).',
-        '',
-        'tool(ask_user(Prompt, Response), "Ask the user a clarifying question and get their response.") :-',
-        '',
-        '    exec(ask_user(prompt: Prompt), Result),',
-        '    get_dict(user_response, Result, Response).',
-        '',
-        'tool(inform_user(Message, Result), "Send a status update or progress report to the user.") :-',
-        '    output(Message),',
-        '    Result = "ok".'
-    ], "\n", ToolBlock).
-
-load_dml_reference(DmlReference) :-
-    (   exists_file('.deepclause/docs/DML_REFERENCE.md')
-    ->  read_file('.deepclause/docs/DML_REFERENCE.md', DmlReference)
-    ;   DmlReference = "DML reference unavailable. Use standard DeepClause DML conventions."
-    ).
-
-load_dml_compiler_prompt(CompilerPrompt) :-
-    (   exists_file('.deepclause/system/DML_COMPILER_PROMPT.md')
-    ->  read_file('.deepclause/system/DML_COMPILER_PROMPT.md', CompilerPrompt)
-    ;   CompilerPrompt = "DML compiler guidance unavailable. Follow standard DeepClause DML conventions and keep plans simple."
-    ).
-
-load_coding_workflow_recipe(CodingWorkflowRecipe) :-
-    exec(consult_recipes(query: 'deepclause coding workflow', max_results: 3), Result),
-    get_dict(matches, Result, Matches),
-    Matches = [FirstMatch|_],
-    get_dict(content, FirstMatch, CodingWorkflowRecipe),
-    !.
-
-load_coding_workflow_recipe("DeepClause Coding Workflow recipe unavailable. Follow standard DeepClause coding workflow guidance.").
-
-agent_main(Request) :-
-    format(string(Message), "I could not create a valid multi-strategy plan for this request: ~w. Try simplifying the request or being more explicit about the steps and required tools.", [Request]),
-    answer(Message).