sdd-cli 0.1.0

package/dist/ui/prompt.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ask = ask;
+exports.confirm = confirm;
+const fs_1 = __importDefault(require("fs"));
+const readline_1 = __importDefault(require("readline"));
+const flags_1 = require("../context/flags");
+let queuedAnswers = null;
+function getQueuedAnswers() {
+    if (queuedAnswers) {
+        return queuedAnswers;
+    }
+    if (!process.stdin.isTTY) {
+        const raw = fs_1.default.readFileSync(0, "utf-8");
+        queuedAnswers = raw.split(/\r?\n/).filter((line) => line.length > 0);
+        return queuedAnswers;
+    }
+    queuedAnswers = [];
+    return queuedAnswers;
+}
+const rl = readline_1.default.createInterface({
+    input: process.stdin,
+    output: process.stdout
+});
+process.on("exit", () => rl.close());
+function ask(question) {
+    if (!process.stdin.isTTY) {
+        const queue = getQueuedAnswers();
+        const answer = queue.shift() ?? "";
+        return Promise.resolve(answer.trim());
+    }
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            resolve(answer.trim());
+        });
+    });
+}
+async function confirm(question) {
+    const flags = (0, flags_1.getFlags)();
+    if (flags.approve) {
+        return true;
+    }
+    const response = await ask(question);
+    const normalized = response.trim().toLowerCase();
+    return normalized === "y" || normalized === "yes";
+}

package/dist/utils/list.d.ts

@@ -0,0 +1,2 @@
+export declare function formatList(input: string): string;
+export declare function parseList(input: string): string[];

package/dist/utils/list.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatList = formatList;
+exports.parseList = parseList;
+function formatList(input) {
+    const items = input
+        .split(",")
+        .map((item) => item.trim())
+        .filter((item) => item.length > 0);
+    if (items.length === 0) {
+        return "- N/A";
+    }
+    return items.map((item) => `- ${item}`).join("\n");
+}
+function parseList(input) {
+    return input
+        .split(",")
+        .map((item) => item.trim())
+        .filter((item) => item.length > 0);
+}

package/dist/validation/validate.d.ts

@@ -0,0 +1,4 @@
+export declare function validateJson(schemaFile: string, data: unknown): {
+    valid: boolean;
+    errors: string[];
+};

package/dist/validation/validate.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateJson = validateJson;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const _2020_1 = __importDefault(require("ajv/dist/2020"));
+const paths_1 = require("../paths");
+function validateJson(schemaFile, data) {
+    const root = (0, paths_1.getRepoRoot)();
+    const schemaPath = path_1.default.join(root, "schemas", schemaFile);
+    const schema = JSON.parse(fs_1.default.readFileSync(schemaPath, "utf-8"));
+    const ajv = new _2020_1.default();
+    const validate = ajv.compile(schema);
+    const valid = validate(data);
+    const errors = (validate.errors ?? []).map((error) => `${error.instancePath} ${error.message}`.trim());
+    return { valid: Boolean(valid), errors };
+}

package/dist/workspace/index.d.ts

@@ -0,0 +1,21 @@
+export type ProjectSummary = {
+    name: string;
+    status: string;
+};
+export type ProjectMetadata = {
+    name: string;
+    status: string;
+    domain: string;
+    createdAt: string;
+    updatedAt: string;
+};
+export type WorkspaceInfo = {
+    root: string;
+    indexPath: string;
+};
+export declare function getWorkspaceInfo(): WorkspaceInfo;
+export declare function ensureWorkspace(workspace: WorkspaceInfo): void;
+export declare function listProjects(workspace: WorkspaceInfo): ProjectSummary[];
+export declare function ensureProject(workspace: WorkspaceInfo, name: string, domain: string): ProjectMetadata;
+export declare function createProject(workspace: WorkspaceInfo, name: string, domain: string): ProjectMetadata;
+export declare function updateProjectStatus(workspace: WorkspaceInfo, name: string, status: string): void;

package/dist/workspace/index.js

