@a5c-ai/atlas-github 5.1.1-staging.0007199a1cb2

package/AGENTS.md

@@ -0,0 +1,15 @@
+# Atlas Agents (GitHub Copilot)
+
+Atlas turns a stated need into a full system design by mining the Atlas
+knowledge graph.
+
+- Use the `atlas` skill to drive the need → design pipeline.
+- Use the `atlas-graph-query` skill as a reference for the Atlas MCP tool surface.
+- Query the graph via the `mcp__atlas__atlas_public_*` MCP tools only; never
+  invent node ids.
+- Delegate non-trivial runs to the `babysitter:babysit` skill using an atlas
+  `.a5c` process (`atlas-systems-discovery`, `atlas-process-mining`,
+  `atlas-data-mining`, `atlas-collect-nuances`).
+
+The Atlas MCP server is wired natively and defaults to
+`https://atlas-staging.a5c.ai/api/mcp`, overridable via `ATLAS_MCP_URL`.

package/README.md

@@ -0,0 +1,35 @@
+# Atlas Plugin for GitHub Copilot
+
+Atlas turns a stated need into a full system design by mining the Atlas
+knowledge graph. This is the GitHub Copilot harness surface for the `atlas` plugin.
+
+## What's Included
+
+- **Skills**: `atlas` (the need → design brain) and `atlas-graph-query`
+  (a reference for the Atlas MCP tool surface).
+- **Commands**: `/atlas:discover`, `/atlas:mine-processes`,
+  `/atlas:mine-data`, `/atlas:collect-nuances` — each delegates orchestration
+  to the `babysitter:babysit` skill using an atlas-specific `.a5c` process.
+- **MCP**: the Atlas knowledge-graph server (`atlas`), wired natively into
+  GitHub Copilot's own MCP config format.
+
+## Atlas MCP
+
+The Atlas MCP server is wired natively for GitHub Copilot — no manual setup. It
+defaults to `https://atlas-staging.a5c.ai/api/mcp` and is overridable at
+runtime via the `ATLAS_MCP_URL` environment variable. The
+`mcp__atlas__atlas_public_*` tools are then available to the atlas skills.
+
+## Installation
+
+Atlas commands delegate orchestration to Babysitter, so install the Babysitter
+CLI once, then install this plugin for GitHub Copilot:
+
+```bash
+npm install -g @a5c-ai/babysitter
+babysitter harness:install-plugin github-copilot
+```
+
+## License
+
+See the repository license.

package/bin/cli.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+'use strict';
+
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+let shared;
+try { shared = require('./install-shared'); } catch {}
+
+function printUsage() {
+  console.error([
+    'Usage:',
+    '  atlas-github install [--global]',
+    '  atlas-github install --workspace [path]',
+    '  atlas-github uninstall',
+  ].join('\n'));
+}
+
+function parseInstallArgs(argv) {
+  let scope = 'global';
+  let workspace = null;
+  const passthrough = [];
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === '--global') {
+      scope = 'global';
+      continue;
+    }
+    if (arg === '--workspace') {
+      scope = 'workspace';
+      const next = argv[i + 1];
+      if (next && !next.startsWith('-')) {
+        workspace = path.resolve(next);
+        i += 1;
+      } else {
+        workspace = process.cwd();
+      }
+      continue;
+    }
+    passthrough.push(arg);
+  }
+
+  return { scope, workspace, passthrough };
+}
+
+function runNodeScript(scriptPath, args, extraEnv = {}) {
+  const result = spawnSync(process.execPath, [scriptPath, ...args], {
+    cwd: process.cwd(),
+    stdio: 'inherit',
+    env: { ...process.env, ...extraEnv },
+  });
+  process.exitCode = result.status ?? 1;
+}
+
+function main() {
+  const [command, ...rest] = process.argv.slice(2);
+  if (!command || command === '--help' || command === '-h' || command === 'help') {
+    printUsage();
+    process.exitCode = command ? 0 : 1;
+    return;
+  }
+
+  if (command === 'install') {
+    if (shared && typeof shared.harnessCliRoute === 'function' && shared.harnessCliRoute(rest, PACKAGE_ROOT, runNodeScript)) {
+      return;
+    }
+    const parsed = parseInstallArgs(rest);
+    if (parsed.scope === 'workspace') {
+      const args = [];
+      if (parsed.workspace) {
+        args.push('--workspace', parsed.workspace);
+      }
+      args.push(...parsed.passthrough);
+      runNodeScript(
+        path.join(PACKAGE_ROOT, 'scripts', 'team-install.js'),
+        args,
+        { PLUGIN_PACKAGE_ROOT: PACKAGE_ROOT },
+      );
+      return;
+    }
+    runNodeScript(path.join(PACKAGE_ROOT, 'bin', 'install.js'), parsed.passthrough);
+    return;
+  }
+
+  if (command === 'uninstall') {
+    runNodeScript(path.join(PACKAGE_ROOT, 'bin', 'uninstall.js'), rest);
+    return;
+  }
+
+  printUsage();
+  process.exitCode = 1;
+}
+
+main();

package/bin/install-shared.js

