agentsys 5.5.0 → 5.7.0

package/.kiro/skills/repo-mapping/SKILL.md

@@ -1,83 +0,0 @@
----
-name: repo-mapping
-description: "Use when user asks to \"create repo map\", \"generate repo map\", \"update repo map\", \"repo map status\", or \"map symbols/imports\". Builds and validates an AST-based repo map using ast-grep."
-argument-hint: "[action] [--force]"
----
-
-# Repo Mapping Skill
-
-Build and maintain a cached AST-based map of repository symbols and imports using ast-grep.
-
-## Parse Arguments
-
-```javascript
-const args = '$ARGUMENTS'.split(' ').filter(Boolean);
-const action = args.find(a => !a.startsWith('--')) || 'status';
-const force = args.includes('--force');
-```
-
-## Primary Responsibilities
-
-1. **Generate map** on demand (`/repo-map init`)
-2. **Update map** incrementally (`/repo-map update`)
-3. **Check status** and staleness (`/repo-map status`)
-4. **Validate output** with the map-validator agent
-
-## Core Data Contract
-
-Repo map is stored in the platform state directory:
-
-- Claude Code: `.claude/repo-map.json`
-- OpenCode: `.opencode/repo-map.json`
-- Codex CLI: `.codex/repo-map.json`
-
-Minimal structure:
-
-```json
-{
-  "version": "1.0.0",
-  "generated": "2026-01-25T12:00:00Z",
-  "updated": "2026-01-25T12:05:00Z",
-  "git": { "commit": "abc123", "branch": "main" },
-  "project": { "languages": ["typescript", "python"] },
-  "stats": { "totalFiles": 142, "totalSymbols": 847 },
-  "files": {
-    "src/auth/login.ts": {
-      "hash": "deadbeef1234abcd",
-      "language": "typescript",
-      "symbols": { "exports": [], "functions": [], "classes": [] },
-      "imports": [ { "source": "./utils", "kind": "named" } ]
-    }
-  }
-}
-```
-
-## Behavior Rules
-
-- **Never** run ast-grep without user approval if it is not installed
-- **Never** install dependencies without explicit user consent
-- **Always** validate map output with `map-validator` after init/update
-- **Prefer** incremental update unless map is stale or history rewritten
-
-## When to Suggest Repo Map
-
-If a user asks for drift detection, documentation alignment, or repo analysis and repo-map is missing:
-
-```
-Repo map not found. For better analysis, run:
-  /repo-map init
-```
-
-## Staleness Signals
-
-- Map commit not found (rebased)
-- Branch changed
-- Git hooks marked stale
-- Commits behind HEAD
-
-## Output Expectations
-
-Keep outputs concise:
-
-- **init/update**: file count, symbol count, commit, warnings
-- **status**: staleness, commits behind, last updated

package/lib/repo-map/concurrency.js

@@ -1,29 +0,0 @@
-'use strict';
-
-async function runWithConcurrency(items, limit, worker) {
-  if (!Array.isArray(items) || items.length === 0) {
-    return [];
-  }
-
-  const maxConcurrency = Math.max(1, Math.min(items.length, Math.floor(limit) || 1));
-  const results = new Array(items.length);
-  let cursor = 0;
-
-  async function runWorker() {
-    while (true) {
-      const index = cursor;
-      cursor += 1;
-      if (index >= items.length) {
-        return;
-      }
-      results[index] = await worker(items[index], index);
-    }
-  }
-
-  await Promise.all(Array.from({ length: maxConcurrency }, () => runWorker()));
-  return results;
-}
-
-module.exports = {
-  runWithConcurrency
-};

package/lib/repo-map/queries/go.js

