archgraph-argo 0.1.0

package/argo/scripts/semanticOperatorJourneyCli.js

@@ -0,0 +1,91 @@
+const path = require('node:path');
+const {
+  semanticOperatorErrorPayload,
+} = require('./graph-rag/semanticOperatorError.js');
+const {
+  getWorkspaceRoot,
+} = require('./argo-paths.js');
+
+async function runSemanticOperatorCommand({ command, options = {}, journey }) {
+  if (!journey) {
+    throw new TypeError('journey is required');
+  }
+  if (command === 'init') return journey.startNewProject(options);
+  if (command === 'backfill') return journey.runExplicitBackfill(options);
+  if (command === 'readiness') return journey.verifyReadiness(options);
+  if (command === 'query') return journey.query(options);
+  if (command === 'snapshot') return journey.readFullSnapshot();
+  throw new Error(`Unknown semantic operator command: ${command}`);
+}
+
+async function runCliProcess({
+  argv = [],
+  dependencies = {},
+  stdout = process.stdout,
+  stderr = process.stderr,
+} = {}) {
+  const command = argv[0];
+  const parsedOptions = parseOptions(argv.slice(1));
+  const repositoryRoot = dependencies.repositoryRoot
+    || getWorkspaceRoot();
+  const options = {
+    ...parsedOptions,
+    approvedConfigurationRequest: {
+      repositoryRoot,
+      useCase: 'production-semantic-query',
+    },
+  };
+  const {
+    createDefaultProductionSemanticOperatorJourney,
+  } = require('./systemarchitecture-mcp-server.js');
+  const createSemanticOperatorJourney = dependencies.createSemanticOperatorJourney
+    || createDefaultProductionSemanticOperatorJourney;
+  try {
+    const journey = await createSemanticOperatorJourney({ repositoryRoot });
+    const result = await runSemanticOperatorCommand({ command, options, journey });
+    stdout.write(`${JSON.stringify(result)}\n`);
+    return { exitCode: 0, result };
+  } catch (error) {
+    const result = {
+      status: 'failed',
+      error: semanticOperatorErrorPayload(error),
+    };
+    stderr.write(`${JSON.stringify(result)}\n`);
+    return { exitCode: 1, result };
+  }
+}
+
+async function main(argv = process.argv.slice(2)) {
+  const outcome = await runCliProcess({ argv });
+  process.exitCode = outcome.exitCode;
+}
+
+function parseOptions(args) {
+  const options = {};
+  for (let index = 0; index < args.length; index += 1) {
+    const argument = args[index];
+    if (argument === '--automatic-backfill') options.automaticBackfillOptIn = true;
+    else if (argument === '--explicit-opt-in') options.explicitOptIn = true;
+    else if (argument === '--resume') options.resume = true;
+    else if (argument === '--request-json') {
+      index += 1;
+      return JSON.parse(args[index]);
+    }
+  }
+  return options;
+}
+
+if (require.main === module) {
+  main().catch(error => {
+    process.stderr.write(`${JSON.stringify({
+      status: 'failed',
+      error: semanticOperatorErrorPayload(error),
+    })}\n`);
+    process.exit(1);
+  });
+}
+
+module.exports = {
+  runCliProcess,
+  runSemanticOperatorCommand,
+};

package/argo/scripts/syncSystemArchitectureToNeo4j.js

@@ -0,0 +1,67 @@
+const {
+  DEFAULT_GRAPH_PATH,
+  getNeo4jConfig,
+  syncArchitectureToNeo4j,
+  verifyArchitectureSync,
+} = require('./neo4j-system-architecture-store.js');
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const architecturePath = args.architecturePath || DEFAULT_GRAPH_PATH;
+  const config = getNeo4jConfig({
+    database: args.database,
+  });
+
+  const result = args.verifyOnly
+    ? await verifyArchitectureSync({ architecturePath, ...config })
+    : await syncArchitectureToNeo4j({ architecturePath, ...config });
+
+  const verification = args.verifyOnly ? result : result.verification;
+  if (!verification.matches) {
+    console.error('Neo4j sync verification failed.');
+    console.error(JSON.stringify(verification, null, 2));
+    process.exit(1);
+  }
+
+  const output = {
+    mode: args.verifyOnly ? 'verify' : 'sync',
+    architecturePath,
+    database: config.database,
+    databaseProvision: verification.databaseProvision || (result && result.databaseProvision) || null,
+    uri: config.uri,
+    counts: verification.actual,
+    matches: verification.matches,
+  };
+
+  console.log(JSON.stringify(output, null, 2));
+}
+
+function parseArgs(argv) {
+  const args = {};
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (token === '--verify') {
+      args.verifyOnly = true;
+      continue;
+    }
+    if (token === '--architecture-path') {
+      args.architecturePath = argv[index + 1];
+      index += 1;
+      continue;
+    }
+    if (token === '--database') {
+      args.database = argv[index + 1];
+      index += 1;
+      continue;
+    }
+    throw new Error(`Unsupported argument: ${token}`);
+  }
+
+  return args;
+}
+
+main().catch(error => {
+  console.error(String(error && error.stack ? error.stack : error));
+  process.exit(1);
+});