substrate-ai 0.1.33 → 0.2.1

package/dist/cli/templates/claude-md-substrate-section.md

@@ -4,9 +4,9 @@
 This project uses Substrate for automated implementation pipelines.
 
 ### Quick Start
-- Run `substrate auto --help-agent` to get full pipeline interaction instructions
-- Run `substrate auto run --events` to execute the pipeline with structured event output
-- Run `substrate auto run --events --stories 7-1,7-2` to run specific stories
+- Run `substrate run --help-agent` to get full pipeline interaction instructions
+- Run `substrate run --events` to execute the pipeline with structured event output
+- Run `substrate run --events --stories 7-1,7-2` to run specific stories
 
 ### Agent Behavior
 - On story escalation: read the flagged files and issues, propose a fix, ask the user before applying

package/dist/decisions-BBLMsN_c.js

@@ -0,0 +1,336 @@
+import { z } from "zod";
+
+//#region src/persistence/schemas/decisions.ts
+const PhaseEnum = z.enum([
+	"analysis",
+	"planning",
+	"solutioning",
+	"implementation"
+]);
+const RequirementPriorityEnum = z.enum([
+	"must",
+	"should",
+	"could",
+	"wont"
+]);
+const RequirementTypeEnum = z.enum([
+	"functional",
+	"non_functional",
+	"constraint"
+]);
+const PipelineRunStatusEnum = z.enum([
+	"running",
+	"paused",
+	"completed",
+	"failed",
+	"stopped"
+]);
+const DecisionSchema = z.object({
+	id: z.string().uuid(),
+	pipeline_run_id: z.string().nullable().optional(),
+	phase: z.string().min(1),
+	category: z.string().min(1),
+	key: z.string().min(1),
+	value: z.string().min(1),
+	rationale: z.string().nullable().optional(),
+	superseded_by: z.string().nullable().optional(),
+	created_at: z.string().optional(),
+	updated_at: z.string().optional()
+});
+const CreateDecisionInputSchema = z.object({
+	pipeline_run_id: z.string().nullable().optional(),
+	phase: z.string().min(1),
+	category: z.string().min(1),
+	key: z.string().min(1),
+	value: z.string().min(1),
+	rationale: z.string().nullable().optional()
+});
+const RequirementSchema = z.object({
+	id: z.string().uuid(),
+	pipeline_run_id: z.string().nullable().optional(),
+	source: z.string().min(1),
+	type: RequirementTypeEnum,
+	description: z.string().min(1),
+	priority: RequirementPriorityEnum,
+	status: z.string().default("active"),
+	created_at: z.string().optional()
+});
+const CreateRequirementInputSchema = z.object({
+	pipeline_run_id: z.string().nullable().optional(),
+	source: z.string().min(1),
+	type: RequirementTypeEnum,
+	description: z.string().min(1),
+	priority: RequirementPriorityEnum
+});
+const ConstraintSchema = z.object({
+	id: z.string().uuid(),
+	pipeline_run_id: z.string().nullable().optional(),
+	category: z.string().min(1),
+	description: z.string().min(1),
+	source: z.string().min(1),
+	created_at: z.string().optional()
+});
+const CreateConstraintInputSchema = z.object({
+	pipeline_run_id: z.string().nullable().optional(),
+	category: z.string().min(1),
+	description: z.string().min(1),
+	source: z.string().min(1)
+});
+const ArtifactSchema = z.object({
+	id: z.string().uuid(),
+	pipeline_run_id: z.string().nullable().optional(),
+	phase: z.string().min(1),
+	type: z.string().min(1),
+	path: z.string().min(1),
+	content_hash: z.string().nullable().optional(),
+	summary: z.string().nullable().optional(),
+	created_at: z.string().optional()
+});
+const RegisterArtifactInputSchema = z.object({
+	pipeline_run_id: z.string().nullable().optional(),
+	phase: z.string().min(1),
+	type: z.string().min(1),
+	path: z.string().min(1),
+	content_hash: z.string().nullable().optional(),
+	summary: z.string().nullable().optional()
+});
+const PipelineRunSchema = z.object({
+	id: z.string().uuid(),
+	methodology: z.string().min(1),
+	current_phase: z.string().nullable().optional(),
+	status: PipelineRunStatusEnum,
+	config_json: z.string().nullable().optional(),
+	token_usage_json: z.string().nullable().optional(),
+	parent_run_id: z.string().nullable().optional(),
+	created_at: z.string().optional(),
+	updated_at: z.string().optional()
+});
+const CreatePipelineRunInputSchema = z.object({
+	methodology: z.string().min(1),
+	start_phase: z.string().nullable().optional(),
+	config_json: z.string().nullable().optional()
+});
+const TokenUsageSchema = z.object({
+	id: z.number().int().optional(),
+	pipeline_run_id: z.string().nullable().optional(),
+	phase: z.string().min(1),
+	agent: z.string().min(1),
+	input_tokens: z.number().int().min(0).default(0),
+	output_tokens: z.number().int().min(0).default(0),
+	cost_usd: z.number().min(0).default(0),
+	metadata: z.string().nullable().optional(),
+	created_at: z.string().optional()
+});
+const AddTokenUsageInputSchema = z.object({
+	phase: z.string().min(1),
+	agent: z.string().min(1),
+	input_tokens: z.number().int().min(0).default(0),
+	output_tokens: z.number().int().min(0).default(0),
+	cost_usd: z.number().min(0).default(0),
+	metadata: z.string().nullable().optional()
+});
+
+//#endregion
+//#region src/persistence/queries/decisions.ts
+/**
+* Insert a new decision record with a generated UUID.
+*/
+function createDecision(db, input) {
+	const validated = CreateDecisionInputSchema.parse(input);
+	const id = crypto.randomUUID();
+	const stmt = db.prepare(`
+    INSERT INTO decisions (id, pipeline_run_id, phase, category, key, value, rationale)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+  `);
+	stmt.run(id, validated.pipeline_run_id ?? null, validated.phase, validated.category, validated.key, validated.value, validated.rationale ?? null);
+	const row = db.prepare("SELECT * FROM decisions WHERE id = ?").get(id);
+	return row;
+}
+/**
+* Insert or update a decision record.
+* If a decision with the same pipeline_run_id, category, and key already exists,
+* update its value and rationale. Otherwise, insert a new record.
+*/
+function upsertDecision(db, input) {
+	const validated = CreateDecisionInputSchema.parse(input);
+	const existing = db.prepare("SELECT * FROM decisions WHERE pipeline_run_id = ? AND category = ? AND key = ? LIMIT 1").get(validated.pipeline_run_id ?? null, validated.category, validated.key);
+	if (existing) {
+		updateDecision(db, existing.id, {
+			value: validated.value,
+			rationale: validated.rationale ?? void 0
+		});
+		return db.prepare("SELECT * FROM decisions WHERE id = ?").get(existing.id);
+	}
+	return createDecision(db, input);
+}
+/**
+* Get all decisions for a given phase, ordered by created_at ascending.
+*/
+function getDecisionsByPhase(db, phase) {
+	const stmt = db.prepare("SELECT * FROM decisions WHERE phase = ? ORDER BY created_at ASC");
+	return stmt.all(phase);
+}
+/**
+* Get all decisions for a given phase scoped to a specific pipeline run,
+* ordered by created_at ascending.
+*/
+function getDecisionsByPhaseForRun(db, runId, phase) {
+	const stmt = db.prepare("SELECT * FROM decisions WHERE pipeline_run_id = ? AND phase = ? ORDER BY created_at ASC");
+	return stmt.all(runId, phase);
+}
+/**
+* Update a decision's value and/or rationale and set updated_at.
+*/
+function updateDecision(db, id, updates) {
+	const setClauses = [];
+	const values = [];
+	if (updates.value !== void 0) {
+		setClauses.push("value = ?");
+		values.push(updates.value);
+	}
+	if (updates.rationale !== void 0) {
+		setClauses.push("rationale = ?");
+		values.push(updates.rationale);
+	}
+	if (setClauses.length === 0) return;
+	setClauses.push("updated_at = datetime('now')");
+	values.push(id);
+	const stmt = db.prepare(`UPDATE decisions SET ${setClauses.join(", ")} WHERE id = ?`);
+	stmt.run(...values);
+}
+/**
+* Insert a new requirement with status = 'active'.
+*/
+function createRequirement(db, input) {
+	const validated = CreateRequirementInputSchema.parse(input);
+	const id = crypto.randomUUID();
+	const stmt = db.prepare(`
+    INSERT INTO requirements (id, pipeline_run_id, source, type, description, priority, status)
+    VALUES (?, ?, ?, ?, ?, ?, 'active')
+  `);
+	stmt.run(id, validated.pipeline_run_id ?? null, validated.source, validated.type, validated.description, validated.priority);
+	const row = db.prepare("SELECT * FROM requirements WHERE id = ?").get(id);
+	return row;
+}
+/**
+* Register a new artifact record.
+*/
+function registerArtifact(db, input) {
+	const validated = RegisterArtifactInputSchema.parse(input);
+	const id = crypto.randomUUID();
+	const stmt = db.prepare(`
+    INSERT INTO artifacts (id, pipeline_run_id, phase, type, path, content_hash, summary)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+  `);
+	stmt.run(id, validated.pipeline_run_id ?? null, validated.phase, validated.type, validated.path, validated.content_hash ?? null, validated.summary ?? null);
+	const row = db.prepare("SELECT * FROM artifacts WHERE id = ?").get(id);
+	return row;
+}
+/**
+* Get the latest artifact of a given type for a specific pipeline run.
+* Filters by pipeline_run_id, phase, and type.
+* Returns undefined if none found.
+*/
+function getArtifactByTypeForRun(db, runId, phase, type) {
+	const stmt = db.prepare("SELECT * FROM artifacts WHERE pipeline_run_id = ? AND phase = ? AND type = ? ORDER BY created_at DESC, rowid DESC LIMIT 1");
+	return stmt.get(runId, phase, type);
+}
+/**
+* Get all artifacts registered for a specific pipeline run, ordered by created_at ascending.
+*/
+function getArtifactsByRun(db, runId) {
+	const stmt = db.prepare("SELECT * FROM artifacts WHERE pipeline_run_id = ? ORDER BY created_at ASC");
+	return stmt.all(runId);
+}
+/**
+* Get a pipeline run by its ID. Returns undefined if not found.
+*/
+function getPipelineRunById(db, id) {
+	const stmt = db.prepare("SELECT * FROM pipeline_runs WHERE id = ?");
+	return stmt.get(id);
+}
+/**
+* Update a pipeline run's config_json field.
+*/
+function updatePipelineRunConfig(db, id, configJson) {
+	const stmt = db.prepare("UPDATE pipeline_runs SET config_json = ?, updated_at = datetime('now') WHERE id = ?");
+	stmt.run(configJson, id);
+}
+/**
+* Create a new pipeline run with status = 'running'.
+*/
+function createPipelineRun(db, input) {
+	const validated = CreatePipelineRunInputSchema.parse(input);
+	const id = crypto.randomUUID();
+	const stmt = db.prepare(`
+    INSERT INTO pipeline_runs (id, methodology, current_phase, status, config_json)
+    VALUES (?, ?, ?, 'running', ?)
+  `);
+	stmt.run(id, validated.methodology, validated.start_phase ?? null, validated.config_json ?? null);
+	const row = db.prepare("SELECT * FROM pipeline_runs WHERE id = ?").get(id);
+	return row;
+}
+/**
+* Update a pipeline run's current_phase, status, and/or token_usage_json.
+*/
+function updatePipelineRun(db, id, updates) {
+	const setClauses = [];
+	const values = [];
+	if (updates.current_phase !== void 0) {
+		setClauses.push("current_phase = ?");
+		values.push(updates.current_phase);
+	}
+	if (updates.status !== void 0) {
+		setClauses.push("status = ?");
+		values.push(updates.status);
+	}
+	if (updates.token_usage_json !== void 0) {
+		setClauses.push("token_usage_json = ?");
+		values.push(updates.token_usage_json);
+	}
+	if (setClauses.length === 0) return;
+	setClauses.push("updated_at = datetime('now')");
+	values.push(id);
+	const stmt = db.prepare(`UPDATE pipeline_runs SET ${setClauses.join(", ")} WHERE id = ?`);
+	stmt.run(...values);
+}
+/**
+* Get the most recently created pipeline run. Returns undefined if none found.
+*/
+function getLatestRun(db) {
+	const stmt = db.prepare("SELECT * FROM pipeline_runs ORDER BY created_at DESC, rowid DESC LIMIT 1");
+	return stmt.get();
+}
+/**
+* Append a token usage record for a pipeline run.
+*/
+function addTokenUsage(db, runId, usage) {
+	const validated = AddTokenUsageInputSchema.parse(usage);
+	const stmt = db.prepare(`
+    INSERT INTO token_usage (pipeline_run_id, phase, agent, input_tokens, output_tokens, cost_usd, metadata)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+  `);
+	stmt.run(runId, validated.phase, validated.agent, validated.input_tokens, validated.output_tokens, validated.cost_usd, validated.metadata ?? null);
+}
+/**
+* Aggregate token usage by phase and agent for a given pipeline run.
+*/
+function getTokenUsageSummary(db, runId) {
+	const stmt = db.prepare(`
+    SELECT
+      phase,
+      agent,
+      SUM(input_tokens)  AS total_input_tokens,
+      SUM(output_tokens) AS total_output_tokens,
+      SUM(cost_usd)      AS total_cost_usd
+    FROM token_usage
+    WHERE pipeline_run_id = ?
+    GROUP BY phase, agent
+    ORDER BY phase ASC, agent ASC
+  `);
+	return stmt.all(runId);
+}
+
+//#endregion
+export { addTokenUsage, createDecision, createPipelineRun, createRequirement, getArtifactByTypeForRun, getArtifactsByRun, getDecisionsByPhase, getDecisionsByPhaseForRun, getLatestRun, getPipelineRunById, getTokenUsageSummary, registerArtifact, updateDecision, updatePipelineRun, updatePipelineRunConfig, upsertDecision };
+//# sourceMappingURL=decisions-BBLMsN_c.js.map