@@ -1,27 +0,0 @@
-/**
- * Go query patterns for ast-grep
- */
-
-'use strict';
-
-module.exports = {
-  exports: [],
-  functions: [
-    { pattern: 'func $NAME($$$) { $$$ }', nameVar: 'NAME' },
-    { pattern: 'func ($$$) $NAME($$$) { $$$ }', nameVar: 'NAME' }
-  ],
-  classes: [],
-  types: [
-    { pattern: 'type $NAME struct { $$$ }', nameVar: 'NAME' },
-    { pattern: 'type $NAME interface { $$$ }', nameVar: 'NAME' },
-    { pattern: 'type $NAME = $$$', nameVar: 'NAME' }
-  ],
-  constants: [
-    { pattern: 'const $NAME = $$$', nameVar: 'NAME' },
-    { pattern: 'const $NAME $TYPE = $$$', nameVar: 'NAME' }
-  ],
-  imports: [
-    { pattern: 'import $SOURCE', sourceVar: 'SOURCE', kind: 'import' },
-    { pattern: 'import $NAME $SOURCE', sourceVar: 'SOURCE', kind: 'import' }
-  ]
-};

package/lib/repo-map/queries/index.js

@@ -1,100 +0,0 @@
-/**
- * Language-specific query patterns for ast-grep
- *
- * @module lib/repo-map/queries
- */
-
-'use strict';
-
-const path = require('path');
-
-const javascript = require('./javascript');
-const typescript = require('./typescript');
-const python = require('./python');
-const rust = require('./rust');
-const go = require('./go');
-const java = require('./java');
-
-/**
- * Get query patterns for a language
- * @param {string} language - Language name
- * @returns {Object|null}
- */
-function getQueriesForLanguage(language) {
-  switch (language) {
-    case 'javascript':
-    case 'js':
-    case 'node':
-      return javascript;
-    case 'typescript':
-    case 'ts':
-      return typescript;
-    case 'python':
-    case 'py':
-      return python;
-    case 'rust':
-      return rust;
-    case 'go':
-      return go;
-    case 'java':
-      return java;
-    default:
-      return null;
-  }
-}
-
-/**
- * Get base ast-grep language identifier
- * @param {string} language - Language name
- * @returns {string}
- */
-function getSgLanguage(language) {
-  switch (language) {
-    case 'javascript':
-    case 'js':
-    case 'node':
-      return 'javascript';
-    case 'typescript':
-    case 'ts':
-      return 'typescript';
-    case 'python':
-    case 'py':
-      return 'python';
-    case 'rust':
-      return 'rust';
-    case 'go':
-      return 'go';
-    case 'java':
-      return 'java';
-    default:
-      return 'javascript';
-  }
-}
-
-/**
- * Get ast-grep language identifier based on file extension
- * @param {string} filePath - File path
- * @param {string} language - Language name
- * @returns {string}
- */
-function getSgLanguageForFile(filePath, language) {
-  const ext = path.extname(filePath).toLowerCase();
-
-  if (language === 'javascript') {
-    if (ext === '.jsx') return 'jsx';
-    return 'javascript';
-  }
-
-  if (language === 'typescript') {
-    if (ext === '.tsx') return 'tsx';
-    return 'typescript';
-  }
-
-  return getSgLanguage(language);
-}
-
-module.exports = {
-  getQueriesForLanguage,
-  getSgLanguage,
-  getSgLanguageForFile
-};

package/lib/repo-map/queries/java.js

