Initial import from codebase-sysmledgraph

Made-with: Cursor

Author: chouswei

.cursor/mcp.json

@@ -0,0 +1,16 @@
+{
+  "mcpServers": {
+    "sysml-v2": {
+      "command": "node",
+      "args": ["node_modules/sysml-v2-lsp/dist/server/mcpServer.js"]
+    },
+    "gitnexus": {
+      "command": "npx",
+      "args": ["-y", "gitnexus@latest", "mcp"]
+    },
+    "context7": {
+      "command": "npx",
+      "args": ["-y", "@upstash/context7-mcp@latest"]
+    }
+  }
+}

.gitignore

@@ -0,0 +1,14 @@
+node_modules/
+dist/
+*.log
+.env
+.sysmledgraph/
+.sysmledgraph-*/
+.sysmledgraph-index-result.txt
+graph-export.json
+graph-map*.md
+analyze-out.txt
+.gitnexus
+*.tsbuildinfo
+coverage/
+.cache/

.npmrc

@@ -0,0 +1,2 @@
+# Optional: use Git Bash for npm scripts on Windows if a dependency needs Unix-style shell
+# script-shell=C:\\Program Files\\git\\bin\\bash.exe

.nvmrc

@@ -0,0 +1 @@
+20

bin/cli.ts

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+/**
+ * CLI entrypoint: analyze, list, clean.
+ */
+
+import { program } from 'commander';
+import {
+  configureStorageRoot,
+  cmdAnalyze,
+  cmdList,
+  cmdClean,
+} from '../src/cli/commands.js';
+
+program
+  .name('sysmledgraph')
+  .description('Path-only SysML indexer: knowledge graph, MCP server, CLI')
+  .option('--storage <path>', 'Storage root (default: ~/.sysmledgraph)', process.env.SYSMEDGRAPH_STORAGE_ROOT);
+
+program
+  .command('analyze <paths...>', { isDefault: true })
+  .description('Index path(s): discover .sysml, build graph')
+  .action(async (paths: string[]) => {
+    const opts = program.opts();
+    configureStorageRoot(opts.storage);
+    if (paths.length > 0) {
+      process.stderr.write(`Indexing ${paths.length} path(s)...\n`);
+    }
+    const result = await cmdAnalyze(paths);
+    if (!result.ok) {
+      process.stderr.write((result.error ?? 'Unknown error') + '\n');
+      if (result.filesProcessed !== undefined && result.filesProcessed > 0) {
+        process.stderr.write(`(Indexed ${result.filesProcessed} file(s) before error.)\n`);
+      }
+      process.exit(1);
+    }
+    const n = result.filesProcessed ?? 0;
+    process.stderr.write(`Indexed ${n} file(s).\n`);
+  });
+
+program
+  .command('list')
+  .description('List indexed path(s)')
+  .action(async () => {
+    configureStorageRoot(program.opts().storage);
+    const result = await cmdList();
+    if (!result.ok) {
+      process.stderr.write((result.error ?? 'Unknown error') + '\n');
+      process.exit(1);
+    }
+    for (const p of result.paths) {
+      console.log(p);
+    }
+  });
+
+program
+  .command('clean [path]')
+  .description('Remove index for path or all')
+  .action(async (path?: string) => {
+    configureStorageRoot(program.opts().storage);
+    const result = await cmdClean(path);
+    if (!result.ok) {
+      process.stderr.write((result.error ?? 'Unknown error') + '\n');
+      process.exit(1);
+    }
+  });
+
+program.parseAsync().catch((err: Error) => {
+  process.stderr.write(String(err) + '\n');
+  process.exit(1);
+});

modelbase-development/config.yaml

@@ -0,0 +1,17 @@
+# Modelbase Development – workflow and iteration across software, hardware, mechanism, system deployment.
+# Kernel + ScalarValues only.
+default_diagram_type: bdd
+auto_generate: [bdd, ibd]
+deployment_part: ModelbaseDevelopmentDeployment
+show_inventree_stock: false
+show_clickup_status: false
+color_by_status: false
+
+model_dir: models
+model_files:
+  - ../../../libs/omg/SysML-v2-Release/sysml.library/Kernel Libraries/Kernel Semantic Library/Base.kerml
+  - ../../../libs/omg/SysML-v2-Release/sysml.library/Kernel Libraries/Kernel Data Type Library/ScalarValues.kerml
+  - requirements-modelbase-development.sysml
+  - deploy-modelbase-development.sysml
+  - behaviour-modelbase-development.sysml
+  - project-modelbase-development.sysml

modelbase-development/models/behaviour-modelbase-development.sysml