@@ -0,0 +1,103 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWorkspaceInfo = getWorkspaceInfo;
+exports.ensureWorkspace = ensureWorkspace;
+exports.listProjects = listProjects;
+exports.ensureProject = ensureProject;
+exports.createProject = createProject;
+exports.updateProjectStatus = updateProjectStatus;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+function getWorkspaceInfo() {
+    const root = process.env.APPDATA
+        ? path_1.default.join(process.env.APPDATA, "sdd-tool", "workspaces")
+        : path_1.default.join(os_1.default.homedir(), ".config", "sdd-tool", "workspaces");
+    const indexPath = path_1.default.join(root, "workspaces.json");
+    return { root, indexPath };
+}
+function ensureWorkspace(workspace) {
+    if (!fs_1.default.existsSync(workspace.root)) {
+        fs_1.default.mkdirSync(workspace.root, { recursive: true });
+    }
+    if (!fs_1.default.existsSync(workspace.indexPath)) {
+        const emptyIndex = { projects: [] };
+        fs_1.default.writeFileSync(workspace.indexPath, JSON.stringify(emptyIndex, null, 2), "utf-8");
+    }
+}
+function listProjects(workspace) {
+    if (!fs_1.default.existsSync(workspace.indexPath)) {
+        return [];
+    }
+    const raw = fs_1.default.readFileSync(workspace.indexPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return (parsed.projects ?? []).map((project) => ({
+        name: project.name ?? "unknown",
+        status: project.status ?? "unknown"
+    }));
+}
+function ensureProject(workspace, name, domain) {
+    ensureWorkspace(workspace);
+    const projectRoot = path_1.default.join(workspace.root, name);
+    if (!fs_1.default.existsSync(projectRoot)) {
+        fs_1.default.mkdirSync(projectRoot, { recursive: true });
+    }
+    const requirementsRoot = path_1.default.join(projectRoot, "requirements", "backlog");
+    fs_1.default.mkdirSync(requirementsRoot, { recursive: true });
+    const metadataPath = path_1.default.join(projectRoot, "metadata.json");
+    let metadata;
+    if (fs_1.default.existsSync(metadataPath)) {
+        metadata = JSON.parse(fs_1.default.readFileSync(metadataPath, "utf-8"));
+    }
+    else {
+        const now = new Date().toISOString();
+        metadata = {
+            name,
+            status: "backlog",
+            domain,
+            createdAt: now,
+            updatedAt: now
+        };
+        fs_1.default.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2), "utf-8");
+    }
+    const indexRaw = fs_1.default.readFileSync(workspace.indexPath, "utf-8");
+    const index = JSON.parse(indexRaw);
+    index.projects = index.projects ?? [];
+    const existing = index.projects.find((project) => project.name === name);
+    if (existing) {
+        existing.status = metadata.status;
+    }
+    else {
+        index.projects.push({ name, status: metadata.status });
+    }
+    fs_1.default.writeFileSync(workspace.indexPath, JSON.stringify(index, null, 2), "utf-8");
+    return metadata;
+}
+function createProject(workspace, name, domain) {
+    return ensureProject(workspace, name, domain);
+}
+function updateProjectStatus(workspace, name, status) {
+    ensureWorkspace(workspace);
+    const indexRaw = fs_1.default.readFileSync(workspace.indexPath, "utf-8");
+    const index = JSON.parse(indexRaw);
+    index.projects = index.projects ?? [];
+    const existing = index.projects.find((project) => project.name === name);
+    if (existing) {
+        existing.status = status;
+    }
+    else {
+        index.projects.push({ name, status });
+    }
+    fs_1.default.writeFileSync(workspace.indexPath, JSON.stringify(index, null, 2), "utf-8");
+    const projectRoot = path_1.default.join(workspace.root, name);
+    const metadataPath = path_1.default.join(projectRoot, "metadata.json");
+    if (fs_1.default.existsSync(metadataPath)) {
+        const metadata = JSON.parse(fs_1.default.readFileSync(metadataPath, "utf-8"));
+        metadata.status = status;
+        metadata.updatedAt = new Date().toISOString();
+        fs_1.default.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2), "utf-8");
+    }
+}

package/flows/ADMISSIONS_ADMIN.md

@@ -0,0 +1,33 @@
+# Flow: Admissions admin
+
+## Goal
+Manage applications, documents, approvals, and communication with clear audit trails.
+
+## Discovery prompts
+- What application stages exist (submitted, reviewed, approved, waitlist)?
+- What documents are required and how are they verified?
+- Who has approval authority and what rules apply?
+- Are there quotas or priority rules?
+- What integrations exist (email, CRM, identity verification)?
+
+## Required artifacts
+- `requirement.md` with eligibility and decision rules
+- `functional-spec.md` for intake, review, and decision workflows
+- `technical-spec.md` for document verification and notifications
+- `architecture.md` including workflow engine and queueing
+- `test-plan.md` for fairness and correctness checks
+
+## Risk and compliance
+- Data privacy and retention
+- Bias and fairness risks
+- Auditability for decisions
+
+## Acceptance criteria examples
+- Every decision is traceable to a reviewer and criteria.
+- Documents cannot be edited without history tracking.
+- Applicants get status updates within defined time windows.
+
+## Recommended outputs
+- Application pipeline dashboard
+- Document verification checklist
+- Decision audit report