@@ -0,0 +1,156 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const PLUGIN_NAME = "atlas";
+const PLUGIN_CATEGORY = 'Coding';
+
+function getUserHome() {
+  return os.homedir();
+}
+
+function getHarnessHome() {
+  return path.join(os.homedir(), ".copilot");
+}
+
+function getHomePluginRoot(scope) {
+  if (scope === 'workspace') return path.join(process.cwd(), '.a5c', 'plugins', PLUGIN_NAME);
+  return path.join(path.join(getHarnessHome(), 'plugins'), PLUGIN_NAME);
+}
+
+function getHomeMarketplacePath() {
+  return path.join(getHarnessHome(), 'plugins', 'marketplace.json');
+}
+
+function writeFileIfChanged(filePath, contents) {
+  try {
+    const existing = fs.readFileSync(filePath, 'utf8');
+    if (existing === contents) return false;
+  } catch (e) { process.stderr.write('[extensions-adapter] file read failed for ' + filePath + ', overwriting: ' + (e instanceof Error ? e.message : String(e)) + '\n'); }
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, contents);
+  return true;
+}
+
+function copyRecursive(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    if (entry.name === 'node_modules' || entry.name === '.git') continue;
+    const s = path.join(src, entry.name);
+    const d = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyRecursive(s, d);
+    } else {
+      fs.copyFileSync(s, d);
+    }
+  }
+}
+
+function copyPluginBundle(packageRoot, pluginRoot) {
+  const bundleEntries = fs.readdirSync(packageRoot).filter(
+    e => !['node_modules', '.git', 'test', 'dist'].includes(e)
+  );
+  fs.mkdirSync(pluginRoot, { recursive: true });
+  for (const entry of bundleEntries) {
+    const src = path.join(packageRoot, entry);
+    const dest = path.join(pluginRoot, entry);
+    const stat = fs.statSync(src);
+    if (stat.isDirectory()) {
+      copyRecursive(src, dest);
+    } else {
+      fs.copyFileSync(src, dest);
+    }
+  }
+}
+
+function readJson(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function writeJson(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(value, null, 2) + '\n');
+}
+
+function ensureExecutable(filePath) {
+  try {
+    fs.chmodSync(filePath, 0o755);
+  } catch (e) { process.stderr.write('[extensions-adapter] chmod failed for ' + filePath + ': ' + (e instanceof Error ? e.message : String(e)) + '\n'); }
+}
+
+function normalizeMarketplaceSourcePath(source, marketplacePath) {
+  if (typeof source === 'string') {
+    return path.relative(path.dirname(marketplacePath), source).replace(/\\/g, '/');
+  }
+  return source;
+}
+
+function ensureMarketplaceEntry(marketplacePath, pluginRoot) {
+  let marketplace = readJson(marketplacePath) || {
+    name: "a5c.ai",
+    plugins: [],
+  };
+  if (!Array.isArray(marketplace.plugins)) marketplace.plugins = [];
+  const idx = marketplace.plugins.findIndex(p => p.name === PLUGIN_NAME);
+  const relSource = './' + normalizeMarketplaceSourcePath(pluginRoot, marketplacePath);
+  const entry = {
+    name: PLUGIN_NAME,
+    source: relSource,
+    description: "Turn a stated need into a full system design by mining the Atlas knowledge graph.",
+    version: "5.1.1-staging.0007199a1cb2",
+    author: { name: "a5c.ai" },
+  };
+  if (idx >= 0) marketplace.plugins[idx] = entry;
+  else marketplace.plugins.push(entry);
+  writeJson(marketplacePath, marketplace);
+}
+
+function removeMarketplaceEntry(marketplacePath) {
+  const marketplace = readJson(marketplacePath);
+  if (!marketplace || !Array.isArray(marketplace.plugins)) return;
+  marketplace.plugins = marketplace.plugins.filter(p => p.name !== PLUGIN_NAME);
+  writeJson(marketplacePath, marketplace);
+}
+
+function warnWindowsHooks() {
+  if (process.platform === 'win32') {
+    console.warn('[' + PLUGIN_NAME + '] Windows detected — shell hooks (.sh) require Git Bash or WSL.');
+  }
+}
+
+function runPostInstall(pluginRoot) {
+  const postInstall = path.join(pluginRoot, 'scripts', 'post-install.js');
+  if (fs.existsSync(postInstall)) {
+    spawnSync(process.execPath, [postInstall], {
+      cwd: pluginRoot, stdio: 'inherit',
+      env: { ...process.env, PLUGIN_ROOT: pluginRoot, CLAUDE_PLUGIN_ROOT: pluginRoot },
+    });
+  }
+}
+
+module.exports = {
+  PLUGIN_NAME,
+  PLUGIN_CATEGORY,
+  getUserHome,
+  getHarnessHome,
+  getHomePluginRoot,
+  getHomeMarketplacePath,
+  writeFileIfChanged,
+  copyRecursive,
+  copyPluginBundle,
+  readJson,
+  writeJson,
+  ensureExecutable,
+  normalizeMarketplaceSourcePath,
+  ensureMarketplaceEntry,
+  removeMarketplaceEntry,
+  warnWindowsHooks,
+  runPostInstall,
+};

package/bin/install.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+'use strict';
+
+const path = require('path');
+const shared = require('./install-shared');
+
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+
+function main() {
+  const pluginRoot = shared.getHomePluginRoot();
+  const marketplacePath = shared.getHomeMarketplacePath();
+
+  console.log(`[${shared.PLUGIN_NAME}] Installing plugin to ${pluginRoot}`);
+
+  try {
+    shared.copyPluginBundle(PACKAGE_ROOT, pluginRoot);
+    shared.ensureMarketplaceEntry(marketplacePath, pluginRoot);
+    if (typeof shared.registerCopilotPlugin === 'function') {
+      shared.registerCopilotPlugin(pluginRoot);
+    }
+    if (typeof shared.installCopilotSurface === 'function' && typeof shared.getCopilotHome === 'function') {
+      shared.installCopilotSurface(PACKAGE_ROOT, shared.getCopilotHome());
+    }
+    if (typeof shared.warnWindowsHooks === 'function') {
+      shared.warnWindowsHooks();
+    }
+    if (typeof shared.harnessInstall === 'function') {
+      shared.harnessInstall(PACKAGE_ROOT, pluginRoot);
+    }
+    shared.runPostInstall && shared.runPostInstall(pluginRoot);
+    console.log(`[${shared.PLUGIN_NAME}] Installation complete!`);
+    console.log(`[${shared.PLUGIN_NAME}] Restart your IDE/CLI to pick up the plugin.`);
+  } catch (err) {
+    console.error(`[${shared.PLUGIN_NAME}] Failed to install: ${err.message}`);
+    process.exitCode = 1;
+  }
+}
+
+main();