@@ -0,0 +1,97 @@
+/*
+  Model-based development behaviour: Plan flows to implement side (develop);
+  report flows from implement side to modelbase. Only modelbase decides if
+  iteration is done and updates plan for next iteration. Plan → develop →
+  deploy → integrate → verify → report → update (decide); repeat = iteration.
+*/
+package ModelbaseDevelopmentBehaviour {
+  private import ModelbaseDevelopment::*;
+  private import ModelbaseDevelopmentRequirements::*;
+
+  action def Plan {
+    doc /* Modelbase: produce or update the plan (to do) from the model. */
+    out item plan : DevelopmentPlan;
+    satisfy ReqWorkflowDescribed;
+    satisfy ReqPlanFromModelbase;
+  }
+
+  action def DoSoftwareDevelopment {
+    doc /* Implement side (e.g. codebase): execute software development against plan and model. */
+    in item plan : DevelopmentPlan;
+    satisfy ReqWorkflowDescribed;
+  }
+
+  action def DoHardwareDevelopment {
+    doc /* Implement side (e.g. hardware repo): execute hardware development against plan and model. */
+    in item plan : DevelopmentPlan;
+    satisfy ReqWorkflowDescribed;
+  }
+
+  action def DoMechanismDevelopment {
+    doc /* Implement side (e.g. mechanism repo): execute mechanism development against plan and model. */
+    in item plan : DevelopmentPlan;
+    satisfy ReqWorkflowDescribed;
+  }
+
+  action def DoSystemDeployment {
+    doc /* Implement side (e.g. deployment repo): define and execute system deployment (integration, topology). */
+    in item plan : DevelopmentPlan;
+    satisfy ReqWorkflowDescribed;
+  }
+
+  action def Integrate {
+    doc /* Implement side: integrate SW/HW/mechanism outputs into the system. */
+    satisfy ReqWorkflowDescribed;
+  }
+
+  action def Verify {
+    doc /* Implement side: verify implementation vs plan and model; feeds implement report. */
+    satisfy ReqWorkflowDescribed;
+  }
+
+  action def ProduceImplementReport {
+    doc /* Implement side: produce implement report (alignment, gaps, traceability); deliver to modelbase. Implement side only gives the report; does not decide if iteration is done. */
+    out item report : ImplementReport;
+    satisfy ReqWorkflowDescribed;
+    satisfy ReqReportFromImplementSide;
+    satisfy ReqTraceability;
+  }
+
+  action def UpdateModelFromGaps {
+    doc /* Modelbase: receive report; decide whether iteration is done; if done, update plan for next iteration (or close); if not, plan unchanged. Only modelbase decides. */
+    in item report : ImplementReport;
+    satisfy ReqIteration;
+    satisfy ReqWorkflowDescribed;
+    satisfy ReqPlanFromModelbase;
+    satisfy ReqDecideByModelbase;
+  }
+
+  action def ModelBasedDevelopmentIteration {
+    doc /* One iteration: plan → develop → report → update. Only modelbase decides if iteration is done and updates plan for next iteration; implement side only delivers report. Repeat. */
+    action plan : Plan;
+    action doSoftware : DoSoftwareDevelopment;
+    action doHardware : DoHardwareDevelopment;
+    action doMechanism : DoMechanismDevelopment;
+    action doDeploy : DoSystemDeployment;
+    action integrate : Integrate;
+    action verify : Verify;
+    action produceImplementReport : ProduceImplementReport;
+    action updateFromGaps : UpdateModelFromGaps;
+    flow from plan.plan to doSoftware.plan;
+    flow from plan.plan to doHardware.plan;
+    flow from plan.plan to doMechanism.plan;
+    flow from plan.plan to doDeploy.plan;
+    flow from produceImplementReport.report to updateFromGaps.report;
+    then plan;
+    then doSoftware;
+    then doHardware;
+    then doMechanism;
+    then doDeploy;
+    then integrate;
+    then verify;
+    then produceImplementReport;
+    then updateFromGaps;
+    satisfy ReqWorkflowDescribed;
+    satisfy ReqIteration;
+  }
+}

modelbase-development/models/deploy-modelbase-development.sysml