@@ -1,38 +0,0 @@
-/**
- * Java query patterns for ast-grep
- */
-
-'use strict';
-
-module.exports = {
-  exports: [
-    { pattern: 'public class $NAME { $$$ }', kind: 'class', nameVar: 'NAME' },
-    { pattern: 'public interface $NAME { $$$ }', kind: 'class', nameVar: 'NAME' },
-    { pattern: 'public enum $NAME { $$$ }', kind: 'class', nameVar: 'NAME' },
-    { pattern: 'public record $NAME($$$) { $$$ }', kind: 'class', nameVar: 'NAME' },
-    { pattern: 'public $RET $NAME($$$) { $$$ }', kind: 'function', nameVar: 'NAME' },
-    { pattern: 'public static $RET $NAME($$$) { $$$ }', kind: 'function', nameVar: 'NAME' },
-    { pattern: 'public $RET $NAME($$$);', kind: 'function', nameVar: 'NAME' }
-  ],
-  functions: [
-    { pattern: 'public $RET $NAME($$$) { $$$ }', nameVar: 'NAME' },
-    { pattern: 'public static $RET $NAME($$$) { $$$ }', nameVar: 'NAME' },
-    { pattern: 'protected $RET $NAME($$$) { $$$ }', nameVar: 'NAME' },
-    { pattern: 'private $RET $NAME($$$) { $$$ }', nameVar: 'NAME' }
-  ],
-  classes: [
-    { pattern: 'class $NAME { $$$ }', nameVar: 'NAME' },
-    { pattern: 'interface $NAME { $$$ }', nameVar: 'NAME' },
-    { pattern: 'enum $NAME { $$$ }', nameVar: 'NAME' },
-    { pattern: 'record $NAME($$$) { $$$ }', nameVar: 'NAME' }
-  ],
-  types: [],
-  constants: [
-    { pattern: 'public static final $TYPE $NAME = $$$;', nameVar: 'NAME' },
-    { pattern: 'static final $TYPE $NAME = $$$;', nameVar: 'NAME' }
-  ],
-  imports: [
-    { pattern: 'import $SOURCE;', sourceVar: 'SOURCE', kind: 'import' },
-    { pattern: 'import static $SOURCE;', sourceVar: 'SOURCE', kind: 'import' }
-  ]
-};

package/lib/repo-map/queries/javascript.js

@@ -1,55 +0,0 @@
-/**
- * JavaScript query patterns for ast-grep
- */
-
-'use strict';
-
-module.exports = {
-  exports: [
-    { pattern: 'export function $NAME($$$) { $$$ }', kind: 'function', nameVar: 'NAME' },
-    { pattern: 'export async function $NAME($$$) { $$$ }', kind: 'function', nameVar: 'NAME' },
-    { pattern: 'export class $NAME { $$$ }', kind: 'class', nameVar: 'NAME' },
-    { pattern: 'export const $NAME = $$$', kind: 'constant', nameVar: 'NAME' },
-    { pattern: 'export let $NAME = $$$', kind: 'variable', nameVar: 'NAME' },
-    { pattern: 'export var $NAME = $$$', kind: 'variable', nameVar: 'NAME' },
-    { pattern: 'export default function $NAME($$$) { $$$ }', kind: 'function', nameVar: 'NAME' },
-    { pattern: 'export default class $NAME { $$$ }', kind: 'class', nameVar: 'NAME' },
-    { pattern: 'export default function ($$$) { $$$ }', kind: 'function', fallbackName: 'default' },
-    { pattern: 'export default class { $$$ }', kind: 'class', fallbackName: 'default' },
-    { pattern: 'export default $NAME', kind: 'value', nameVar: 'NAME' },
-    { pattern: 'export { $$$ }', kind: 'value', multi: 'exportList' },
-    { pattern: 'export { $$$ } from $SOURCE', kind: 're-export', multi: 'exportList', sourceVar: 'SOURCE' },
-    { pattern: 'export * from $SOURCE', kind: 're-export', fallbackName: '*', sourceVar: 'SOURCE' },
-    { pattern: 'module.exports = $NAME', kind: 'value', nameVar: 'NAME' },
-    { pattern: 'module.exports = { $$$ }', kind: 'value', multi: 'objectLiteral' },
-    { pattern: 'exports.$NAME = $$$', kind: 'value', nameVar: 'NAME' }
-  ],
-  functions: [
-    { pattern: 'function $NAME($$$) { $$$ }', nameVar: 'NAME' },
-    { pattern: 'async function $NAME($$$) { $$$ }', nameVar: 'NAME' },
-    { pattern: 'function* $NAME($$$) { $$$ }', nameVar: 'NAME' },
-    { pattern: 'async function* $NAME($$$) { $$$ }', nameVar: 'NAME' },
-    { pattern: 'const $NAME = ($$$) => $$$', nameVar: 'NAME' },
-    { pattern: 'const $NAME = async ($$$) => $$$', nameVar: 'NAME' },
-    { pattern: 'const $NAME = function ($$$) { $$$ }', nameVar: 'NAME' },
-    { pattern: 'const $NAME = async function ($$$) { $$$ }', nameVar: 'NAME' },
-    { pattern: 'let $NAME = ($$$) => $$$', nameVar: 'NAME' },
-    { pattern: 'var $NAME = ($$$) => $$$', nameVar: 'NAME' }
-  ],
-  classes: [
-    { pattern: 'class $NAME { $$$ }', nameVar: 'NAME' },
-    { pattern: 'const $NAME = class { $$$ }', nameVar: 'NAME' },
-    { pattern: 'const $NAME = class $CLASS { $$$ }', nameVar: 'NAME' }
-  ],
-  types: [],
-  constants: [],
-  imports: [
-    { pattern: 'import $NAME from $SOURCE', sourceVar: 'SOURCE', kind: 'default' },
-    { pattern: 'import * as $NAME from $SOURCE', sourceVar: 'SOURCE', kind: 'namespace' },
-    { pattern: 'import { $$$ } from $SOURCE', sourceVar: 'SOURCE', kind: 'named' },
-    { pattern: 'import $SOURCE', sourceVar: 'SOURCE', kind: 'side-effect' },
-    { pattern: 'const $NAME = require($SOURCE)', sourceVar: 'SOURCE', kind: 'require' },
-    { pattern: 'const { $$$ } = require($SOURCE)', sourceVar: 'SOURCE', kind: 'require' },
-    { pattern: 'require($SOURCE)', sourceVar: 'SOURCE', kind: 'require' }
-  ]
-};