package/bin/uninstall.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const shared = require('./install-shared');
+
+function main() {
+  const pluginRoot = shared.getHomePluginRoot();
+  const marketplacePath = typeof shared.getHomeMarketplacePath === 'function'
+    ? shared.getHomeMarketplacePath()
+    : null;
+  const copilotHome = typeof shared.getCopilotHome === 'function'
+    ? shared.getCopilotHome()
+    : null;
+
+  if (!fs.existsSync(pluginRoot)) {
+    console.log(`[${shared.PLUGIN_NAME}] Plugin not installed at ${pluginRoot}`);
+  } else {
+    try {
+      fs.rmSync(pluginRoot, { recursive: true, force: true });
+      console.log(`[${shared.PLUGIN_NAME}] Uninstalled from ${pluginRoot}`);
+    } catch (err) {
+      console.error(`[${shared.PLUGIN_NAME}] Failed to uninstall: ${err.message}`);
+      process.exitCode = 1;
+      return;
+    }
+  }
+
+  try {
+    if (typeof shared.deregisterCopilotPlugin === 'function') {
+      shared.deregisterCopilotPlugin(pluginRoot);
+    }
+    if (copilotHome && typeof shared.removeManagedHooks === 'function') {
+      shared.removeManagedHooks(copilotHome);
+    }
+    if (marketplacePath && typeof shared.removeMarketplaceEntry === 'function') {
+      shared.removeMarketplaceEntry(marketplacePath);
+    }
+  } catch (err) {
+    console.error(`[${shared.PLUGIN_NAME}] Failed to clean up uninstall state: ${err.message}`);
+    process.exitCode = 1;
+  }
+}
+
+main();

package/commands/collect-nuances.md

@@ -0,0 +1,19 @@
+---
+description: Collect the REAL constraints/gotchas of your scanned systems (IaC drift, orphaned resources, RBAC quirks, region splits), each cited; Atlas-graph comparison secondary.
+argument-hint: The sources to inspect for nuances (e.g. "our azure account and this repo into C:/work/atlas").
+allowed-tools: Read, Grep, Write, Task, Bash, Edit, Glob, AskUserQuestion, TodoWrite, Skill, mcp__atlas__atlas_public_search, mcp__atlas__atlas_public_record, mcp__atlas__atlas_public_neighbors, mcp__atlas__atlas_public_kinds, mcp__atlas__atlas_public_clusters, mcp__atlas__atlas_public_wiki_page
+---
+
+Invoke the babysitter:babysit skill (using the Skill tool) and follow its instructions (SKILL.md). Run the PRE-AUTHORED atlas process bundled with this plugin — do NOT interview the user or author a new process. Create the run directly from this bundled entry and iterate it to completion:
+
+```
+${COPILOT_PLUGIN_DIR}/processes/atlas-collect-nuances.mjs#process
+```
+
+(e.g. `babysitter run:create --process-id atlas-collect-nuances --entry "${COPILOT_PLUGIN_DIR}/processes/atlas-collect-nuances.mjs#process" --harness <this-harness>`, then iterate.) Pass the user arguments below as the run's stated need / process inputs. Continue executing in this same turn; do not stop after the Skill tool returns.
+
+This process is SCAN-FIRST: it parses the stated sources, then runs READ-ONLY scans (Bash `az` + git/fs) of the user's REAL systems to collect actual constraints/gotchas/edge-cases — IaC-as-survey drift, orphaned cloud resources, RBAC/visibility quirks, region splits, tenant/descriptor mismatches, externally-deployed systems with no in-repo pipeline — each cited to its real resource id / RG / file path (or a concrete missing-thing observation). The Atlas knowledge graph (mcp__atlas__atlas_public_*) is used only as SECONDARY comparison. Never invent constraints; only inspect the sources named in the arguments.
+
+User arguments for this command:
+
+$ARGUMENTS

package/commands/discover.md