package/dist/decisions-WIsicZiG.js

@@ -0,0 +1,3 @@
+import { addTokenUsage, createDecision, createPipelineRun, createRequirement, getArtifactByTypeForRun, getArtifactsByRun, getDecisionsByPhase, getDecisionsByPhaseForRun, getLatestRun, getPipelineRunById, getTokenUsageSummary, registerArtifact, updateDecision, updatePipelineRun, updatePipelineRunConfig, upsertDecision } from "./decisions-BBLMsN_c.js";
+
+export { getLatestRun };

package/dist/errors-BPqtzQ4U.js

@@ -0,0 +1,111 @@
+//#region src/core/errors.ts
+/**
+* Error definitions for Substrate
+* Provides structured error hierarchy for all toolkit operations
+*/
+/** Base error class for all Substrate errors */
+var AdtError = class AdtError extends Error {
+	code;
+	context;
+	constructor(message, code, context = {}) {
+		super(message);
+		this.name = "AdtError";
+		this.code = code;
+		this.context = context;
+		if (Error.captureStackTrace) Error.captureStackTrace(this, AdtError);
+	}
+	toJSON() {
+		return {
+			name: this.name,
+			message: this.message,
+			code: this.code,
+			context: this.context,
+			stack: this.stack
+		};
+	}
+};
+/** Error thrown when task configuration is invalid */
+var TaskConfigError = class extends AdtError {
+	constructor(message, context = {}) {
+		super(message, "TASK_CONFIG_ERROR", context);
+		this.name = "TaskConfigError";
+	}
+};
+/** Error thrown when a worker/agent operation fails */
+var WorkerError = class extends AdtError {
+	constructor(message, context = {}) {
+		super(message, "WORKER_ERROR", context);
+		this.name = "WorkerError";
+	}
+};
+/** Error thrown when a worker/agent cannot be found */
+var WorkerNotFoundError = class extends AdtError {
+	constructor(agentId) {
+		super(`Worker agent not found: ${agentId}`, "WORKER_NOT_FOUND", { agentId });
+		this.name = "WorkerNotFoundError";
+	}
+};
+/** Error thrown when a task graph is invalid */
+var TaskGraphError = class extends AdtError {
+	constructor(message, context = {}) {
+		super(message, "TASK_GRAPH_ERROR", context);
+		this.name = "TaskGraphError";
+	}
+};
+/** Error thrown when a task graph has cycles (deadlock) */
+var TaskGraphCycleError = class extends TaskGraphError {
+	constructor(cycle) {
+		super(`Circular dependency detected in task graph: ${cycle.join(" -> ")}`, { cycle });
+		this.name = "TaskGraphCycleError";
+	}
+};
+/** Error thrown when a budget limit is exceeded */
+var BudgetExceededError = class extends AdtError {
+	constructor(limit, current, context = {}) {
+		super(`Budget cap exceeded: current=${String(current)}, limit=${String(limit)}`, "BUDGET_EXCEEDED", {
+			limit,
+			current,
+			...context
+		});
+		this.name = "BudgetExceededError";
+	}
+};
+/** Error thrown when git operations fail */
+var GitError = class extends AdtError {
+	constructor(message, context = {}) {
+		super(message, "GIT_ERROR", context);
+		this.name = "GitError";
+	}
+};
+/** Error thrown when configuration is invalid or missing */
+var ConfigError = class extends AdtError {
+	constructor(message, context = {}) {
+		super(message, "CONFIG_ERROR", context);
+		this.name = "ConfigError";
+	}
+};
+/** Error thrown when state recovery fails */
+var RecoveryError = class extends AdtError {
+	constructor(message, context = {}) {
+		super(message, "RECOVERY_ERROR", context);
+		this.name = "RecoveryError";
+	}
+};
+/** Error thrown when a config file uses an incompatible format version */
+var ConfigIncompatibleFormatError = class extends AdtError {
+	constructor(message, context = {}) {
+		super(message, "CONFIG_INCOMPATIBLE_FORMAT", context);
+		this.name = "ConfigIncompatibleFormatError";
+	}
+};
+/** Error thrown when a task graph file uses an incompatible format version */
+var TaskGraphIncompatibleFormatError = class extends AdtError {
+	constructor(message, context = {}) {
+		super(message, "TASK_GRAPH_INCOMPATIBLE_FORMAT", context);
+		this.name = "TaskGraphIncompatibleFormatError";
+	}
+};
+
+//#endregion
+export { AdtError, BudgetExceededError, ConfigError, ConfigIncompatibleFormatError, GitError, RecoveryError, TaskConfigError, TaskGraphCycleError, TaskGraphError, TaskGraphIncompatibleFormatError, WorkerError, WorkerNotFoundError };
+//# sourceMappingURL=errors-BPqtzQ4U.js.map