package/lib/repo-map/queries/python.js

@@ -1,24 +0,0 @@
-/**
- * Python query patterns for ast-grep
- */
-
-'use strict';
-
-module.exports = {
-  exports: [],
-  functions: [
-    { pattern: 'def $NAME($$$): $$$', nameVar: 'NAME' },
-    { pattern: 'async def $NAME($$$): $$$', nameVar: 'NAME' }
-  ],
-  classes: [
-    { pattern: 'class $NAME($$$): $$$', nameVar: 'NAME' },
-    { pattern: 'class $NAME: $$$', nameVar: 'NAME' }
-  ],
-  types: [],
-  constants: [],
-  imports: [
-    { pattern: 'import $SOURCE', sourceVar: 'SOURCE', kind: 'import', multiSource: true },
-    { pattern: 'from $SOURCE import $NAME', sourceVar: 'SOURCE', kind: 'from' },
-    { pattern: 'from $SOURCE import ($$$)', sourceVar: 'SOURCE', kind: 'from' }
-  ]
-};

package/lib/repo-map/queries/rust.js

@@ -1,73 +0,0 @@
-/**
- * Rust query patterns for ast-grep
- */
-
-'use strict';
-
-module.exports = {
-  exports: [
-    { pattern: 'pub fn $NAME($$$) { $$$ }', kind: 'function', nameVar: 'NAME' },
-    { pattern: 'pub(crate) fn $NAME($$$) { $$$ }', kind: 'function', nameVar: 'NAME' },
-    { pattern: 'pub(super) fn $NAME($$$) { $$$ }', kind: 'function', nameVar: 'NAME' },
-    { pattern: 'pub(in $PATH) fn $NAME($$$) { $$$ }', kind: 'function', nameVar: 'NAME' },
-    { pattern: 'pub struct $NAME { $$$ }', kind: 'type', nameVar: 'NAME' },
-    { pattern: 'pub(crate) struct $NAME { $$$ }', kind: 'type', nameVar: 'NAME' },
-    { pattern: 'pub(super) struct $NAME { $$$ }', kind: 'type', nameVar: 'NAME' },
-    { pattern: 'pub(in $PATH) struct $NAME { $$$ }', kind: 'type', nameVar: 'NAME' },
-    { pattern: 'pub enum $NAME { $$$ }', kind: 'type', nameVar: 'NAME' },
-    { pattern: 'pub(crate) enum $NAME { $$$ }', kind: 'type', nameVar: 'NAME' },
-    { pattern: 'pub(super) enum $NAME { $$$ }', kind: 'type', nameVar: 'NAME' },
-    { pattern: 'pub(in $PATH) enum $NAME { $$$ }', kind: 'type', nameVar: 'NAME' },
-    { pattern: 'pub trait $NAME { $$$ }', kind: 'type', nameVar: 'NAME' },
-    { pattern: 'pub(crate) trait $NAME { $$$ }', kind: 'type', nameVar: 'NAME' },
-    { pattern: 'pub(super) trait $NAME { $$$ }', kind: 'type', nameVar: 'NAME' },
-    { pattern: 'pub(in $PATH) trait $NAME { $$$ }', kind: 'type', nameVar: 'NAME' },
-    { pattern: 'pub type $NAME = $$$', kind: 'type', nameVar: 'NAME' },
-    { pattern: 'pub(crate) type $NAME = $$$', kind: 'type', nameVar: 'NAME' },
-    { pattern: 'pub(super) type $NAME = $$$', kind: 'type', nameVar: 'NAME' },
-    { pattern: 'pub(in $PATH) type $NAME = $$$', kind: 'type', nameVar: 'NAME' },
-    { pattern: 'pub const $NAME: $TYPE = $$$', kind: 'constant', nameVar: 'NAME' },
-    { pattern: 'pub(crate) const $NAME: $TYPE = $$$', kind: 'constant', nameVar: 'NAME' },
-    { pattern: 'pub(super) const $NAME: $TYPE = $$$', kind: 'constant', nameVar: 'NAME' },
-    { pattern: 'pub(in $PATH) const $NAME: $TYPE = $$$', kind: 'constant', nameVar: 'NAME' },
-    { pattern: 'pub static $NAME: $TYPE = $$$', kind: 'constant', nameVar: 'NAME' },
-    { pattern: 'pub(crate) static $NAME: $TYPE = $$$', kind: 'constant', nameVar: 'NAME' },
-    { pattern: 'pub(super) static $NAME: $TYPE = $$$', kind: 'constant', nameVar: 'NAME' },
-    { pattern: 'pub(in $PATH) static $NAME: $TYPE = $$$', kind: 'constant', nameVar: 'NAME' },
-    { pattern: 'pub mod $NAME { $$$ }', kind: 'module', nameVar: 'NAME' },
-    { pattern: 'pub(crate) mod $NAME { $$$ }', kind: 'module', nameVar: 'NAME' },
-    { pattern: 'pub(super) mod $NAME { $$$ }', kind: 'module', nameVar: 'NAME' },
-    { pattern: 'pub(in $PATH) mod $NAME { $$$ }', kind: 'module', nameVar: 'NAME' },
-    { pattern: 'pub mod $NAME;', kind: 'module', nameVar: 'NAME' }
-  ],
-  functions: [
-    { pattern: 'fn $NAME($$$) { $$$ }', nameVar: 'NAME' },
-    { pattern: 'async fn $NAME($$$) { $$$ }', nameVar: 'NAME' },
-    { pattern: 'pub fn $NAME($$$) { $$$ }', nameVar: 'NAME' },
-    { pattern: 'pub(crate) fn $NAME($$$) { $$$ }', nameVar: 'NAME' },
-    { pattern: 'pub(super) fn $NAME($$$) { $$$ }', nameVar: 'NAME' },
-    { pattern: 'pub(in $PATH) fn $NAME($$$) { $$$ }', nameVar: 'NAME' },
-    { pattern: 'pub async fn $NAME($$$) { $$$ }', nameVar: 'NAME' },
-    { pattern: 'pub(crate) async fn $NAME($$$) { $$$ }', nameVar: 'NAME' }
-  ],
-  classes: [],
-  types: [
-    { pattern: 'struct $NAME { $$$ }', nameVar: 'NAME' },
-    { pattern: 'enum $NAME { $$$ }', nameVar: 'NAME' },
-    { pattern: 'trait $NAME { $$$ }', nameVar: 'NAME' },
-    { pattern: 'type $NAME = $$$', nameVar: 'NAME' },
-    { pattern: 'pub struct $NAME { $$$ }', nameVar: 'NAME' },
-    { pattern: 'pub enum $NAME { $$$ }', nameVar: 'NAME' },
-    { pattern: 'pub trait $NAME { $$$ }', nameVar: 'NAME' },
-    { pattern: 'pub type $NAME = $$$', nameVar: 'NAME' }
-  ],
-  constants: [
-    { pattern: 'const $NAME: $TYPE = $$$', nameVar: 'NAME' },
-    { pattern: 'static $NAME: $TYPE = $$$', nameVar: 'NAME' }
-  ],
-  imports: [
-    { pattern: 'use $SOURCE;', sourceVar: 'SOURCE', kind: 'use' },
-    { pattern: 'use $SOURCE::{ $$$ };', sourceVar: 'SOURCE', kind: 'use' },
-    { pattern: 'use $SOURCE::*;', sourceVar: 'SOURCE', kind: 'use' }
-  ]
-};