@@ -0,0 +1,19 @@
+---
+description: Scan your real systems (Azure + repos + dirs) and map them into a layered, source-cited atlas; enrich against the Atlas graph (secondary).
+argument-hint: The sources to scan (e.g. "our azure account, this repo and C:/work/ into C:/work/atlas").
+allowed-tools: Read, Grep, Write, Task, Bash, Edit, Glob, AskUserQuestion, TodoWrite, Skill, mcp__atlas__atlas_public_search, mcp__atlas__atlas_public_record, mcp__atlas__atlas_public_neighbors, mcp__atlas__atlas_public_kinds, mcp__atlas__atlas_public_clusters, mcp__atlas__atlas_public_wiki_page
+---
+
+Invoke the babysitter:babysit skill (using the Skill tool) and follow its instructions (SKILL.md). Run the PRE-AUTHORED atlas process bundled with this plugin — do NOT interview the user or author a new process. Create the run directly from this bundled entry and iterate it to completion:
+
+```
+${COPILOT_PLUGIN_DIR}/processes/atlas-systems-discovery.mjs#process
+```
+
+(e.g. `babysitter run:create --process-id atlas-systems-discovery --entry "${COPILOT_PLUGIN_DIR}/processes/atlas-systems-discovery.mjs#process" --harness <this-harness>`, then iterate.) Pass the user arguments below as the run's stated need / process inputs. Continue executing in this same turn; do not stop after the Skill tool returns.
+
+This process is SCAN-FIRST: it parses the stated sources, then runs READ-ONLY scans of the user's REAL systems — Azure via `az` (Bash), git repos, and local directories — and synthesizes a cross-linked, source-cited atlas where every item cites a real resource id / RG / file path. The Atlas knowledge graph (mcp__atlas__atlas_public_*) is used only as SECONDARY enrichment/comparison, never as the primary content. Never invent resource ids or file paths; only scan the sources named in the arguments.
+
+User arguments for this command:
+
+$ARGUMENTS

package/commands/mine-data.md

@@ -0,0 +1,19 @@
+---
+description: Mine the REAL data stores/models in your sources (cloud DBs via az, schemas/migrations, package types), each cited; Atlas-graph comparison secondary.
+argument-hint: The sources to mine for data (e.g. "our azure account and this repo into C:/work/atlas").
+allowed-tools: Read, Grep, Write, Task, Bash, Edit, Glob, AskUserQuestion, TodoWrite, Skill, mcp__atlas__atlas_public_search, mcp__atlas__atlas_public_record, mcp__atlas__atlas_public_neighbors, mcp__atlas__atlas_public_kinds, mcp__atlas__atlas_public_clusters, mcp__atlas__atlas_public_wiki_page
+---
+
+Invoke the babysitter:babysit skill (using the Skill tool) and follow its instructions (SKILL.md). Run the PRE-AUTHORED atlas process bundled with this plugin — do NOT interview the user or author a new process. Create the run directly from this bundled entry and iterate it to completion:
+
+```
+${COPILOT_PLUGIN_DIR}/processes/atlas-data-mining.mjs#process
+```
+
+(e.g. `babysitter run:create --process-id atlas-data-mining --entry "${COPILOT_PLUGIN_DIR}/processes/atlas-data-mining.mjs#process" --harness <this-harness>`, then iterate.) Pass the user arguments below as the run's stated need / process inputs. Continue executing in this same turn; do not stop after the Skill tool returns.
+
+This process is SCAN-FIRST: it parses the stated sources, then runs READ-ONLY scans to mine the REAL data — cloud databases/storage/AI-Search via `az` (Bash), and schemas/migrations/ORM models/package types in the repos/dirs — binding models to the stores that back them, each cited to its real resource id / file path. The Atlas knowledge graph (mcp__atlas__atlas_public_*) is used only as SECONDARY comparison. Never invent stores or models; only mine the sources named in the arguments. Never read secret values.
+
+User arguments for this command:
+
+$ARGUMENTS

package/commands/mine-processes.md

@@ -0,0 +1,19 @@
+---
+description: Mine the REAL processes in your sources (CI/CD, npm scripts, IaC, Dockerfiles, .a5c, cron), each cited to its file; Atlas-graph comparison secondary.
+argument-hint: The sources to mine (e.g. "this repo and C:/work/ into C:/work/atlas").
+allowed-tools: Read, Grep, Write, Task, Bash, Edit, Glob, AskUserQuestion, TodoWrite, Skill, mcp__atlas__atlas_public_search, mcp__atlas__atlas_public_record, mcp__atlas__atlas_public_neighbors, mcp__atlas__atlas_public_kinds, mcp__atlas__atlas_public_clusters, mcp__atlas__atlas_public_wiki_page
+---
+
+Invoke the babysitter:babysit skill (using the Skill tool) and follow its instructions (SKILL.md). Run the PRE-AUTHORED atlas process bundled with this plugin — do NOT interview the user or author a new process. Create the run directly from this bundled entry and iterate it to completion:
+
+```
+${COPILOT_PLUGIN_DIR}/processes/atlas-process-mining.mjs#process
+```
+
+(e.g. `babysitter run:create --process-id atlas-process-mining --entry "${COPILOT_PLUGIN_DIR}/processes/atlas-process-mining.mjs#process" --harness <this-harness>`, then iterate.) Pass the user arguments below as the run's stated need / process inputs. Continue executing in this same turn; do not stop after the Skill tool returns.
+
+This process is SCAN-FIRST: it parses the stated sources, then runs READ-ONLY scans (Bash) of the REAL repos/dirs/cloud automation and mines the processes that actually exist — `.github/workflows`, npm scripts, terraform/bicep/helm/k8s, Dockerfiles, babysitter `.a5c` processes, and cron/scheduled jobs — each cited to its real file path. The Atlas knowledge graph (mcp__atlas__atlas_public_*) is used only as SECONDARY comparison. Never invent files or processes; only mine the sources named in the arguments.
+
+User arguments for this command:
+
+$ARGUMENTS

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@a5c-ai/atlas-github",
+  "version": "5.1.1-staging.0007199a1cb2",
+  "description": "Turn a stated need into a full system design by mining the Atlas knowledge graph.",
+  "scripts": {
+    "deploy": "npm publish --access public",
+    "deploy:staging": "npm publish --access public --tag staging",
+    "plugin:install": "node bin/install.js --global",
+    "plugin:uninstall": "node bin/uninstall.js --global",
+    "team:install": "node scripts/team-install.js"
+  },
+  "bin": {
+    "atlas-github": "bin/cli.js"
+  },
+  "files": [
+    "bin/",
+    "AGENTS.md",
+    "skills/",
+    "commands/",
+    "scripts/",
+    "plugin.json",
+    "README.md",
+    "versions.json",
+    "package.json"
+  ],
+  "keywords": [
+    "atlas",
+    "github-copilot",
+    "orchestration"
+  ],
+  "author": "a5c.ai",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@a5c-ai/babysitter-sdk": "5.1.1-staging.0007199a1cb2"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/a5c-ai/atlas-github-copilot.git"
+  },
+  "homepage": "https://github.com/a5c-ai/atlas-github-copilot#readme",
+  "bugs": {
+    "url": "https://github.com/a5c-ai/atlas-github-copilot/issues"
+  }
+}

