substrate-ai 0.1.0

package/dist/cli/templates/parallel.yaml

@@ -0,0 +1,72 @@
+# Substrate Task Graph — Parallel Template
+# A set of tasks that all run concurrently.
+#
+# All tasks below have no dependencies (depends_on: []), so they all start
+# simultaneously when the orchestration session begins.
+# Each task is assigned to a different agent to illustrate per-task agent routing.
+
+# version: format version for compatibility tracking with Substrate.
+version: "1.0"
+
+# session: configuration that applies to the entire orchestration run.
+session:
+  # name: human-readable label for this session.
+  name: parallel-workflow
+  # base_branch: the git branch that all agent worktrees branch from.
+  base_branch: main
+
+tasks:
+  # All four tasks below start simultaneously (no depends_on).
+  # Each runs in its own git worktree so they don't conflict.
+  feature-auth:
+    name: "Implement Authentication"
+    description: "Implement user authentication module"
+    # agent: claude-code handles general TypeScript/JavaScript tasks well.
+    agent: claude-code
+    # type: categorizes the task. Options: coding, testing, docs, debugging, refactoring
+    type: coding
+    # prompt: the full instruction sent to the agent.
+    prompt: |
+      Implement the authentication module at src/auth/.
+      Include login, logout, and JWT token validation.
+      Write unit tests alongside the implementation.
+    # depends_on: empty list means this task starts immediately.
+    depends_on: []
+
+  feature-api:
+    name: "Implement REST API"
+    description: "Implement REST API endpoints"
+    # agent: codex illustrates using a different agent for a different task.
+    # Each task can specify a different agent — useful for specialization.
+    agent: codex
+    type: coding
+    prompt: |
+      Implement the REST API endpoints defined in docs/api-spec.yaml.
+      Use Express.js and add OpenAPI documentation comments.
+      Ensure all endpoints have proper error handling and input validation.
+    depends_on: []
+
+  feature-ui:
+    name: "Implement UI Components"
+    description: "Implement frontend UI components"
+    # agent: gemini illustrates yet another agent choice.
+    agent: gemini
+    type: coding
+    prompt: |
+      Create the React UI components for the dashboard.
+      Use the design mockups in docs/mockups/ as reference.
+      Follow the existing component patterns in src/components/.
+    depends_on: []
+
+  feature-db:
+    name: "Set Up Database Schema"
+    description: "Set up database schema and migrations"
+    # agent: auto means the routing engine picks the best available agent
+    # based on the current routing policy and agent availability.
+    agent: auto
+    type: coding
+    prompt: |
+      Create the database schema and migration files.
+      Use the entity definitions in docs/data-model.md.
+      Ensure migrations are idempotent and reversible.
+    depends_on: []

package/dist/cli/templates/research-then-implement.yaml

