@jstn-sdk/ma 0.1.5 → 0.1.7

package/src/launcher.js

@@ -1,52 +1,56 @@
 import { spawnSync } from "node:child_process";
 import path from "node:path";
 
-const maintenanceCommands = new Set([
+const nativeCommands = new Set([
   "setup",
   "init",
-  "doctor",
   "idea",
   "skills",
+  "sdk-path",
   "status",
-  "run",
   "merge",
   "release",
+  "run",
 ]);
 
 export function shouldDelegateToCodex(args) {
   if (args.length === 0) {
-    return false;
+    return true;
   }
 
-  const first = args[0];
-  return first.startsWith("-") || !maintenanceCommands.has(first);
+  return !nativeCommands.has(args[0]);
 }
 
-export function normalizeCodexArgs(args) {
+function normalizeCodexArgs(args) {
   return args.filter((arg) => arg !== "--madmax" && arg !== "--high");
 }
 
 function resolveCodexCommand() {
-  return process.env.MA_CODEX_BIN ?? "codex";
+  if (process.env.MA_CODEX_BIN) {
+    return process.env.MA_CODEX_BIN;
+  }
+
+  return "codex";
 }
 
 export function runCodex(args) {
   const codexCommand = resolveCodexCommand();
   const codexArgs = normalizeCodexArgs(args);
-  const useNode = path.extname(codexCommand) === ".js" || path.extname(codexCommand) === ".mjs";
-  const command = useNode ? process.execPath : codexCommand;
-  const finalArgs = useNode ? [codexCommand, ...codexArgs] : codexArgs;
-  const result = spawnSync(command, finalArgs, {
-    stdio: "inherit",
-  });
+  const commandArgs =
+    path.extname(codexCommand) === ".js" || path.extname(codexCommand) === ".mjs"
+      ? [codexCommand, ...codexArgs]
+      : codexArgs;
+  const command = commandArgs[0] === codexCommand ? process.execPath : codexCommand;
+  const finalArgs = command === process.execPath ? commandArgs : codexArgs;
+  const result = spawnSync(command, finalArgs, { stdio: "inherit" });
 
   if (result.error) {
     if (result.error.code === "ENOENT") {
-      throw new Error("Codex CLI not found. Install it with: npm i -g @openai/codex");
+      throw new Error("Codex not found. Install it with: npm install -g @openai/codex");
     }
 
-    throw new Error(`Failed to start Codex CLI: ${result.error.message}`);
+    throw new Error(`Failed to start Codex: ${result.error.message}`);
   }
 
-  return result.status ?? 1;
+  return typeof result.status === "number" ? result.status : 1;
 }

package/src/mcp-live-client.js

@@ -38,7 +38,7 @@ export class McpSseClient {
       capabilities: {},
       clientInfo: {
         name: "meta-architect",
-        version: "1.0.0",
+        version: "0.1.7",
       },
     });
 

package/src/paths.js

@@ -5,46 +5,22 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
 export const packageRoot = path.resolve(__dirname, "..");
-export function getPackageRoot() {
-  return packageRoot;
-}
-
 export function getRepoRoot() {
-  return path.resolve(process.env.MA_ROOT ?? process.cwd());
-}
-
-export function resolveRepoPath(...parts) {
-  return path.join(getRepoRoot(), ...parts);
+  return process.env.MA_ROOT ? path.resolve(process.env.MA_ROOT) : process.cwd();
 }
 
-export function getOmxRoot() {
-  return resolveRepoPath(".omx");
+export function getRuntimeRoot() {
+  return path.join(getRepoRoot(), ".ma");
 }
 
-export function getReleaseStatePath() {
-  return path.join(getOmxRoot(), "release.json");
+export function getRuntimeWritePath(...parts) {
+  return path.join(getRuntimeRoot(), ...parts);
 }
 
-export function getDecisionsPath() {
-  return path.join(getOmxRoot(), "decisions.json");
+export function getRuntimeReadPath(...parts) {
+  return path.join(getRuntimeRoot(), ...parts);
 }
 
 export function getMcpServersPath() {
-  return resolveRepoPath("mcp", "servers.json");
-}
-
-export function getSourcesPath() {
-  return path.join(getOmxRoot(), "evidence", "sources.json");
-}
-
-export function getAuditsPath() {
-  return path.join(getOmxRoot(), "evidence", "audits.json");
-}
-
-export function getOutcomesPath() {
-  return path.join(getOmxRoot(), "evidence", "outcomes.json");
-}
-
-export function getCvesPath() {
-  return path.join(getOmxRoot(), "evidence", "cves.json");
+  return path.join(getRepoRoot(), "mcp", "servers.json");
 }

package/src/release-state.js

@@ -1,6 +1,6 @@
 import fs from "node:fs/promises";
 import { writeJson } from "./fs-utils.js";
-import { getReleaseStatePath } from "./paths.js";
+import { getRuntimeReadPath, getRuntimeWritePath } from "./paths.js";
 
 const allowedStatuses = {
   idea_status: ["DRAFT", "CLEAR", "BLOCKED"],
@@ -43,7 +43,7 @@ export function validateReleaseState(state) {
 }
 
 export async function loadReleaseState() {
-  const raw = await fs.readFile(getReleaseStatePath(), "utf8");
+  const raw = await fs.readFile(getRuntimeReadPath("release.json"), "utf8");
   const parsed = JSON.parse(raw);
   return validateReleaseState(parsed);
 }
@@ -54,6 +54,6 @@ export async function saveReleaseState(state) {
     ...state,
     updatedAt: new Date().toISOString(),
   };
-  await writeJson(getReleaseStatePath(), next);
+  await writeJson(getRuntimeWritePath("release.json"), next);
   return next;
 }

package/src/runtime-artifacts.js

@@ -0,0 +1,411 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { ensureDir, writeFileIfMissing } from "./fs-utils.js";
+import { getRuntimeWritePath } from "./paths.js";
+
+const runtimeDirs = ["context", "specs", "plans"];
+
+function renderProjectContext({ idea = null }) {
+  return [
+    "# Project Context",
+    "",
+    `Updated: ${new Date().toISOString()}`,
+    "",
+    "## Current Brief",
+    "",
+    idea ?? 'No project brief captured yet. Run `ma idea "..."` first.',
+    "",
+    "## Source Of Truth",
+    "",
+    "- `.ma/decisions.json` tracks gate and decision history",
+    "- `.ma/release.json` tracks release-state fields",
+    "- `.ma/runbook.md` defines the local helper workflow",
+    "",
+    "## Next Recommended Trigger",
+    "",
+    idea ? "`$arch`" : "`ma idea`",
+    "",
+  ].join("\n");
+}
+
+function renderArchitectureSpec({ idea, blueprint }) {
+  return [
+    "# Architecture Spec",
+    "",
+    `Updated: ${new Date().toISOString()}`,
+    "",
+    "## Problem Statement",
+    "",
+    idea,
+    "",
+    "## Blueprint Summary",
+    "",
+    blueprint.summary,
+    "",
+    "## Suggested Stack",
+    "",
+    ...blueprint.suggestedStack.map((item) => `- ${item}`),
+    "",
+    "## Intended Outcome",
+    "",
+    blueprint.outcome,
+    "",
+    "## Next Recommended Trigger",
+    "",
+    "`$sage`",
+    "",
+  ].join("\n");
+}
+
+function renderEvidenceSpec({ idea, sourceEntries, verified, blockers }) {
+  const status = verified ? "VERIFIED" : sourceEntries.length > 0 ? "PARTIAL" : "MISSING";
+  const lines = [
+    "# Evidence Spec",
+    "",
+    `Updated: ${new Date().toISOString()}`,
+    "",
+    "## Probe Basis",
+    "",
+    idea,
+    "",
+    "## Evidence Status",
+    "",
+    status,
+    "",
+    "## Sources",
+    "",
+  ];
+
+  if (sourceEntries.length === 0) {
+    lines.push("No approved GitMCP sources configured.", "");
+  } else {
+    for (const source of sourceEntries) {
+      lines.push(`- ${source.repo} (${source.category})`);
+      lines.push(`  - endpoint: ${source.endpoint}`);
+      if (source.liveProbe?.sampleText) {
+        lines.push(`  - live probe: ${source.liveProbe.sampleText}`);
+      } else if (source.liveProbe?.reason) {
+        lines.push(`  - live probe: ${source.liveProbe.reason}`);
+      } else if (source.liveProbe?.error) {
+        lines.push(`  - live probe error: ${source.liveProbe.error}`);
+      }
+    }
+    lines.push("");
+  }
+
+  lines.push("## Blockers", "");
+  if (blockers.length === 0) {
+    lines.push("None.", "");
+  } else {
+    lines.push(...blockers.map((blocker) => `- ${blocker}`), "");
+  }
+
+  lines.push("## Next Recommended Trigger", "", verified ? "`$flow`" : "`$sage`", "");
+  return lines.join("\n");
+}
+
+function renderLogicSpec(logicMap) {
+  return [
+    "# Logic Spec",
+    "",
+    `Updated: ${new Date().toISOString()}`,
+    "",
+    "## States",
+    "",
+    ...logicMap.states.map((state) => `- ${state}`),
+    "",
+    "## Blockers",
+    "",
+    ...(logicMap.blockers.length === 0 ? ["None."] : logicMap.blockers.map((item) => `- ${item}`)),
+    "",
+    "## Next Recommended Trigger",
+    "",
+    "`$vet`",
+    "",
+  ].join("\n");
+}
+
+function renderSecuritySpec({ finding, auditCount, cveCount }) {
+  return [
+    "# Security Spec",
+    "",
+    `Updated: ${new Date().toISOString()}`,
+    "",
+    "## Latest Finding",
+    "",
+    `- severity: ${finding.severity}`,
+    `- summary: ${finding.summary}`,
+    `- unresolved: ${finding.unresolved}`,
+    "",
+    "## Evidence Files",
+    "",
+    `- audits logged: ${auditCount}`,
+    `- cve entries logged: ${cveCount}`,
+    "",
+    "## Next Recommended Trigger",
+    "",
+    "`$vibe`",
+    "",
+  ].join("\n");
+}
+
+function renderExperienceSpec({ note, outcomeCount }) {
+  return [
+    "# Experience Spec",
+    "",
+    `Updated: ${new Date().toISOString()}`,
+    "",
+    "## Latest Outcome",
+    "",
+    `- area: ${note.area}`,
+    `- summary: ${note.summary}`,
+    "",
+    "## Evidence Files",
+    "",
+    `- outcomes logged: ${outcomeCount}`,
+    "",
+    "## Next Recommended Trigger",
+    "",
+    "`$build`",
+    "",
+  ].join("\n");
+}
+
+function renderImplementationPlan({ idea, blueprint }) {
+  return [
+    "# Implementation Plan",
+    "",
+    `Updated: ${new Date().toISOString()}`,
+    "",
+    "## Goal",
+    "",
+    idea,
+    "",
+    "## Planned Phases",
+    "",
+    "- Capture the approved architecture baseline",
+    "- Validate evidence through approved GitMCP sources",
+    "- Validate logic and state transitions",
+    "- Review security and experience gates",
+    "- Unlock bounded build execution",
+    "",
+    "## Architecture Anchor",
+    "",
+    blueprint.summary,
+    "",
+  ].join("\n");
+}
+
+function renderMaestroPlan({ releaseState, recommendation }) {
+  return [
+    "# Maestro Plan",
+    "",
+    `Updated: ${new Date().toISOString()}`,
+    "",
+    "## Current Gate State",
+    "",
+    `- idea: ${releaseState.idea_status}`,
+    `- architecture: ${releaseState.architecture_status}`,
+    `- evidence: ${releaseState.evidence_status}`,
+    `- logic: ${releaseState.logic_status}`,
+    `- security: ${releaseState.security_status}`,
+    `- experience: ${releaseState.experience_status}`,
+    `- build: ${releaseState.build_status}`,
+    "",
+    "## Best Next Step",
+    "",
+    recommendation.nextStep,
+    "",
+    "## Why This Is Next",
+    "",
+    recommendation.why,
+    "",
+    "## Recommended Lane",
+    "",
+    `- primary: ${recommendation.primaryLane}`,
+    `- support: ${recommendation.supportLane}`,
+    "",
+    "## Suggested Assignment",
+    "",
+    ...recommendation.assignments.map((item) => `- ${item}`),
+    "",
+    "## Avoid For Now",
+    "",
+    ...recommendation.avoid.map((item) => `- ${item}`),
+    "",
+    "## Exact Next Trigger",
+    "",
+    recommendation.nextTrigger,
+    "",
+  ].join("\n");
+}
+
+function renderBuildPlan({ allowed, blockers, nextTriggers, suggestedBranches = [] }) {
+  const lines = [
+    "# Build Plan",
+    "",
+    `Updated: ${new Date().toISOString()}`,
+    "",
+    "## Gate State",
+    "",
+    allowed ? "READY" : "LOCKED",
+    "",
+    "## Blockers",
+    "",
+  ];
+
+  if (blockers.length === 0) {
+    lines.push("None.", "");
+  } else {
+    lines.push(...blockers.map((blocker) => `- ${blocker}`), "");
+  }
+
+  lines.push("## Next Allowed Triggers", "");
+  lines.push(
+    ...(nextTriggers.length === 0 ? ["- $build"] : nextTriggers.map((item) => `- ${item}`)),
+    "",
+  );
+
+  if (suggestedBranches.length > 0) {
+    lines.push(
+      "## Suggested Branches",
+      "",
+      ...suggestedBranches.map((branch) => `- ${branch}`),
+      "",
+    );
+  }
+
+  return lines.join("\n");
+}
+
+function renderRunbook() {
+  return [
+    "# Meta-Architect Runbook",
+    "",
+    "## Purpose",
+    "",
+    "This runbook defines the local helper-path workflow that supports the primary in-session skill flow.",
+    "",
+    "## Canonical Sequence",
+    "",
+    "1. `ma setup`",
+    '2. `ma idea "..."`',
+    "3. `ma run '$arch'`",
+    "4. `ma run '$sage'`",
+    "5. `ma run '$flow'`",
+    "6. `ma run '$vet'`",
+    "7. `ma run '$vibe'`",
+    "8. `ma status`",
+    "9. `ma run '$build'`",
+    "",
+    "## Runtime Artifacts",
+    "",
+    "- `.ma/context/project.md`",
+    "- `.ma/specs/architecture.md`",
+    "- `.ma/specs/evidence.md`",
+    "- `.ma/specs/logic.md`",
+    "- `.ma/specs/security.md`",
+    "- `.ma/specs/experience.md`",
+    "- `.ma/plans/implementation.md`",
+    "- `.ma/plans/build.md`",
+    "- `.ma/decisions.json`",
+    "- `.ma/release.json`",
+    "",
+    "## Guardrails",
+    "",
+    "- Do not edit gate status files manually.",
+    "- Treat GitHub release state and npm registry state as separate facts.",
+    "- Do not claim a publish channel succeeded without evidence from that channel.",
+    "",
+  ].join("\n");
+}
+
+async function writeArtifact(relativePath, content) {
+  const target = getRuntimeWritePath(...relativePath.split("/"));
+  await ensureDir(path.dirname(target));
+  await fs.writeFile(target, `${content.trimEnd()}\n`);
+}
+
+export async function seedRuntimeArtifacts() {
+  for (const dir of runtimeDirs) {
+    await ensureDir(getRuntimeWritePath(dir));
+  }
+
+  await writeFileIfMissing(
+    getRuntimeWritePath("context", "project.md"),
+    `${renderProjectContext({})}\n`,
+  );
+  await writeFileIfMissing(
+    getRuntimeWritePath("specs", "architecture.md"),
+    "# Architecture Spec\n\nNo architecture captured yet.\n",
+  );
+  await writeFileIfMissing(
+    getRuntimeWritePath("specs", "evidence.md"),
+    "# Evidence Spec\n\nNo evidence captured yet.\n",
+  );
+  await writeFileIfMissing(
+    getRuntimeWritePath("specs", "logic.md"),
+    "# Logic Spec\n\nNo logic review captured yet.\n",
+  );
+  await writeFileIfMissing(
+    getRuntimeWritePath("specs", "security.md"),
+    "# Security Spec\n\nNo security review captured yet.\n",
+  );
+  await writeFileIfMissing(
+    getRuntimeWritePath("specs", "experience.md"),
+    "# Experience Spec\n\nNo experience review captured yet.\n",
+  );
+  await writeFileIfMissing(
+    getRuntimeWritePath("plans", "implementation.md"),
+    "# Implementation Plan\n\nNo implementation plan captured yet.\n",
+  );
+  await writeFileIfMissing(
+    getRuntimeWritePath("plans", "build.md"),
+    "# Build Plan\n\nBuild is still locked.\n",
+  );
+  await writeFileIfMissing(getRuntimeWritePath("runbook.md"), `${renderRunbook()}\n`);
+}
+
+export async function writeProjectContext(idea) {
+  await writeArtifact("context/project.md", renderProjectContext({ idea }));
+}
+
+export async function writeArchitectureArtifacts({ idea, blueprint }) {
+  await writeArtifact("specs/architecture.md", renderArchitectureSpec({ idea, blueprint }));
+  await writeArtifact("plans/implementation.md", renderImplementationPlan({ idea, blueprint }));
+}
+
+export async function writeEvidenceSpec({ idea, sourceEntries, verified, blockers }) {
+  await writeArtifact(
+    "specs/evidence.md",
+    renderEvidenceSpec({ idea, sourceEntries, verified, blockers }),
+  );
+}
+
+export async function writeLogicSpec(logicMap) {
+  await writeArtifact("specs/logic.md", renderLogicSpec(logicMap));
+}
+
+export async function writeSecuritySpec({ finding, auditCount, cveCount }) {
+  await writeArtifact("specs/security.md", renderSecuritySpec({ finding, auditCount, cveCount }));
+}
+
+export async function writeExperienceSpec({ note, outcomeCount }) {
+  await writeArtifact("specs/experience.md", renderExperienceSpec({ note, outcomeCount }));
+}
+
+export async function writeBuildPlanArtifact({
+  allowed,
+  blockers,
+  nextTriggers,
+  suggestedBranches = [],
+}) {
+  await writeArtifact(
+    "plans/build.md",
+    renderBuildPlan({ allowed, blockers, nextTriggers, suggestedBranches }),
+  );
+}
+
+export async function writeMaestroPlan({ releaseState, recommendation }) {
+  await writeArtifact("plans/maestro.md", renderMaestroPlan({ releaseState, recommendation }));
+}