package/plugin.json

@@ -0,0 +1,28 @@
+{
+  "name": "atlas",
+  "version": "5.1.1-staging.0007199a1cb2",
+  "description": "Turn a stated need into a full system design by mining the Atlas knowledge graph.",
+  "author": {
+    "name": "a5c.ai"
+  },
+  "license": "MIT",
+  "skills": "skills/",
+  "commands": "commands/",
+  "agents": "AGENTS.md",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/a5c-ai/babysitter"
+  },
+  "keywords": [
+    "atlas",
+    "knowledge-graph",
+    "system-design",
+    "discovery",
+    "process-mining",
+    "data-mining",
+    "mcp",
+    "agent",
+    "LLM",
+    "github-copilot"
+  ]
+}

package/scripts/create-release-tag.mjs

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+
+function run(command, args) {
+  const result = spawnSync(command, args, { encoding: 'utf8', stdio: 'inherit' });
+  if (result.status !== 0) process.exit(result.status || 1);
+}
+
+const branch = process.env.GITHUB_REF_NAME || 'develop';
+const sha = (process.env.GITHUB_SHA || '').slice(0, 12);
+const version = existsSync('package.json') ? JSON.parse(readFileSync('package.json', 'utf8')).version : JSON.parse(readFileSync('versions.json', 'utf8')).sdkVersion;
+const normalized = String(version).replace(/[^0-9A-Za-z._-]/g, '-');
+const tag = 'release/' + branch + '/v' + normalized + '-' + sha;
+run('git', ['config', 'user.name', 'github-actions[bot]']);
+run('git', ['config', 'user.email', 'github-actions[bot]@users.noreply.github.com']);
+run('git', ['tag', tag]);
+run('git', ['push', 'origin', tag]);

package/scripts/publish-from-tag.mjs

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+
+function run(command, args, options = {}) {
+  const result = spawnSync(command, args, { stdio: options.stdio || 'inherit', encoding: options.encoding });
+  if (result.status !== 0 && !options.allowFailure) process.exit(result.status || 1);
+  return result;
+}
+
+function npmView(packageSpec) {
+  return run('npm', ['view', packageSpec, 'version'], { allowFailure: true, stdio: 'pipe', encoding: 'utf8' }).status === 0;
+}
+
+const pkg = JSON.parse(readFileSync('package.json', 'utf8'));
+const ref = process.env.GITHUB_REF_NAME || '';
+const branch = ref.split('/')[1] || 'develop';
+const tag = branch === 'main' ? 'latest' : branch;
+
+if (!process.env.NODE_AUTH_TOKEN) {
+  console.log('NODE_AUTH_TOKEN is not configured; skipping npm publish.');
+  process.exit(0);
+}
+
+if (npmView(pkg.name + '@' + pkg.version)) {
+  console.log(pkg.name + '@' + pkg.version + ' already exists; ensuring dist-tag ' + tag + '.');
+  run('npm', ['dist-tag', 'add', pkg.name + '@' + pkg.version, tag], { allowFailure: true });
+  process.exit(0);
+}
+
+for (const field of ['dependencies', 'peerDependencies', 'optionalDependencies']) {
+  for (const [name, version] of Object.entries(pkg[field] || {})) {
+    if (!name.startsWith('@a5c-ai/') || version.startsWith('^') || version.startsWith('~') || version === '*' || version.startsWith('workspace:')) continue;
+    if (!npmView(name + '@' + version)) {
+      console.log('Required internal dependency ' + name + '@' + version + ' is not published yet; skipping npm publish.');
+      process.exit(0);
+    }
+  }
+}
+
+run('npm', ['publish', '--access', 'public', '--tag', tag]);

package/scripts/team-install.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+'use strict';
+
+var path = require('path');
+var shared = require('../bin/install-shared');
+
+var workspace = process.cwd();
+for (var i = 0; i < process.argv.length; i++) {
+  if (process.argv[i] === '--workspace' && process.argv[i + 1]) {
+    workspace = path.resolve(process.argv[i + 1]);
+  }
+}
+
+var src = process.env.PLUGIN_PACKAGE_ROOT || path.resolve(__dirname, '..');
+var dest = shared.getHomePluginRoot('workspace');
+console.log('[atlas] Team install to ' + dest);
+
+shared.copyPluginBundle(src, dest);
+if (typeof shared.harnessTeamInstall === 'function') {
+  shared.harnessTeamInstall(src, dest, workspace);
+}
+shared.runPostInstall(dest);
+console.log('[atlas] Team install complete.');

package/skills/atlas/SKILL.md