@@ -0,0 +1,103 @@
+# Substrate Task Graph — Research Then Implement Template
+# Pattern: parallel research → synthesize → parallel implementation
+#
+# This is a fan-out / fan-in pattern:
+#   Fan-out: multiple research tasks run in parallel (no dependencies between them)
+#   Fan-in:  synthesize waits for ALL research tasks before starting
+#   Fan-out: multiple implementation tasks run in parallel after synthesize
+#
+# Visualization:
+#   research-existing-code ─┐
+#                            ├─→ synthesize ─┬─→ implement-core
+#   research-best-practices ─┘               └─→ implement-tests
+
+# version: format version for compatibility tracking with Substrate.
+version: "1.0"
+
+# session: configuration that applies to the entire orchestration run.
+session:
+  # name: human-readable label for this session.
+  name: research-implement-workflow
+  # base_branch: the git branch that all agent worktrees branch from.
+  base_branch: main
+
+tasks:
+  # Phase 1: Parallel research tasks (both start immediately — fan-out).
+  # These run concurrently in separate git worktrees.
+  research-existing-code:
+    name: "Research Existing Codebase"
+    description: "Research the existing codebase for patterns and constraints"
+    # agent: which CLI agent handles this task.
+    agent: claude-code
+    # type: Options: coding, testing, docs, debugging, refactoring
+    type: docs
+    # prompt: full instruction sent to the agent.
+    prompt: |
+      Analyze the existing codebase. Document:
+      - Key architectural patterns and design decisions
+      - Relevant existing modules that the new feature will interact with
+      - Constraints and conventions (naming, error handling, testing style)
+      - Potential conflicts or integration points
+      Save findings to docs/research-codebase.md.
+    # depends_on: empty list means this task starts immediately (fan-out start).
+    depends_on: []
+
+  research-best-practices:
+    name: "Research Best Practices"
+    description: "Research industry best practices for the target feature"
+    agent: claude-code
+    type: docs
+    prompt: |
+      Research best practices for implementing [FEATURE].
+      Document recommended approaches, trade-offs, and real-world examples.
+      Compare at least two alternative implementation strategies.
+      Save findings to docs/research-practices.md.
+    # depends_on: also empty — runs concurrently with research-existing-code.
+    depends_on: []
+
+  # Phase 2: Synthesize findings — fan-in (waits for BOTH research tasks).
+  # This task cannot start until research-existing-code AND research-best-practices
+  # have both completed successfully.
+  synthesize:
+    name: "Synthesize Research"
+    description: "Synthesize research findings into an implementation plan"
+    agent: claude-code
+    type: docs
+    prompt: |
+      Read docs/research-codebase.md and docs/research-practices.md.
+      Produce a detailed implementation plan at docs/implementation-plan.md.
+      The plan should specify:
+      - Which modules to create or modify
+      - The recommended implementation strategy (with rationale)
+      - The order of implementation steps
+      - Key risks and mitigations
+    depends_on:
+      - research-existing-code   # fan-in: waits for both research tasks to complete
+      - research-best-practices  # both must finish before synthesize can start
+
+  # Phase 3: Parallel implementation — fan-out (both start after synthesize).
+  # These tasks run concurrently once the implementation plan is ready.
+  implement-core:
+    name: "Implement Core Logic"
+    description: "Implement the core business logic per the implementation plan"
+    agent: claude-code
+    type: coding
+    prompt: |
+      Read docs/implementation-plan.md and implement the core module.
+      Focus on the business logic layer only (no UI, no test code).
+      Follow the architectural patterns documented in docs/research-codebase.md.
+    depends_on:
+      - synthesize  # will not start until synthesize completes (fan-out start)
+
+  implement-tests:
+    name: "Implement Test Suite"
+    description: "Implement the test suite per the implementation plan"
+    agent: claude-code
+    type: testing
+    prompt: |
+      Read docs/implementation-plan.md and implement the test suite.
+      Write tests in parallel with implement-core — test the interfaces/contracts,
+      not the internal implementation details.
+      Target 80%+ coverage for the new core module.
+    depends_on:
+      - synthesize  # also waits for synthesize, then runs in parallel with implement-core

package/dist/cli/templates/review-cycle.yaml

@@ -0,0 +1,91 @@
+# Substrate Task Graph — Review Cycle Template
+# Pattern: implement → review → revise
+#
+# This template demonstrates a quality-focused workflow where code is
+# written, then reviewed, then revised based on review feedback.
+#
+# To add another review iteration, duplicate the review + revise pair:
+#   review-2:
+#     depends_on: [revise]
+#   revise-2:
+#     depends_on: [review-2]
+
+# version: format version for compatibility tracking with Substrate.
+version: "1.0"
+
+# session: configuration that applies to the entire orchestration run.
+session:
+  # name: human-readable label for this session.
+  name: review-cycle-workflow
+  # base_branch: the git branch that all agent worktrees branch from.
+  base_branch: main
+
+tasks:
+  # Step 1: Initial implementation — starts immediately (no dependencies).
+  implement:
+    name: "Implement Feature"
+    description: "Implement the target feature"
+    # agent: which CLI agent handles this task.
+    agent: claude-code
+    # type: Options: coding, testing, docs, debugging, refactoring
+    type: coding
+    # prompt: full instruction sent to the agent.
+    prompt: |
+      Implement the feature described in docs/feature-spec.md.
+      Focus on correctness and completeness.
+      Code quality and style will be reviewed in the next step.
+    # depends_on: empty list means this task starts immediately.
+    depends_on: []
+
+  # Step 2: Code review — runs after implementation completes.
+  # A different agent can be assigned here for an independent perspective.
+  review:
+    name: "Code Review"
+    description: "Review the implementation for quality and correctness"
+    agent: claude-code
+    type: debugging
+    prompt: |
+      Review the code changes made in the 'implement' task.
+      Check for: correctness, error handling, test coverage, code style,
+      security concerns, and adherence to the spec in docs/feature-spec.md.
+      Write your review findings to docs/review-notes.md.
+      Be specific: cite file names, line numbers, and suggested fixes.
+    depends_on:
+      - implement  # review will not start until implement is completed
+
+  # Step 3: Revision — applies the review feedback.
+  revise:
+    name: "Apply Review Feedback"
+    description: "Apply review feedback and finalize the implementation"
+    agent: claude-code
+    type: coding
+    prompt: |
+      Read docs/review-notes.md and apply all required changes.
+      Address every concern raised in the review.
+      After making changes, update docs/review-notes.md to mark each
+      item as resolved with a brief note explaining what was changed.
+    depends_on:
+      - review  # revise will not start until review is completed
+
+  # --- To add a second review cycle, uncomment and customize: ---
+  # review-2:
+  #   name: "Final Code Review"
+  #   description: "Final review after revisions"
+  #   agent: claude-code
+  #   type: debugging
+  #   prompt: |
+  #     Perform a final review of the revised code.
+  #     Verify all items from docs/review-notes.md are resolved.
+  #     Confirm the implementation meets all spec requirements.
+  #   depends_on:
+  #     - revise
+  #
+  # revise-2:
+  #   name: "Final Revision"
+  #   description: "Apply final review feedback"
+  #   agent: claude-code
+  #   type: coding
+  #   prompt: |
+  #     Apply any remaining feedback from the final review.
+  #   depends_on:
+  #     - review-2