@@ -0,0 +1,90 @@
+/*
+  Model-based development structure: modelbase, implement side, and four domains.
+  Plan and report flow between modelbase and implement side. Per domain the
+  implement side may be named e.g. codebase (software), hardware repo,
+  mechanism repo, deployment repo.
+*/
+package ModelbaseDevelopment {
+  private import ModelbaseDevelopmentRequirements::*;
+
+  item def DevelopmentPlan {
+    doc /* Plan (to do) generated by modelbase; flows to implement side (e.g. codebase) as implementation guide. */
+  }
+
+  item def ImplementReport {
+    doc /* Implement report (alignment, gaps, traceability) generated by implement side; flows to modelbase. Implement side only delivers it; only modelbase decides if iteration is done. */
+  }
+
+  part def ModelRequirements {
+    doc /* Requirements pillar of the SysML model: requirement definitions, satisfy/derive/verify. */
+  }
+
+  part def ModelStructure {
+    doc /* Structure pillar: blocks, parts, connections, ports; deploy and BDD/IBD. */
+  }
+
+  part def ModelBehaviour {
+    doc /* Behaviour pillar: actions, activities, state machines; workflow and iteration. */
+  }
+
+  part def PlanToDo {
+    doc /* Development plan (to do): checkable steps, phases, implementation layout (e.g. CODEBASE_STRUCTURE); generated from the model; flows out as DevelopmentPlan item. */
+  }
+
+  part def Modelbase {
+    doc /*
+      Holds the model and the plan; generates the plan (to do); receives implement report.
+      Only the modelbase decides whether an iteration is done; when done, updates the plan
+      for the next iteration (or closes). Composed of requirements, structure, behaviour,
+      and plan artifact.
+    */
+    part modelRequirements : ModelRequirements;
+    part modelStructure : ModelStructure;
+    part modelBehaviour : ModelBehaviour;
+    part planToDo : PlanToDo;
+    satisfy ReqPlanFromModelbase;
+    satisfy ReqDecideByModelbase;
+  }
+
+  part def ImplementSide {
+    doc /*
+      Implements against plan and model; produces and delivers the implement report
+      (alignment, gaps, traceability). Only gives the report; does not decide if
+      iteration is done. Per domain may be named e.g. codebase (software), hardware
+      repo, mechanism repo, deployment repo.
+    */
+    satisfy ReqReportFromImplementSide;
+    satisfy ReqTraceability;
+  }
+
+  part def SoftwareDevelopment {
+    doc /* Software development: design and implementation against the model and plan. */
+    satisfy ReqFourDomains;
+  }
+
+  part def HardwareDevelopment {
+    doc /* Hardware development: electronics/PCBA (BOM, netlists, parts) aligned with the model. */
+    satisfy ReqFourDomains;
+  }
+
+  part def MechanismDevelopment {
+    doc /* Mechanism development: mechanical/mechatronic design and implementation. */
+    satisfy ReqFourDomains;
+  }
+
+  part def SystemDeployment {
+    doc /* System deployment: integration, topology, operational configuration. */
+    satisfy ReqFourDomains;
+  }
+
+  part def ModelbaseDevelopmentDeployment {
+    doc /* Composite: modelbase + implement side + four development domains. Workflow and iteration in behaviour. */
+    part modelbase : Modelbase;
+    part implementSide : ImplementSide;
+    part softwareDevelopment : SoftwareDevelopment;
+    part hardwareDevelopment : HardwareDevelopment;
+    part mechanismDevelopment : MechanismDevelopment;
+    part systemDeployment : SystemDeployment;
+    satisfy ReqFourDomains;
+  }
+}

modelbase-development/models/project-modelbase-development.sysml

@@ -0,0 +1,10 @@
+/*
+  Project-level grouping for modelbase-development. Imports all project packages.
+  Convention: project-<name>.sysml contains package Project<NamePascalCase> that
+  imports requirements, deploy, behaviour.
+*/
+package ProjectModelbaseDevelopment {
+  private import ModelbaseDevelopmentRequirements::*;
+  private import ModelbaseDevelopment::*;
+  private import ModelbaseDevelopmentBehaviour::*;
+}

modelbase-development/models/requirements-modelbase-development.sysml

@@ -0,0 +1,63 @@
+/*
+  Model-based development workflow: four domains, plan from modelbase, report from
+  implement side (per-domain names: e.g. codebase for software, hardware repo,
+  mechanism repo, deployment repo). Iteration, traceability.
+*/
+package ModelbaseDevelopmentRequirements {
+
+  requirement def ReqFourDomains {
+    doc /*
+      The model-based development workflow shall include the four development domains:
+      software development, hardware development, mechanism development, and system deployment.
+    */
+  }
+
+  requirement def ReqWorkflowDescribed {
+    doc /*
+      The workflow shall be described in the model (activities, actions, and their order
+      or iteration) so that plan → implement → report → update is explicit.
+    */
+  }
+
+  requirement def ReqIteration {
+    doc /*
+      The process shall support iteration: feedback from the implement report (alignment, gaps)
+      shall be usable to update the model or plan and to re-run development steps.
+    */
+  }
+
+  requirement def ReqPlanFromModelbase {
+    doc /*
+      The plan (to do: development plan, checkable steps, what to build) shall be
+      generated by the modelbase and used as the implementation guide by the
+      implement side (e.g. codebase, hardware repo, mechanism repo, deployment repo).
+    */
+  }
+
+  requirement def ReqReportFromImplementSide {
+    doc /*
+      The implement report (alignment vs plan/model, gaps, traceability) shall be
+      generated by the implement side and delivered to the modelbase for each
+      iteration. The implement side only gives the report; it does not decide
+      whether the iteration is done. Per domain the implement side may be named
+      e.g. codebase (software), hardware repo, mechanism repo, deployment repo.
+    */
+  }
+
+  requirement def ReqDecideByModelbase {
+    doc /*
+      Only the modelbase shall decide whether an iteration is done (after
+      reviewing the implement report). When the modelbase decides done, it
+      updates the plan for the next iteration (or closes). When not done,
+      the implement side continues with the same or updated plan.
+    */
+  }
+
+  requirement def ReqTraceability {
+    doc /*
+      The implement side shall produce traceability from plan steps to implementation
+      (e.g. IMPLEMENTATION_PLAN.md: step, plan, implementation paths) as part of the
+      implement report. Per domain: codebase, hardware repo, etc.
+    */
+  }
+}