@@ -0,0 +1,103 @@
+---
+name: atlas
+description: >
+  Atlas turns your STATED NEED into a real systems atlas by SCANNING your actual
+  sources (Azure via `az`, git repos, local dirs) and process/data mining them,
+  THEN enriching against the Atlas knowledge graph. Use this skill when asked to
+  inventory/map your real systems, scan your cloud + repos + directories, mine the
+  real processes or data they contain, or collect their real constraints/gotchas.
+  (atlas, scan my systems, inventory our azure account, map my repos, real systems
+  atlas, process mining, data mining, collect nuances, system discovery)
+allowed-tools: Read, Grep, Glob, Write, Edit, Task, Bash, AskUserQuestion, TodoWrite, Skill, mcp__atlas__atlas_public_search, mcp__atlas__atlas_public_record, mcp__atlas__atlas_public_neighbors, mcp__atlas__atlas_public_kinds, mcp__atlas__atlas_public_kind, mcp__atlas__atlas_public_clusters, mcp__atlas__atlas_public_stats, mcp__atlas__atlas_public_wiki_page
+version: 0.1.0
+---
+
+# atlas
+
+This skill turns a stated need into a **real systems atlas** by SCANNING your
+actual sources — Azure subscriptions (via read-only `az`), git repos, and local
+directories — and process/data mining them, THEN enriching the result against the
+Atlas knowledge graph. It is the brain of the `atlas` plugin. The scan is
+PRIMARY; the graph is SECONDARY. For non-trivial runs it delegates orchestration
+to `babysitter:babysit` using an atlas-specific `.a5c` process; for simple
+lookups it queries the graph directly.
+
+## 1. Scan-first, graph-second
+
+The output you want is an evidence-backed inventory of **your** systems — e.g.
+`azure-inventory.json` (every real resource id + RG from `az`),
+`workspace-inventory.json` (real repo/dir scan), `processes.json` (real mined
+CI/CD/IaC/.a5c processes), and a cross-linked `SYSTEMS-ATLAS.md`. Every item must
+cite its REAL source. Generic catalog nodes are NOT the deliverable.
+
+- **Primary — scan the user's real sources.** Use `Bash` to run READ-ONLY scans:
+  `az` (account/group/resource list + per-service list/show) for Azure;
+  `git` + filesystem (`Read`/`Glob`) for repos and directories. NEVER invent
+  resource ids, regions, SKUs, or file paths — if you didn't observe it in real
+  output, it does not go in the atlas. Only scan the sources named in the need
+  (scoping, not a fallback).
+- **Secondary — the Atlas knowledge graph.** Atlas is a knowledge graph of
+  agents, processes, data models, capabilities, workflows, and wiki pages reached
+  through the `mcp__atlas__atlas_public_*` MCP tools (server URL overridable via
+  `ATLAS_MCP_URL`). Use it ONLY to add best-practice / comparison context for the
+  real systems you found — never as the primary content, never to pad the atlas
+  with generic nodes. See the `atlas-graph-query` skill for the tool surface.
+
+## 2. When to use
+
+| Trigger phrase | Command |
+|----------------|---------|
+| scan/inventory my real systems (azure + repos + dirs), map them | `/atlas:discover` |
+| mine the real processes in my repos/cloud (CI/CD, IaC, .a5c, cron) | `/atlas:mine-processes` |
+| mine the real data stores/models in my cloud + repos | `/atlas:mine-data` |
+| collect the real constraints/gotchas of my scanned systems | `/atlas:collect-nuances` |
+
+## 3. The need → real atlas pipeline (core method)
+
+1. **Parse sources** — interpret the stated need into concrete SOURCES: Azure
+   subscription(s), git repos, local directories, URLs, plus the output dir. If
+   the sources are genuinely ambiguous, run a short interview
+   (`AskUserQuestion`). Per repo policy, interview ONLY when truly unclear.
+2. **Scan cloud (primary)** — for each Azure source, run read-only `az` and write
+   a real cloud inventory citing resource ids/RGs. Skip cleanly (record a reason)
+   if no cloud source is in scope — only scan what's named.
+3. **Scan local (primary)** — for each repo/dir, scan the filesystem + git
+   (structure, submodules, manifests, languages, services, IaC) and write a real
+   inventory citing real paths.
+4. **Enrich (secondary)** — map the discovered real systems against the Atlas
+   graph for comparison context. Clearly secondary; never the headline.
+5. **Synthesize** — assemble a real, cross-linked layered atlas (components /
+   processes / data / integrations / nuances) where EVERY item cites its real
+   source, like `SYSTEMS-ATLAS.md`, plus a machine mirror.
+6. **Converge (TDD)** — each phase asserts its own checkable outputs before
+   proceeding (see the atlas processes), iterating until the assertions pass.
+
+## 4. How to delegate
+
+For any non-trivial run, hand off to `babysitter:babysit` (via the Skill tool)
+naming the matching atlas process:
+
+- `/atlas:discover` → `atlas-systems-discovery`
+- `/atlas:mine-processes` → `atlas-process-mining`
+- `/atlas:mine-data` → `atlas-data-mining`
+- `/atlas:collect-nuances` → `atlas-collect-nuances`
+
+Do not hand-roll orchestration when a process exists.
+
+## 5. Guardrails
+
+- No fallbacks (repo rule). Skipping an out-of-scope source class (e.g. no cloud
+  named) is correct scoping and must be recorded with a reason — it is NOT a
+  silent fallback to the public graph. If you find yourself writing a real
+  fallback, stop and fix the root cause.
+- Scan-first: every system/item in the atlas MUST cite a REAL source (an `az`
+  resource id / RG, or a file path). Never invent resource ids, regions, SKUs, or
+  file paths. Never invent graph node ids either — only reference ids returned by
+  the Atlas tools, and keep graph content strictly secondary.
+- Read-only scanning only: `az` read verbs, `git` status/remote/log, filesystem
+  reads. Never run mutating cloud/git/fs commands and never read secret values.
+- Keep breakpoints sparse; use them only when the sources to scan are genuinely
+  ambiguous.
+- The real scanning is done BY the agent via its `Bash` tool inside the agent
+  task prompt. Do not emit `kind: 'shell'` subtasks unless the user explicitly
+  asks for a shell-oriented workflow.