package/dist/cli/templates/sequential.yaml

@@ -0,0 +1,68 @@
+# Substrate Task Graph — Sequential Template
+# A series of tasks that run one after another.
+#
+# This template demonstrates a simple sequential pipeline where each task
+# depends on the previous one completing before it starts.
+
+# version: format version for compatibility tracking with Substrate.
+# Currently "1.0" is the supported version.
+version: "1.0"
+
+# session: configuration that applies to the entire orchestration run.
+session:
+  # name: a human-readable label for this session (appears in logs and status output).
+  name: sequential-workflow
+  # base_branch: the git branch that all agent worktrees branch from.
+  base_branch: main
+
+tasks:
+  # Task 1: the first step in the sequence.
+  # Format: each task key is the unique task ID used in depends_on references.
+  step-1:
+    # name: short label shown in status output and logs.
+    name: "Gather Requirements"
+    # description: optional longer explanation of what this task does.
+    description: "First step: analyze the project and produce a requirements document"
+    # agent: which CLI agent handles this task.
+    # Options: claude-code, codex, gemini, auto (auto lets the routing engine pick)
+    agent: claude-code
+    # type: categorizes the task for routing and reporting purposes.
+    # Options: coding, testing, docs, debugging, refactoring
+    type: docs
+    # prompt: the instruction sent verbatim to the agent.
+    prompt: |
+      Analyze the project requirements and produce a detailed spec document.
+      Save the output to docs/spec.md.
+      Include: goals, non-goals, acceptance criteria, and open questions.
+    # depends_on: list of task IDs that must complete before this task runs.
+    # An empty list means this task can start immediately.
+    depends_on: []
+
+  # Task 2: runs only after step-1 completes successfully.
+  step-2:
+    name: "Implement Feature"
+    description: "Second step: implement the feature described in the spec"
+    agent: claude-code
+    type: coding
+    prompt: |
+      Read docs/spec.md and implement the described feature.
+      Follow existing code conventions and patterns in the codebase.
+      Ensure all acceptance criteria from the spec are addressed.
+    depends_on:
+      - step-1  # step-2 will not start until step-1 is completed
+
+  # Task 3: final step — runs only after step-2 completes.
+  # To add more sequential steps, copy this block and update the id and depends_on.
+  step-3:
+    name: "Write Tests"
+    description: "Third step: write tests for the implementation"
+    agent: claude-code
+    type: testing
+    prompt: |
+      Write comprehensive unit and integration tests for the code written in step-2.
+      Target 80%+ coverage for new code.
+      Ensure all edge cases from docs/spec.md are covered.
+    # budget_usd: optional per-task cost cap. Overrides the session-level budget.
+    # budget_usd: 2.00
+    depends_on:
+      - step-2  # step-3 will not start until step-2 is completed

package/dist/config-schema-C9tTMcm1.js