package/flows/ART.md

@@ -0,0 +1,33 @@
+# Flow: Art project
+
+## Goal
+Create an art piece or series with a clear concept, process, and critique cycle.
+
+## Discovery prompts
+- What is the concept or theme?
+- What medium and format are required?
+- What is the audience or exhibition context?
+- What is the timeline and budget?
+- What references or inspirations apply?
+
+## Required artifacts
+- `requirement.md` with concept and constraints
+- `functional-spec.md` for narrative or interaction flow
+- `technical-spec.md` for materials and production steps
+- `architecture.md` for series structure or installation layout
+- `test-plan.md` for critique and iteration checkpoints
+
+## Risk and compliance
+- Material constraints and safety
+- Copyright and reference usage
+- Delivery and installation risks
+
+## Acceptance criteria examples
+- Concept is clear and articulated.
+- Production steps are feasible in the timeline.
+- Final piece aligns with exhibition constraints.
+
+## Recommended outputs
+- Concept brief
+- Production plan
+- Critique log

package/flows/BUG_FIX.md

@@ -0,0 +1,32 @@
+# Flow: Bug fix
+
+## Goal
+Diagnose, fix, and verify a production or QA bug with minimal regression risk.
+
+## Discovery prompts
+- What is the exact observed behavior?
+- What is the expected behavior?
+- Steps to reproduce (deterministic if possible)
+- Environment details (version, OS, data)
+- Impact and severity
+
+## Required artifacts
+- `requirement.md` with bug description and scope
+- `functional-spec.md` focusing on expected behavior
+- `technical-spec.md` with root cause and fix strategy
+- `test-plan.md` with repro and regression checks
+
+## Risk and compliance
+- Hidden dependencies and regressions
+- Data corruption risk
+- SLA impact
+
+## Acceptance criteria examples
+- Bug can no longer be reproduced.
+- No regressions in related flows.
+- A regression test is added.
+
+## Recommended outputs
+- Root cause analysis
+- Fix plan
+- Rollback plan if needed

package/flows/COURT_SYSTEM.md

@@ -0,0 +1,33 @@
+# Flow: Court system
+
+## Goal
+Manage case intake, hearings, rulings, and records with strict auditability and compliance.
+
+## Discovery prompts
+- What case types and jurisdictions are included?
+- What rules govern access and privacy?
+- What is the expected SLA for filings and responses?
+- What are the archival and retention requirements?
+- What integrations exist with external justice systems?
+
+## Required artifacts
+- `requirement.md` with legal constraints and actors
+- `functional-spec.md` for filing, scheduling, and ruling flows
+- `technical-spec.md` for access control and audit logs
+- `architecture.md` for resiliency and record management
+- `test-plan.md` for permissions and compliance verification
+
+## Risk and compliance
+- Evidence integrity and chain of custody
+- Unauthorized access risks
+- Retention and public records compliance
+
+## Acceptance criteria examples
+- All case actions are logged and immutable.
+- Access is enforced by role and jurisdiction.
+- Records can be produced for audit in minutes.
+
+## Recommended outputs
+- Court docket workflow
+- Evidence chain-of-custody log
+- Compliance audit pack

package/flows/DATA_SCIENTIST.md

@@ -0,0 +1,33 @@
+# Flow: Data scientist
+
+## Goal
+Deliver a data product or model with reproducible experiments and measurable impact.
+
+## Discovery prompts
+- What business or research question are we answering?
+- What data sources exist and what is their quality?
+- What are the target metrics (accuracy, recall, ROI)?
+- What constraints exist (latency, cost, fairness)?
+- How will the model be monitored post-release?
+
+## Required artifacts
+- `requirement.md` with objective and success metrics
+- `functional-spec.md` for data flows and user interactions
+- `technical-spec.md` for pipelines, features, and infra
+- `architecture.md` for data storage and serving
+- `test-plan.md` for data validation and model evaluation
+
+## Risk and compliance
+- Data bias and fairness
+- Privacy and consent
+- Model drift and monitoring gaps
+
+## Acceptance criteria examples
+- Model meets minimum metric thresholds.
+- Data validation passes for all critical datasets.
+- Monitoring alerts exist for drift and anomalies.
+
+## Recommended outputs
+- Feature catalog
+- Experiment tracking plan
+- Model card summary