package/skills/atlas-graph-query/SKILL.md

@@ -0,0 +1,70 @@
+---
+name: atlas-graph-query
+description: >
+  Reference for querying the Atlas knowledge graph through its MCP tools — the
+  SECONDARY enrichment/comparison layer that adds best-practice context to systems
+  you have ALREADY scanned from your real sources (`az`, repos, dirs). Use when
+  you need to look up nodes, edges, kinds, clusters, stats, or wiki pages in Atlas
+  to compare against your real inventory. (atlas graph, query atlas, atlas mcp,
+  search the graph, graph neighbors, atlas record, atlas kinds, enrichment layer)
+allowed-tools: mcp__atlas__atlas_public_search, mcp__atlas__atlas_public_record, mcp__atlas__atlas_public_neighbors, mcp__atlas__atlas_public_kinds, mcp__atlas__atlas_public_kind, mcp__atlas__atlas_public_edge_kinds, mcp__atlas__atlas_public_edge_kind, mcp__atlas__atlas_public_clusters, mcp__atlas__atlas_public_stats, mcp__atlas__atlas_public_wiki_page
+version: 0.1.0
+---
+
+# atlas-graph-query
+
+A thin reference for the Atlas knowledge-graph MCP tool surface so any agent
+(including sub-agents) can query the graph without re-deriving conventions. The
+server URL is wired natively by the `atlas` plugin and is overridable via
+`ATLAS_MCP_URL`. Never invent node ids — only use ids returned by these tools.
+
+> **Position: this is the SECONDARY / enrichment layer.** The `atlas` plugin is
+> scan-first — it inventories your REAL systems by scanning your actual sources
+> (Azure via read-only `az`, git repos, local directories) and process/data
+> mining them. The graph queries below are used ONLY to add best-practice /
+> comparison context to those already-discovered real systems. Do NOT use the
+> graph as the primary content, and never pad a real inventory with generic
+> catalog nodes. Tie every graph lookup back to a real scanned system.
+
+## Tools
+
+### `mcp__atlas__atlas_public_search`
+Full-text/semantic search over the graph. Key params: `q` (query), optional
+`kind` filter, `limit`. Prefer it to find seed/anchor nodes from need terms.
+
+### `mcp__atlas__atlas_public_record`
+Fetch one node's full record by `id` (fields + edges). Use `expandNeighbors` to
+pull immediate relations in one call. Prefer it to read detail once you have ids.
+
+### `mcp__atlas__atlas_public_neighbors`
+Traverse the graph from a node. Key params: `id`, `depth`, `edges` (edge-kind
+filter), `kinds` (node-kind filter). Prefer it to expand a subsystem from anchors.
+
+### `mcp__atlas__atlas_public_kinds`
+List all node kinds in the graph. Use to scope a domain to relevant kinds.
+
+### `mcp__atlas__atlas_public_kind`
+Describe a single node kind (schema/fields). Use before relying on a kind's shape.
+
+### `mcp__atlas__atlas_public_edge_kinds`
+List all edge kinds. Use to understand how nodes relate.
+
+### `mcp__atlas__atlas_public_edge_kind`
+Describe a single edge kind. Use to interpret a specific relation type.
+
+### `mcp__atlas__atlas_public_clusters`
+List graph clusters (thematic groupings). Use to scope a domain to cluster(s).
+
+### `mcp__atlas__atlas_public_stats`
+Graph-level counts/metrics. Use for sizing and sanity checks.
+
+### `mcp__atlas__atlas_public_wiki_page`
+Fetch a narrative wiki page for context. Use to capture human-readable nuance.
+
+## Query recipes
+
+- **Find by need** — `atlas_public_search(q=<need terms>)` → take top ids.
+- **Expand a subsystem** — `atlas_public_neighbors(id, depth=2, kinds=[...])`.
+- **Inspect a node** — `atlas_public_record(id, expandNeighbors=true)`.
+- **Browse a cluster** — `atlas_public_clusters` → pick cluster → `search`/
+  `neighbors` scoped to it.

package/skills/collect-nuances/SKILL.md

@@ -0,0 +1,20 @@
+---
+name: collect-nuances
+description: Collect the REAL constraints/gotchas of your scanned systems (IaC drift, orphaned resources, RBAC quirks, region splits), each cited; Atlas-graph comparison secondary.
+---
+
+# collect-nuances
+
+Invoke the babysitter:babysit skill (using the Skill tool) and follow its instructions (SKILL.md). Run the PRE-AUTHORED atlas process bundled with this plugin — do NOT interview the user or author a new process. Create the run directly from this bundled entry and iterate it to completion:
+
+```
+${COPILOT_PLUGIN_DIR}/processes/atlas-collect-nuances.mjs#process
+```
+
+(e.g. `babysitter run:create --process-id atlas-collect-nuances --entry "${COPILOT_PLUGIN_DIR}/processes/atlas-collect-nuances.mjs#process" --harness <this-harness>`, then iterate.) Pass the user arguments below as the run's stated need / process inputs. Continue executing in this same turn; do not stop after the Skill tool returns.
+
+This process is SCAN-FIRST: it parses the stated sources, then runs READ-ONLY scans (Bash `az` + git/fs) of the user's REAL systems to collect actual constraints/gotchas/edge-cases — IaC-as-survey drift, orphaned cloud resources, RBAC/visibility quirks, region splits, tenant/descriptor mismatches, externally-deployed systems with no in-repo pipeline — each cited to its real resource id / RG / file path (or a concrete missing-thing observation). The Atlas knowledge graph (mcp__atlas__atlas_public_*) is used only as SECONDARY comparison. Never invent constraints; only inspect the sources named in the arguments.
+
+User arguments for this command:
+
+$ARGUMENTS