@@ -0,0 +1,102 @@
+import { z } from "zod";
+
+//#region src/modules/config/config-schema.ts
+/** Subscription routing modes */
+const SubscriptionRoutingSchema = z.enum([
+	"auto",
+	"subscription",
+	"api",
+	"disabled"
+]);
+/** Rate limit configuration for a provider */
+const RateLimitSchema = z.object({
+	tokens: z.number().int().positive(),
+	window_seconds: z.number().int().positive()
+}).strict();
+/** Per-provider configuration */
+const ProviderConfigSchema = z.object({
+	enabled: z.boolean(),
+	cli_path: z.string().optional(),
+	subscription_routing: SubscriptionRoutingSchema,
+	max_concurrent: z.number().int().min(1).max(32),
+	rate_limit: RateLimitSchema.optional(),
+	api_key_env: z.string().optional(),
+	api_billing: z.boolean()
+}).strict();
+/** Map of all known providers */
+const ProvidersSchema = z.object({
+	claude: ProviderConfigSchema.optional(),
+	codex: ProviderConfigSchema.optional(),
+	gemini: ProviderConfigSchema.optional()
+}).strict();
+const LogLevelSchema = z.enum([
+	"trace",
+	"debug",
+	"info",
+	"warn",
+	"error",
+	"fatal"
+]);
+const GlobalSettingsSchema = z.object({
+	log_level: LogLevelSchema,
+	max_concurrent_tasks: z.number().int().min(1).max(64),
+	budget_cap_tokens: z.number().int().min(0),
+	budget_cap_usd: z.number().min(0),
+	workspace_dir: z.string().optional(),
+	update_check: z.boolean().optional()
+}).strict();
+const CostTrackerConfigSchema = z.object({
+	enabled: z.boolean(),
+	token_rates_provider: z.enum(["builtin", "custom"]),
+	track_planning_costs: z.boolean(),
+	savings_reporting: z.boolean()
+}).strict();
+const BudgetConfigSchema = z.object({
+	default_task_budget_usd: z.number().min(0),
+	default_session_budget_usd: z.number().min(0),
+	planning_costs_count_against_budget: z.boolean(),
+	warning_threshold_percent: z.number().min(0).max(100)
+}).strict();
+const RoutingRuleSchema = z.object({
+	task_type: z.string(),
+	preferred_provider: z.string(),
+	fallback_providers: z.array(z.string())
+}).strict();
+const RoutingPolicySchema = z.object({
+	default_provider: z.string(),
+	rules: z.array(RoutingRuleSchema)
+}).strict();
+/** Current supported config format version */
+const CURRENT_CONFIG_FORMAT_VERSION = "1";
+/** Current supported task graph version */
+const CURRENT_TASK_GRAPH_VERSION = "1";
+/** All config format versions this toolkit can read and validate */
+const SUPPORTED_CONFIG_FORMAT_VERSIONS = ["1"];
+/** All task graph format versions this toolkit can read and validate */
+const SUPPORTED_TASK_GRAPH_VERSIONS = ["1"];
+const SubstrateConfigSchema = z.object({
+	config_format_version: z.enum(["1"]),
+	task_graph_version: z.enum(["1"]).optional(),
+	global: GlobalSettingsSchema,
+	providers: ProvidersSchema,
+	cost_tracker: CostTrackerConfigSchema.optional(),
+	budget: BudgetConfigSchema.optional()
+}).strict();
+const PartialProviderConfigSchema = ProviderConfigSchema.partial();
+const PartialGlobalSettingsSchema = GlobalSettingsSchema.partial();
+const PartialSubstrateConfigSchema = z.object({
+	config_format_version: z.enum(["1"]).optional(),
+	task_graph_version: z.enum(["1"]).optional(),
+	global: PartialGlobalSettingsSchema.optional(),
+	providers: z.object({
+		claude: PartialProviderConfigSchema.optional(),
+		codex: PartialProviderConfigSchema.optional(),
+		gemini: PartialProviderConfigSchema.optional()
+	}).partial().optional(),
+	cost_tracker: CostTrackerConfigSchema.partial().optional(),
+	budget: BudgetConfigSchema.partial().optional()
+}).strict();
+
+//#endregion
+export { CURRENT_CONFIG_FORMAT_VERSION, CURRENT_TASK_GRAPH_VERSION, PartialSubstrateConfigSchema, SUPPORTED_CONFIG_FORMAT_VERSIONS, SUPPORTED_TASK_GRAPH_VERSIONS, SubstrateConfigSchema };
+//# sourceMappingURL=config-schema-C9tTMcm1.js.map