@danielblomma/cortex-mcp 0.4.5 → 0.6.4

package/scaffold/scripts/parsers/vbnet.mjs

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+/**
+ * Conditional VB.NET parser bridge for Cortex.
+ *
+ * Uses a Roslyn sidecar via `dotnet run` when a .NET runtime is available.
+ * If no runtime exists, callers should skip structured chunk extraction and
+ * fall back to plain file-level indexing.
+ */
+
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const DEFAULT_DOTNET_COMMAND = "dotnet";
+const DEFAULT_PROJECT_PATH = path.join(__dirname, "dotnet", "VbNetParser", "VbNetParser.csproj");
+
+let runtimeCache = null;
+
+function getDotnetCommand() {
+  const override = process.env.CORTEX_DOTNET_CMD;
+  return override && override.trim().length > 0 ? override.trim() : DEFAULT_DOTNET_COMMAND;
+}
+
+function getProjectPath() {
+  const override = process.env.CORTEX_VBNET_PARSER_PROJECT;
+  return override && override.trim().length > 0 ? override.trim() : DEFAULT_PROJECT_PATH;
+}
+
+export function resetVbNetParserRuntimeCache() {
+  runtimeCache = null;
+}
+
+export function getVbNetParserRuntime() {
+  if (runtimeCache) {
+    return runtimeCache;
+  }
+
+  const command = getDotnetCommand();
+  const versionProbe = spawnSync(command, ["--version"], {
+    encoding: "utf8",
+    timeout: 5000
+  });
+
+  if (versionProbe.error || versionProbe.status !== 0) {
+    runtimeCache = {
+      available: false,
+      command,
+      projectPath: getProjectPath(),
+      reason:
+        versionProbe.error?.message ||
+        versionProbe.stderr?.trim() ||
+        "dotnet runtime not available"
+    };
+    return runtimeCache;
+  }
+
+  runtimeCache = {
+    available: true,
+    command,
+    projectPath: getProjectPath(),
+    version: versionProbe.stdout.trim()
+  };
+  return runtimeCache;
+}
+
+export function isVbNetParserAvailable() {
+  return getVbNetParserRuntime().available;
+}
+
+export function parseCode(code, filePath, language = "vbnet") {
+  const runtime = getVbNetParserRuntime();
+  if (!runtime.available) {
+    return { chunks: [], errors: [] };
+  }
+
+  const args = [
+    "run",
+    "--project",
+    runtime.projectPath,
+    "--configuration",
+    "Release",
+    "--",
+    "--stdin",
+    "--file",
+    filePath,
+    "--language",
+    language
+  ];
+
+  const result = spawnSync(runtime.command, args, {
+    input: code,
+    encoding: "utf8",
+    timeout: 30000,
+    maxBuffer: 10 * 1024 * 1024
+  });
+
+  if (result.error || result.status !== 0) {
+    return {
+      chunks: [],
+      errors: [
+        {
+          message:
+            result.error?.message ||
+            result.stderr?.trim() ||
+            `VB.NET parser failed with exit code ${result.status ?? "unknown"}`
+        }
+      ]
+    };
+  }
+
+  try {
+    const parsed = JSON.parse(result.stdout);
+    return {
+      chunks: Array.isArray(parsed.chunks) ? parsed.chunks : [],
+      errors: Array.isArray(parsed.errors) ? parsed.errors : []
+    };
+  } catch (error) {
+    return {
+      chunks: [],
+      errors: [
+        {
+          message: `VB.NET parser returned invalid JSON: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ]
+    };
+  }
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const fs = await import("node:fs");
+  const filePath = process.argv[2];
+
+  if (!filePath) {
+    console.error("Usage: vbnet.mjs <file.vb>");
+    process.exit(1);
+  }
+
+  const code = fs.readFileSync(filePath, "utf8");
+  const result = parseCode(code, filePath, "vbnet");
+  console.log(JSON.stringify(result, null, 2));
+}

package/scaffold/scripts/status.sh

@@ -287,10 +287,3 @@ try {
   console.log(`[status] cortex_update_check=unavailable (${message})`);
 }
 ' "$REPO_ROOT" "$REPO_ROOT/.context/cache" "${CORTEX_CLI_VERSION:-}"
-
-PLAN_SCRIPT="$REPO_ROOT/scripts/plan-state.sh"
-if [[ -x "$PLAN_SCRIPT" ]]; then
-  if ! "$PLAN_SCRIPT" show; then
-    echo "[plan] warning: failed to read plan state"
-  fi
-fi

package/scaffold/scripts/capture-note.sh

@@ -1,55 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-NOTES_DIR="$REPO_ROOT/.context/notes"
-DECISIONS_DIR="$REPO_ROOT/.context/decisions"
-
-TITLE="${1:-}"
-if [[ -z "$TITLE" ]]; then
-  echo "Usage: ./scripts/context.sh note <title> [text]"
-  exit 1
-fi
-shift || true
-
-BODY="${*:-}"
-if [[ -z "$BODY" && ! -t 0 ]]; then
-  BODY="$(cat)"
-fi
-
-mkdir -p "$NOTES_DIR" "$DECISIONS_DIR"
-
-DATE_UTC="$(date -u +"%Y-%m-%dT%H:%M:%SZ")"
-DATE_PREFIX="$(date -u +"%Y-%m-%d")"
-SLUG="$(echo "$TITLE" | tr '[:upper:]' '[:lower:]' | sed -E 's/[^a-z0-9]+/-/g; s/^-+//; s/-+$//; s/-+/-/g')"
-if [[ -z "$SLUG" ]]; then
-  SLUG="note"
-fi
-FILE_PATH="$NOTES_DIR/${DATE_PREFIX}-${SLUG}.md"
-
-if [[ -f "$FILE_PATH" ]]; then
-  FILE_PATH="$NOTES_DIR/${DATE_PREFIX}-${SLUG}-$(date -u +"%H%M%S").md"
-fi
-
-{
-  echo "---"
-  echo "title: \"$TITLE\""
-  echo "created_at: \"$DATE_UTC\""
-  echo "kind: \"team-note\""
-  echo "source_of_truth: false"
-  echo "trust_level: 60"
-  echo "status: active"
-  echo "---"
-  echo
-  if [[ -n "$BODY" ]]; then
-    echo "$BODY"
-  else
-    echo "_Skriv ner bakgrund, beslut, edge-cases och länkar här._"
-  fi
-  echo
-  echo "## Follow-up"
-  echo "- [ ] Convert to ADR in .context/decisions/ if this becomes a long-term rule."
-} > "$FILE_PATH"
-
-echo "[note] wrote $FILE_PATH"
-echo "[note] run: ./scripts/context.sh update"

package/scaffold/scripts/plan-state-engine.cjs

@@ -1,310 +0,0 @@
-const fs = require("node:fs");
-const path = require("node:path");
-
-const statePath = process.argv[2];
-const action = process.argv[3] || "show";
-const arg = process.argv[4] || "";
-
-const STEP_DEFS = [
-  {
-    id: "initialize",
-    title: "Initialize repository context",
-    command: "cortex init --bootstrap"
-  },
-  {
-    id: "connect",
-    title: "Connect MCP clients (Codex/Claude)",
-    command: "cortex connect"
-  },
-  {
-    id: "update",
-    title: "Refresh context while coding",
-    command: "cortex update"
-  },
-  {
-    id: "note",
-    title: "Capture decisions and TODOs",
-    command: "cortex note \"title\" \"details\""
-  }
-];
-
-const COMMAND_STEP_MAP = {
-  init: ["initialize"],
-  bootstrap: ["initialize", "update"],
-  connect: ["connect"],
-  update: ["update"],
-  refresh: ["update"],
-  ingest: ["update"],
-  embed: ["update"],
-  "graph-load": ["update"],
-  note: ["note"]
-};
-
-function nowIso() {
-  return new Date().toISOString();
-}
-
-function createDefaultState(now) {
-  return {
-    version: 1,
-    created_at: now,
-    updated_at: now,
-    last_command: null,
-    current_step: STEP_DEFS[0].title,
-    next_command: STEP_DEFS[0].command,
-    steps: STEP_DEFS.map((step) => ({
-      id: step.id,
-      title: step.title,
-      command: step.command,
-      status: "pending",
-      updated_at: null
-    })),
-    history: [],
-    next_todo_id: 1,
-    todos: []
-  };
-}
-
-function loadState() {
-  if (!fs.existsSync(statePath)) {
-    return null;
-  }
-
-  const parsed = JSON.parse(fs.readFileSync(statePath, "utf8"));
-  if (!Array.isArray(parsed.steps)) {
-    throw new Error("Invalid plan state: steps is missing");
-  }
-
-  if (!Array.isArray(parsed.history)) {
-    parsed.history = [];
-  }
-
-  if (!Array.isArray(parsed.todos)) {
-    parsed.todos = [];
-  }
-
-  if (!Number.isInteger(parsed.next_todo_id) || parsed.next_todo_id < 1) {
-    parsed.next_todo_id = parsed.todos.reduce((max, todo) => Math.max(max, Number(todo.id) || 0), 0) + 1;
-  }
-
-  for (const def of STEP_DEFS) {
-    if (!parsed.steps.find((step) => step.id === def.id)) {
-      parsed.steps.push({
-        id: def.id,
-        title: def.title,
-        command: def.command,
-        status: "pending",
-        updated_at: null
-      });
-    }
-  }
-
-  return parsed;
-}
-
-function saveState(state) {
-  fs.mkdirSync(path.dirname(statePath), { recursive: true });
-  fs.writeFileSync(statePath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
-}
-
-function updateDerivedFields(state) {
-  const nextStep = state.steps.find((step) => step.status !== "completed");
-  if (nextStep) {
-    state.current_step = nextStep.title;
-    state.next_command = nextStep.command;
-    return;
-  }
-
-  state.current_step = "Keep context fresh and capture decisions/TODOs";
-  state.next_command = "cortex update";
-}
-
-function appendHistory(state, command, at) {
-  state.last_command = {
-    name: command,
-    at
-  };
-  state.history.unshift({ command, at });
-  state.history = state.history.slice(0, 100);
-}
-
-function markStepCompleted(state, stepId, at) {
-  const step = state.steps.find((item) => item.id === stepId);
-  if (!step) {
-    return;
-  }
-  step.status = "completed";
-  step.updated_at = at;
-}
-
-function ensureState() {
-  const existing = loadState();
-  if (existing) {
-    return existing;
-  }
-  const now = nowIso();
-  const created = createDefaultState(now);
-  saveState(created);
-  return created;
-}
-
-function parseTodoId(raw) {
-  const cleaned = String(raw || "").trim().replace(/^#/, "");
-  const parsed = Number(cleaned);
-  if (!Number.isInteger(parsed) || parsed < 1) {
-    return null;
-  }
-  return parsed;
-}
-
-function printSummary(state) {
-  const openTodos = state.todos.filter((todo) => todo.status === "open");
-  const doneTodos = state.todos.filter((todo) => todo.status === "done");
-  const stepState = state.steps.map((step) => `${step.id}=${step.status}`).join(" ");
-
-  console.log(`[plan] current_step=${state.current_step}`);
-  console.log(`[plan] next_command=${state.next_command}`);
-  console.log(`[plan] steps ${stepState}`);
-
-  if (state.last_command && state.last_command.name) {
-    console.log(`[plan] last_command=${state.last_command.name} at=${state.last_command.at}`);
-  }
-
-  console.log(`[todo] open=${openTodos.length} done=${doneTodos.length}`);
-  if (openTodos.length > 0) {
-    console.log(`[todo] next=#${openTodos[0].id} ${openTodos[0].text}`);
-  }
-}
-
-try {
-  if (action === "ensure") {
-    ensureState();
-    process.exit(0);
-  }
-
-  if (action === "reset") {
-    const now = nowIso();
-    const reset = createDefaultState(now);
-    saveState(reset);
-    console.log(`[plan] reset ${statePath}`);
-    process.exit(0);
-  }
-
-  const state = ensureState();
-  const now = nowIso();
-
-  if (action === "event") {
-    const commandName = arg.trim();
-    if (!commandName) {
-      throw new Error("Usage: plan-state.sh event <command>");
-    }
-
-    const stepsToMark = COMMAND_STEP_MAP[commandName] || [];
-    for (const stepId of stepsToMark) {
-      markStepCompleted(state, stepId, now);
-    }
-
-    appendHistory(state, commandName, now);
-    state.updated_at = now;
-    updateDerivedFields(state);
-    saveState(state);
-    process.exit(0);
-  }
-
-  if (action === "show") {
-    updateDerivedFields(state);
-    printSummary(state);
-    process.exit(0);
-  }
-
-  if (action === "todo-add") {
-    const text = arg.trim();
-    if (!text) {
-      throw new Error('Usage: plan-state.sh todo add "<text>"');
-    }
-
-    const todo = {
-      id: state.next_todo_id,
-      text,
-      status: "open",
-      created_at: now,
-      updated_at: now,
-      completed_at: null
-    };
-
-    state.todos.push(todo);
-    state.next_todo_id += 1;
-    markStepCompleted(state, "note", now);
-    appendHistory(state, "todo:add", now);
-    state.updated_at = now;
-    updateDerivedFields(state);
-    saveState(state);
-    console.log(`[todo] added #${todo.id} ${todo.text}`);
-    process.exit(0);
-  }
-
-  if (action === "todo-list") {
-    const openTodos = state.todos.filter((todo) => todo.status === "open");
-    const doneTodos = state.todos.filter((todo) => todo.status === "done");
-
-    if (openTodos.length === 0 && doneTodos.length === 0) {
-      console.log("[todo] no todos");
-      process.exit(0);
-    }
-
-    for (const todo of openTodos) {
-      console.log(`[todo] [open] #${todo.id} ${todo.text}`);
-    }
-    for (const todo of doneTodos) {
-      console.log(`[todo] [done] #${todo.id} ${todo.text}`);
-    }
-    process.exit(0);
-  }
-
-  if (action === "todo-done" || action === "todo-reopen" || action === "todo-remove") {
-    const todoId = parseTodoId(arg);
-    if (!todoId) {
-      throw new Error("Usage: plan-state.sh todo <done|reopen|remove> <id>");
-    }
-
-    const index = state.todos.findIndex((todo) => Number(todo.id) === todoId);
-    if (index === -1) {
-      throw new Error(`TODO #${todoId} not found`);
-    }
-
-    const todo = state.todos[index];
-    if (action === "todo-remove") {
-      state.todos.splice(index, 1);
-      appendHistory(state, "todo:remove", now);
-      state.updated_at = now;
-      updateDerivedFields(state);
-      saveState(state);
-      console.log(`[todo] removed #${todoId}`);
-      process.exit(0);
-    }
-
-    if (action === "todo-done") {
-      todo.status = "done";
-      todo.completed_at = now;
-      appendHistory(state, "todo:done", now);
-      console.log(`[todo] done #${todoId} ${todo.text}`);
-    } else {
-      todo.status = "open";
-      todo.completed_at = null;
-      appendHistory(state, "todo:reopen", now);
-      console.log(`[todo] reopened #${todoId} ${todo.text}`);
-    }
-
-    todo.updated_at = now;
-    state.updated_at = now;
-    updateDerivedFields(state);
-    saveState(state);
-    process.exit(0);
-  }
-
-  throw new Error(`Unknown plan-state action: ${action}`);
-} catch (error) {
-  const message = error instanceof Error ? error.message : String(error);
-  process.stderr.write(`${message}\n`);
-  process.exit(1);
-}

package/scaffold/scripts/plan-state.sh

@@ -1,71 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PLAN_DIR="$REPO_ROOT/.context/plan"
-STATE_FILE="$PLAN_DIR/state.json"
-
-SUBCOMMAND="${1:-show}"
-if [[ $# -gt 0 ]]; then
-  shift
-fi
-
-run_state_tool() {
-  node "$SCRIPT_DIR/plan-state-engine.cjs" "$STATE_FILE" "$@"
-}
-
-mkdir -p "$PLAN_DIR"
-
-case "$SUBCOMMAND" in
-  show)
-    run_state_tool show
-    ;;
-  event)
-    EVENT_NAME="${1:-}"
-    if [[ -z "$EVENT_NAME" ]]; then
-      echo "Usage: plan-state.sh event <command-name>"
-      exit 1
-    fi
-    run_state_tool event "$EVENT_NAME"
-    ;;
-  reset)
-    run_state_tool reset
-    ;;
-  todo)
-    TODO_ACTION="${1:-list}"
-    if [[ $# -gt 0 ]]; then
-      shift
-    fi
-    case "$TODO_ACTION" in
-      add)
-        TODO_TEXT="${*:-}"
-        run_state_tool todo-add "$TODO_TEXT"
-        ;;
-      list)
-        run_state_tool todo-list
-        ;;
-      done)
-        TODO_ID="${1:-}"
-        run_state_tool todo-done "$TODO_ID"
-        ;;
-      reopen)
-        TODO_ID="${1:-}"
-        run_state_tool todo-reopen "$TODO_ID"
-        ;;
-      remove)
-        TODO_ID="${1:-}"
-        run_state_tool todo-remove "$TODO_ID"
-        ;;
-      *)
-        # Keep ergonomic behavior: unknown first token is treated as todo text.
-        run_state_tool todo-add "$TODO_ACTION ${*:-}"
-        ;;
-    esac
-    ;;
-  *)
-    echo "Unknown subcommand: $SUBCOMMAND"
-    echo "Usage: plan-state.sh [show|event <name>|reset|todo <action> [args]]"
-    exit 1
-    ;;
-esac