package/skills/discover/SKILL.md

@@ -0,0 +1,20 @@
+---
+name: discover
+description: Scan your real systems (Azure + repos + dirs) and map them into a layered, source-cited atlas; enrich against the Atlas graph (secondary).
+---
+
+# discover
+
+Invoke the babysitter:babysit skill (using the Skill tool) and follow its instructions (SKILL.md). Run the PRE-AUTHORED atlas process bundled with this plugin — do NOT interview the user or author a new process. Create the run directly from this bundled entry and iterate it to completion:
+
+```
+${COPILOT_PLUGIN_DIR}/processes/atlas-systems-discovery.mjs#process
+```
+
+(e.g. `babysitter run:create --process-id atlas-systems-discovery --entry "${COPILOT_PLUGIN_DIR}/processes/atlas-systems-discovery.mjs#process" --harness <this-harness>`, then iterate.) Pass the user arguments below as the run's stated need / process inputs. Continue executing in this same turn; do not stop after the Skill tool returns.
+
+This process is SCAN-FIRST: it parses the stated sources, then runs READ-ONLY scans of the user's REAL systems — Azure via `az` (Bash), git repos, and local directories — and synthesizes a cross-linked, source-cited atlas where every item cites a real resource id / RG / file path. The Atlas knowledge graph (mcp__atlas__atlas_public_*) is used only as SECONDARY enrichment/comparison, never as the primary content. Never invent resource ids or file paths; only scan the sources named in the arguments.
+
+User arguments for this command:
+
+$ARGUMENTS

package/skills/mine-data/SKILL.md

@@ -0,0 +1,20 @@
+---
+name: mine-data
+description: Mine the REAL data stores/models in your sources (cloud DBs via az, schemas/migrations, package types), each cited; Atlas-graph comparison secondary.
+---
+
+# mine-data
+
+Invoke the babysitter:babysit skill (using the Skill tool) and follow its instructions (SKILL.md). Run the PRE-AUTHORED atlas process bundled with this plugin — do NOT interview the user or author a new process. Create the run directly from this bundled entry and iterate it to completion:
+
+```
+${COPILOT_PLUGIN_DIR}/processes/atlas-data-mining.mjs#process
+```
+
+(e.g. `babysitter run:create --process-id atlas-data-mining --entry "${COPILOT_PLUGIN_DIR}/processes/atlas-data-mining.mjs#process" --harness <this-harness>`, then iterate.) Pass the user arguments below as the run's stated need / process inputs. Continue executing in this same turn; do not stop after the Skill tool returns.
+
+This process is SCAN-FIRST: it parses the stated sources, then runs READ-ONLY scans to mine the REAL data — cloud databases/storage/AI-Search via `az` (Bash), and schemas/migrations/ORM models/package types in the repos/dirs — binding models to the stores that back them, each cited to its real resource id / file path. The Atlas knowledge graph (mcp__atlas__atlas_public_*) is used only as SECONDARY comparison. Never invent stores or models; only mine the sources named in the arguments. Never read secret values.
+
+User arguments for this command:
+
+$ARGUMENTS

package/skills/mine-processes/SKILL.md

@@ -0,0 +1,20 @@
+---
+name: mine-processes
+description: Mine the REAL processes in your sources (CI/CD, npm scripts, IaC, Dockerfiles, .a5c, cron), each cited to its file; Atlas-graph comparison secondary.
+---
+
+# mine-processes
+
+Invoke the babysitter:babysit skill (using the Skill tool) and follow its instructions (SKILL.md). Run the PRE-AUTHORED atlas process bundled with this plugin — do NOT interview the user or author a new process. Create the run directly from this bundled entry and iterate it to completion:
+
+```
+${COPILOT_PLUGIN_DIR}/processes/atlas-process-mining.mjs#process
+```
+
+(e.g. `babysitter run:create --process-id atlas-process-mining --entry "${COPILOT_PLUGIN_DIR}/processes/atlas-process-mining.mjs#process" --harness <this-harness>`, then iterate.) Pass the user arguments below as the run's stated need / process inputs. Continue executing in this same turn; do not stop after the Skill tool returns.
+
+This process is SCAN-FIRST: it parses the stated sources, then runs READ-ONLY scans (Bash) of the REAL repos/dirs/cloud automation and mines the processes that actually exist — `.github/workflows`, npm scripts, terraform/bicep/helm/k8s, Dockerfiles, babysitter `.a5c` processes, and cron/scheduled jobs — each cited to its real file path. The Atlas knowledge graph (mcp__atlas__atlas_public_*) is used only as SECONDARY comparison. Never invent files or processes; only mine the sources named in the arguments.
+
+User arguments for this command:
+
+$ARGUMENTS

package/versions.json

@@ -0,0 +1,4 @@
+{
+  "sdkVersion": "5.1.1-staging.0007199a1cb2",
+  "extensionVersion": "5.1.1-staging.0007199a1cb2"
+}