package/flows/ECOMMERCE.md

@@ -0,0 +1,33 @@
+# Flow: Ecommerce
+
+## Goal
+Build or extend an ecommerce platform with reliable checkout and inventory integrity.
+
+## Discovery prompts
+- What products and catalog rules exist?
+- What payment providers are used?
+- What are peak traffic expectations?
+- What are return/refund rules?
+- What are compliance requirements (PCI, taxes)?
+
+## Required artifacts
+- `requirement.md` with revenue and conversion goals
+- `functional-spec.md` for browse, cart, checkout, returns
+- `technical-spec.md` for payment and order integrations
+- `architecture.md` for scaling and availability
+- `test-plan.md` for checkout and payment validation
+
+## Risk and compliance
+- Payment failures and data leakage
+- Inventory inconsistencies
+- Peak traffic and downtime
+
+## Acceptance criteria examples
+- Checkout success rate above threshold.
+- Inventory updates are consistent across channels.
+- Payment data never stored in plaintext.
+
+## Recommended outputs
+- Checkout flow diagram
+- Fraud prevention checklist
+- Post-purchase email templates

package/flows/ECONOMICS.md

@@ -0,0 +1,33 @@
+# Flow: Economics / policy analysis
+
+## Goal
+Analyze economic scenarios or policy impacts with clear assumptions and models.
+
+## Discovery prompts
+- What policy or market question is being analyzed?
+- What scope and geography are covered?
+- What time horizon is relevant?
+- What data sources or models are required?
+- What stakeholders need the results?
+
+## Required artifacts
+- `requirement.md` with objectives and constraints
+- `functional-spec.md` for analysis flow and outputs
+- `technical-spec.md` for models and datasets
+- `architecture.md` for data pipeline and reporting
+- `test-plan.md` for sensitivity and robustness checks
+
+## Risk and compliance
+- Model assumptions and bias
+- Data quality issues
+- Overconfidence in forecasts
+
+## Acceptance criteria examples
+- Assumptions are explicit and defensible.
+- Sensitivity analysis is included.
+- Results are reproducible.
+
+## Recommended outputs
+- Assumptions log
+- Scenario matrix
+- Executive summary

package/flows/GRAPHIC_DESIGN.md

@@ -0,0 +1,33 @@
+# Flow: Graphic design
+
+## Goal
+Deliver a visual system (brand, UI, or campaign) with clear requirements and critique loops.
+
+## Discovery prompts
+- What is the brand or message?
+- Who is the audience and context?
+- What formats are required (logo, web, print, social)?
+- What references or style directions exist?
+- What are the constraints (budget, timeline, tools)?
+
+## Required artifacts
+- `requirement.md` with audience and goals
+- `functional-spec.md` for usage scenarios
+- `technical-spec.md` for file formats and delivery specs
+- `architecture.md` for design system structure
+- `test-plan.md` for accessibility and brand consistency checks
+
+## Risk and compliance
+- Trademark conflicts
+- Accessibility and contrast compliance
+- Usage inconsistency across channels
+
+## Acceptance criteria examples
+- Color palette meets contrast ratios.
+- Logo works at small and large sizes.
+- Deliverables match required formats.
+
+## Recommended outputs
+- Brand guidelines
+- Component library
+- Asset delivery checklist

package/flows/HISTORY.md

@@ -0,0 +1,33 @@
+# Flow: History research
+
+## Goal
+Produce a credible historical analysis with sources, timelines, and context.
+
+## Discovery prompts
+- What period or region is in scope?
+- What is the research question or thesis?
+- What depth is required (overview vs academic)?
+- What sources are allowed or preferred?
+- What format is required (essay, lecture, timeline)?
+
+## Required artifacts
+- `requirement.md` with scope and thesis
+- `functional-spec.md` for narrative flow
+- `technical-spec.md` for citation style and source rules
+- `architecture.md` for section structure
+- `test-plan.md` for source verification and bias checks
+
+## Risk and compliance
+- Source bias and reliability
+- Misinterpretation of primary sources
+- Citation or attribution mistakes
+
+## Acceptance criteria examples
+- Claims are supported by sources.
+- Timeline is consistent and verifiable.
+- Multiple perspectives are represented.
+
+## Recommended outputs
+- Annotated bibliography
+- Timeline map
+- Thesis refinement log