package/lib/repo-map/queries/typescript.js

@@ -1,38 +0,0 @@
-/**
- * TypeScript query patterns for ast-grep
- */
-
-'use strict';
-
-const javascript = require('./javascript');
-
-module.exports = {
-  exports: [
-    ...javascript.exports,
-    { pattern: 'export interface $NAME { $$$ }', kind: 'type', nameVar: 'NAME' },
-    { pattern: 'export type $NAME = $$$', kind: 'type', nameVar: 'NAME' },
-    { pattern: 'export enum $NAME { $$$ }', kind: 'type', nameVar: 'NAME' },
-    { pattern: 'export namespace $NAME { $$$ }', kind: 'type', nameVar: 'NAME' },
-    { pattern: 'export const enum $NAME { $$$ }', kind: 'type', nameVar: 'NAME' },
-    { pattern: 'export = $NAME', kind: 'value', nameVar: 'NAME' },
-    { pattern: 'export as namespace $NAME', kind: 'namespace', nameVar: 'NAME' }
-  ],
-  functions: javascript.functions,
-  classes: [
-    ...javascript.classes,
-    { pattern: 'abstract class $NAME { $$$ }', nameVar: 'NAME' }
-  ],
-  types: [
-    { pattern: 'interface $NAME { $$$ }', nameVar: 'NAME' },
-    { pattern: 'type $NAME = $$$', nameVar: 'NAME' },
-    { pattern: 'enum $NAME { $$$ }', nameVar: 'NAME' },
-    { pattern: 'namespace $NAME { $$$ }', nameVar: 'NAME' },
-    { pattern: 'const enum $NAME { $$$ }', nameVar: 'NAME' }
-  ],
-  constants: javascript.constants,
-  imports: [
-    ...javascript.imports,
-    { pattern: 'import type { $$$ } from $SOURCE', sourceVar: 'SOURCE', kind: 'type' },
-    { pattern: 'import type $NAME from $SOURCE', sourceVar: 'SOURCE', kind: 'type' }
-  ]
-};