package/flows/LAWYER.md

@@ -0,0 +1,34 @@
+# Flow: Lawyer (legal practice)
+
+## Goal
+Build a system to manage cases, documents, deadlines, and client communication with strong audit trails.
+
+## Discovery prompts
+- What case types are supported (civil, criminal, corporate)?
+- What jurisdictions and compliance rules apply?
+- What data is sensitive or privileged?
+- Who are the actors (partners, associates, paralegals, clients)?
+- What are the legal deadlines and escalation rules?
+
+## Required artifacts
+- `requirement.md` with scope and compliance constraints
+- `functional-spec.md` including case lifecycle and document review flows
+- `technical-spec.md` detailing access control and audit logging
+- `architecture.md` with secure storage and encryption at rest
+- `test-plan.md` with permission boundary tests
+- `decision-log/ADR-XXXX.md` for storage and retention choices
+
+## Risk and compliance
+- Data confidentiality (client privilege)
+- Retention and legal hold policies
+- Audit trails for all access and edits
+
+## Acceptance criteria examples
+- Every document access is logged with user, timestamp, and reason.
+- Retention rules can be configured per case type.
+- Access is role-based and least-privilege by default.
+
+## Recommended outputs
+- Secure storage and audit module
+- Role-based access matrix
+- Case timeline dashboard

package/flows/PROGRAMMER.md

@@ -0,0 +1,33 @@
+# Flow: Programmer
+
+## Goal
+Implement a feature or system change with clean code, tests, and documentation.
+
+## Discovery prompts
+- What is the feature and who needs it?
+- What are the acceptance criteria?
+- What existing code areas are impacted?
+- What constraints exist (performance, security, compatibility)?
+- What is the expected rollout strategy?
+
+## Required artifacts
+- `requirement.md` with scope and constraints
+- `functional-spec.md` for behavior and edge cases
+- `technical-spec.md` for design and dependencies
+- `architecture.md` for component-level impact
+- `test-plan.md` for coverage and regression
+
+## Risk and compliance
+- Regression risk on critical flows
+- Backward compatibility
+- Operational impacts
+
+## Acceptance criteria examples
+- Feature works in primary and edge scenarios.
+- Tests cover new logic and critical regressions.
+- Documentation updated for users and developers.
+
+## Recommended outputs
+- Implementation plan
+- Code review checklist
+- Rollout plan

package/flows/PR_REVIEW.md

@@ -0,0 +1,33 @@
+# Flow: PR review (code review)
+
+## Goal
+Resolve pull request feedback with high confidence, clean changes, and documented decisions.
+
+## Discovery prompts
+- What repository and PR link should be reviewed?
+- What is the target branch and scope of the PR?
+- Are there blocking comments or requested changes?
+- What tests or checks are required?
+- Are there deadlines or merge constraints?
+
+## Required artifacts
+- `requirement.md` with review objectives
+- `functional-spec.md` summarizing behavior expectations
+- `technical-spec.md` with planned fixes
+- `test-plan.md` covering affected areas
+- `progress-log.md` for review status
+
+## Risk and compliance
+- Regression risk from changes
+- Breaking API or behavior changes
+- Incomplete test coverage
+
+## Acceptance criteria examples
+- All review comments addressed or resolved.
+- Changes validated by tests or checks.
+- Summary of changes posted back to PR.
+
+## Recommended outputs
+- Review checklist
+- Change summary for PR comments
+- Verified test results

package/flows/README.md

@@ -0,0 +1,29 @@
+# Flows (domain playbooks)
+
+These flows show how the tool should guide real users from discovery to completion.
+
+- `LAWYER.md`
+- `TEACHER.md`
+- `ADMISSIONS_ADMIN.md`
+- `STATE_ADMIN.md`
+- `TAXES_ADMIN.md`
+- `STUDENT_UNIVERSITY.md`
+- `DATA_SCIENTIST.md`
+- `PROGRAMMER.md`
+- `BUG_FIX.md`
+- `ECOMMERCE.md`
+- `RETAIL_STORE.md`
+- `COURT_SYSTEM.md`
+- `GRAPHIC_DESIGN.md`
+- `ART.md`
+- `HISTORY.md`
+- `SOCIOLOGY.md`
+- `ECONOMICS.md`
+- `PR_REVIEW.md`
+
+Each flow includes:
+- Discovery questions
+- Required artifacts
+- Risk and compliance notes
+- Acceptance criteria examples
+- Recommended outputs and handoff steps