@automaton-labs/aib 0.0.1

package/dist/help/json/snippets/agents.md

@@ -0,0 +1,14 @@
+Recommended:
+For TS/JS code work, use aib. Start with {{docsPath}}.
+
+Strict:
+For TS/JS code work in this repo, prefer aib before broad file reads. Start with {{docsPath}}.
+
+Minimal:
+Use {{docsPath}} when working with TS/JS code.
+
+Help fallback:
+For TS/JS code work, use aib. Start with {{docsPath}}. If local docs are not enough, run `aib help bootstrap`.
+
+Refactor-focused:
+When changing TS/JS code, use aib for semantic discovery, usages, graph, rename, move, and modulePlan. Start with {{docsPath}}.

package/dist/help/json/topics/basics.md

@@ -0,0 +1,13 @@
+Use the active session while you work.
+Reuse captured inputs when editing them is cheaper than rebuilding large JSON.
+
+Examples are patterns, not limits.
+Feature sections show common high-value uses, not every valid use.
+Adapt requests to the task: combine features, batch related questions, and skip steps when you already have enough context.
+
+Prefer batch JSON instead of inline calls.
+One request can inspect/mutate several files/entities and save reusable outputs.
+Use one-off commands only for small checks/changes.
+
+For mutations, aib asks TS/IDE refactors to update affected references and imports.
+After a successful mutation, do not manually patch the same imports unless aib reports a follow-up or the build/checks show a real issue.

package/dist/help/json/topics/dsl.md

@@ -0,0 +1,23 @@
+DSL request model:
+- directives set defaults for following requests
+- each request line can override defaults with key=value
+- +flag means true
+- -flag means false
+- file/imports/exports/members/code/deps accept a path as the first positional argument; examples below use this shape.
+- Use @file when several following operations share the same file.
+- For one-off file operations, pass the path directly.
+
+Syntax:
+@file <path>               default file
+@source <path>             default sourceFile for mutations
+op arg arg key=value       request
++flag                      boolean true
+-flag                      boolean false
+>name                      save reusable artifact when supported
+old->new                   rename pair
+Parent.member              parent-qualified member
+Parent.{a,b}               several members under one parent
+key=[a,b]                  list value for repeatable fields
+file="path with spaces.ts" quote values with spaces
+detail=sum|loc|code        aliases for summary|locations|code
+from=...                   alias for fromFile

package/dist/help/json/topics/help-format.md

@@ -0,0 +1,10 @@
+Inline commands below omit the aib prefix.
+Run them as: aib <command>
+
+Stdin examples show command and input separately to avoid shell-specific syntax.
+Stdin Run lines include the aib prefix to avoid confusion.
+
+PowerShell stdin shape:
+@'
+<input>
+'@ | aib <command> --stdin

package/dist/help/json/topics/imports.normalize.md

@@ -0,0 +1,45 @@
+Use imports normalize for explicit import-style cleanup.
+It rewrites resolved local import/export specifiers inside a chosen file or directory.
+
+Use importNormalize in aib.json for repeated defaults.
+
+Good for:
+- converting one area to aliases or relative imports
+- cleaning import style after manual edits or broad refactors
+- applying the same import style to a directory without hand-editing files
+- applying new tsconfig aliases after they are added
+
+Controls:
+scope        file/dir scope to normalize
+to           relative|alias|shortestAlias
+preferAlias  select one tsconfig paths pattern when several aliases can resolve the same file
+exclude      files, directories, or glob-like patterns to skip
+all          show all planned edits; avoid on broad directory scopes
+
+Run:
+aib imports normalize preview --stdin
+
+Input:
+{
+  "scope": "src/services",
+  "to": "shortestAlias",
+  "exclude": ["src/services/generated", "**/* copy.ts"]
+}
+
+Rewrite imports found inside src/core.
+When an imported file can be expressed through @features/*, prefer that alias.
+
+Run:
+aib imports normalize preview --stdin
+
+Input:
+{
+  "scope": "src/core",
+  "to": "alias",
+  "preferAlias": "@features/*"
+}
+
+With matching importNormalize config for this scope or a parent scope, use inline CLI commands:
+
+imports normalize preview @svc
+imports normalize execute @svc

package/dist/help/json/topics/inspect.code.md

@@ -0,0 +1,39 @@
+Use code to fetch exact declarations or members.
+It returns focused code without reading the whole file.
+
+Good for:
+- reading a known function, class, method, or declaration
+- fetching several related code blocks in one request
+- keeping context focused on code needed for the current task
+
+Controls:
+file, entity, entities, parent, show, ranges
+
+Specific:
+show  include source output
+
+Defaults: +show +ranges
+Use -show for names/ranges only.
+Use -ranges for source without ranges.
+
+Prefs:
+inspect.code.maxNonEmptyLines
+
+Run:
+aib inspect --stdin
+
+Input:
+{
+  "file": "src/service.ts",
+  "op": "code",
+  "requests": [
+    {
+      "entities": [
+        { "parent": "Service", "entities": ["render", "reset"] },
+        "normalize"
+      ],
+      "show": true,
+      "save": "service-focus"
+    }
+  ]
+}

package/dist/help/json/topics/inspect.deps.md

@@ -0,0 +1,44 @@
+Use deps to see what one entity depends on inside its file.
+It separates type-only dependencies from runtime value dependencies.
+
+Good for:
+- checking what a symbol may need when moved or extracted
+- spotting nearby types, constants, or helpers tied to one entity
+- deciding whether one symbol is standalone or tied to nearby declarations
+- debugging mutation failures caused by local dependency shape
+
+Controls:
+file, entity, entities, parent
+
+Run:
+aib inspect --stdin
+
+Input:
+{
+  "file": "src/service.ts",
+  "op": "deps",
+  "requests": [
+    { "entity": "createService" },
+    {
+      "entities": [
+        { "parent": "Service", "entities": ["render", "reset"] }
+      ]
+    }
+  ]
+}
+
+inspect deps src/service.ts Service
+
+Batch several symbols when you are planning a move:
+Run:
+aib inspect --stdin
+
+Input:
+{
+  "file": "src/service.ts",
+  "requests": [
+    { "op": "deps", "entity": "Service" },
+    { "op": "deps", "entity": "ServiceOptions" },
+    { "op": "deps", "entity": "createService" }
+  ]
+}

package/dist/help/json/topics/inspect.duplicates.md

@@ -0,0 +1,37 @@
+Use duplicates to find repeated top-level names and exact declaration copies.
+It is useful when many files may contain copied local helpers, duplicated types, or repeated declarations.
+
+Start with summary for broad scopes.
+Use locations when you need files/lines.
+Use code only for duplicate names you are ready to inspect.
+
+Controls:
+scope, detail, limit, offset, kinds, entities, exclude, pathExclude
+
+Specific:
+entities    only these duplicate names/selectors
+exclude     skip these names/selectors
+pathExclude skip files or path/glob-like patterns
+kinds       selector kinds, e.g. f, t, c, etc.; kinds=[...]
+
+Summary scan:
+Run:
+aib inspect --stdin
+
+Input:
+{
+  "scope": "src",
+  "detail": "summary",
+  "limit": 20
+}
+
+Inspect specific duplicate code:
+Run:
+aib inspect --stdin
+
+Input:
+{
+  "scope": "src",
+  "detail": "code",
+  "entities": ["getBoolean", "WsOptions"]
+}

package/dist/help/json/topics/inspect.exports.md

@@ -0,0 +1,38 @@
+Use exports to see the public API of one file.
+It answers what other files can import from that file.
+
+Important:
+inspect.file marks exported declarations already.
+
+Do not batch this for a plain implementation file:
+file src/service.ts
+exports src/service.ts
+
+Use exports when you need public module surface, barrels, re-exports, export *, or resolveStar.
+
+Good for:
+- checking a module boundary or public surface
+- understanding facade/barrel files
+- resolving export * when the local file only re-exports from elsewhere
+- comparing API shape when public imports matter
+
+Controls:
+file, ranges, resolveStar
+
+Specific:
+resolveStar  resolve export * through re-exported modules; +resolveStar
+
+Run:
+aib inspect --stdin
+
+Input:
+{
+  "op": "exports",
+  "file": "src/service.ts",
+  "requests": [
+    { "ranges": true },
+    { "file": "src/index.ts", "resolveStar": true }
+  ]
+}
+
+inspect exports src/service.ts [--ranges] [--resolve-star]

package/dist/help/json/topics/inspect.file.md

@@ -0,0 +1,36 @@
+Use file to map top-level declarations physically present in one file.
+Exported declarations are marked in the output.
+It shows what lives in the file before you decide whether to read code.
+
+Good for:
+- mapping an unfamiliar file
+- listing top-level declarations
+- checking whether a file contains real declarations or mostly re-exports
+
+Do not add limit just in case.
+file output is compact and most files have far fewer than 100 top-level declarations.
+Use limit only after file output is actually too large.
+
+Controls:
+file, ranges, localOnly
+
+Specific:
+localOnly   show local declarations and reexports without resolving facade API; +localOnly
+
+Defaults: +ranges
+Use -ranges to show names without ranges.
+
+Run:
+aib inspect --stdin
+
+Input:
+{
+  "op": "file",
+  "file": "src/service.ts",
+  "requests": [
+    { "ranges": true },
+    { "file": "src/index.ts", "localOnly": true }
+  ]
+}
+
+inspect file src/service.ts [--ranges] [--local-only]

package/dist/help/json/topics/inspect.graph.md

@@ -0,0 +1,137 @@
+Use graph when the question is about file/module boundaries, not one symbol.
+It builds a reusable map of local import relationships, then lets you focus files inside that map.
+
+Good for:
+- mapping an unfamiliar directory or subsystem
+- seeing which files are hubs, entrypoints, or leaves
+- comparing a few known areas without mapping all src
+- choosing files/entities to inspect next
+- checking module boundaries when ownership is unclear
+
+Use deps for one entity's outgoing dependencies.
+Use usages for real incoming references.
+Use graph for file-level connectivity.
+
+Model:
+build graph: scope + view + save
+query graph: fromFile + focus + output toggles
+
+view controls what enters the saved graph.
+focus only expands details for files already inside it.
+If focus misses a file, rebuild with wider scope or view.
+
+Default view:
+directory scope -> local
+file or multiple scopes -> neighbors
+fromFile -> uses the saved graph
+
+Views:
+local      only files inside scope; best directory map
+neighbors  direct import neighborhood; best file-centered map
+expanded   wider neighborhood; more output
+
+Scope choice:
+scope: "src" creates a broad reusable map for src.
+scope: "src/services" is cheaper for local work.
+scope: [...] compares known areas without mapping all src.
+
+After you understand which graph sections matter, hide the rest with JSON fields or prefs.
+Graph can be noisy; shape it for the current task.
+
+Controls:
+scope, view, from, focus, symbolUsage, edges, hubs, entrypoints, leaves, exclude, save
+
+Specific:
+view         local|neighbors|expanded
+from         reuse saved graph index; from=aib:graph:<name>
+focus        focus a file inside the graph; focus=path
+symbolUsage  show imported symbols on edges; +symbolUsage
+
+edges/hubs/entrypoints/leaves  output section toggles; +name or -name
+
+Run:
+aib inspect --stdin
+
+Input:
+{
+  "op": "graph",
+  "requests": [
+    {
+      "scope": "src/services",
+      "view": "local",
+      "save": "services-graph"
+    },
+    {
+      "fromFile": "aib:graph:services-graph",
+      "focus": ["src/services/users.ts", "src/services/admins.ts"],
+      "symbolUsage": true,
+      "edges": false
+    }
+  ]
+}
+
+Focus saved graph later:
+inspect graph --from-file aib:graph:services-graph --focus src/services/messages.ts --focus src/services/posts.ts --symbol-usage
+
+Inline graph focus can add focus and symbolUsage.
+Inline cannot hide graph sections such as edges/hubs/entrypoints/leaves.
+Use JSON request fields or prefs for section control.
+
+Specialized graph command:
+Run:
+aib inspect graph --stdin
+
+Input:
+{
+  "requests": [
+    {
+      "scope": "src/services",
+      "view": "local",
+      "save": "services-graph"
+    },
+    {
+      "fromFile": "aib:graph:services-graph",
+      "focus": ["src/services/users.ts", "src/services/admins.ts"],
+      "symbolUsage": true,
+      "edges": false
+    }
+  ]
+}
+
+Multiple scopes:
+Run:
+aib inspect --stdin
+
+Input:
+{
+  "op": "graph",
+  "scope": ["src/main/server", "src/services/ws"],
+  "view": "local",
+  "save": "server-ws-graph"
+}
+
+scope accepts one file/dir or an array.
+scopes is accepted as an alias for multiple scopes.
+
+Graph prefs:
+inspect.graph.edges boolean
+inspect.graph.hubs boolean
+inspect.graph.entrypoints boolean
+inspect.graph.leaves boolean
+inspect.graph.symbols boolean
+inspect.graph.symbolUsage boolean
+
+symbolUsage is usually the better first choice when imported names matter.
+
+Example:
+session prefs set inspect.graph.edges false inspect.graph.hubs false inspect.graph.symbolUsage true
+
+Output fields:
+summary       file/edge/package counts
+paths         compact path aliases used in text output
+focus         selected files with imports/importedBy
+hubs          highly connected files
+entrypoints   scoped files imported by nobody in graph
+leaves        scoped files importing nobody in graph
+edges         local file-to-file imports
+saved         reusable aib:graph handle

package/dist/help/json/topics/inspect.imports.md

@@ -0,0 +1,13 @@
+Use imports to inspect static and dynamic imports in a file.
+If there are no dynamic imports, the dynamic imports block is omitted.
+
+Controls:
+file, ranges
+
+Defaults: +ranges
+
+Run:
+aib inspect --stdin
+
+Input:
+imports @svc/service.ts

package/dist/help/json/topics/inspect.md

@@ -0,0 +1,85 @@
+Inspect helps you turn an unknown code area into a small working model.
+
+Use it to understand what exists, how pieces connect, what repeats, where a change can spread, and which exact code should enter context next.
+
+One useful flow:
+map -> focus -> code
+
+map: learn what exists and how it connects
+focus: choose files/entities/usages that matter
+code: fetch exact code needed
+
+Choose inspect operation:
+
+declarations in one file         file
+static/dynamic imports           imports
+public API                       exports
+methods/properties of parent     members
+exact implementation             code
+outgoing deps of one entity      deps
+incoming references/callers      usages
+file/module connectivity         graph
+compact directory layout         tree
+repeated declarations/helpers    duplicates
+
+Prefer one batch JSON request for related questions.
+Top-level fields are defaults for every request.
+A request without op uses the top-level op.
+A request without file/scope/target uses the top-level value when applicable.
+Each request may override any default.
+
+Batch example:
+
+Run:
+aib inspect --stdin
+
+Input:
+{
+  "file": "src/service.ts",
+  "requests": [
+    { "op": "file" },
+    { "op": "members", "entity": "Service" },
+    {
+      "op": "code",
+      "entities": [
+        { "parent": "Service", "entities": ["render", "reset"] },
+        "normalize"
+      ],
+      "show": true,
+      "save": "service-focus"
+    },
+    {
+      "op": "usages",
+      "target": "src/service.ts",
+      "entity": "normalize",
+      "scope": "src",
+      "detail": "locations"
+    },
+    {
+      "op": "duplicates",
+      "scope": "src/scripts",
+      "detail": "summary",
+      "limit": 20
+    }
+  ]
+}
+
+Inspect controls:
+
+file        default file for requests
+target      file, dir, or symbol area to analyze
+scope       where to search; JSON scope:string|string[]
+entity      one symbol
+entities    several target symbols; JSON entities:[...]
+parent      class/interface parent for methods/properties
+ranges      include line/range metadata; JSON ranges:boolean; CLI --ranges
+localOnly   show local declarations and reexports without resolving facade API; JSON localOnly:boolean; CLI --local-only
+resolveStar resolve export * through re-exported modules; JSON resolveStar:boolean; CLI --resolve-star
+limit       max items in one page; JSON limit:N; CLI --limit N
+offset      page offset; JSON offset:N; CLI --offset N
+all         return all items; JSON all:boolean; CLI --all
+detail      output level; JSON detail:summary|locations|code; CLI --detail summary|locations|code
+show        include code output; JSON show:boolean; CLI --show
+save        save reusable output; JSON save:"name"; CLI --save name
+exclude     skip names/selectors; JSON exclude:[...]
+kinds       restrict selector kinds; JSON kinds:["f","t"]

package/dist/help/json/topics/inspect.members.md

@@ -0,0 +1,30 @@
+Use members to map a class/interface/object-like symbol without reading its body.
+It shows the internal shape of a parent entity without reading its full body.
+
+Good for:
+- listing member names when the parent entity is known
+- narrowing a large parent entity to relevant members
+- understanding object shape before changing or moving related code
+
+Controls:
+file, entity, entities, ranges, limit, offset, all
+
+Prefs:
+inspect.members.maxItems
+inspect.members.all
+
+Run:
+aib inspect --stdin
+
+Input:
+{
+  "file": "src/service.ts",
+  "op": "members",
+  "limit": 12,
+  "requests": [
+    { "entity": "Service" },
+    { "entities": ["ServiceOptions", "WsOptions"], "all": true }
+  ]
+}
+
+inspect members src/service.ts Service [--limit N] [--offset N] [--all] [--ranges]

package/dist/help/json/topics/inspect.tree.md

@@ -0,0 +1,20 @@
+Use tree to list a compact directory layout.
+It is useful before focused inspect when you know the area but not the exact file.
+
+node_modules, .git, dist, build, out, and .tmp are skipped by default.
+
+Controls:
+scope, depth, minDepth, limit, include, exclude, onlyDirs
+
+Specific:
+depth     max nesting depth; depth=N
+minDepth  hide shallower paths; minDepth=N
+onlyDirs  show directories only; +onlyDirs
+include   only matching files/dirs; include=[...]
+
+Run:
+aib inspect --stdin
+
+Input:
+tree src depth=4 +onlyDirs limit=200
+tree @svc depth=3 include=["**/*.ts"] exclude=["**/*.test.ts","**/* copy.ts"]

package/dist/help/json/topics/inspect.usages.md

@@ -0,0 +1,59 @@
+Use usages to find who references a file, directory, or entity inside a scope.
+It reports real references, not unused imports or text matches.
+For broad impact checks, target-local usages are hidden automatically when the target is inside a wider scope.
+Use includeTarget only when references inside the target file or directory matter.
+
+Good for:
+- checking impact before changing behavior
+- finding consumers of an entity or module area
+- confirming whether extracted or renamed code still has callers
+- getting caller locations or caller code without broad file scans
+
+Use locations for broad impact checks.
+Use code when usage count is small or caller context matters now.
+
+Controls:
+target, scope, entity, entities, parent, detail, limit, all, save, includeTarget
+
+Specific:
+includeTarget  include references inside the target file/directory; +includeTarget
+
+Prefs:
+inspect.usages.maxLocations
+inspect.usages.maxCodeBlocks
+
+Run:
+aib inspect --stdin
+
+Input:
+{
+  "op": "usages",
+  "target": "src/service.ts",
+  "entities": [
+    "createService",
+    { "parent": "Service", "entities": ["render", "reset"] }
+  ],
+  "scope": ["src/app", "src/tests"],
+  "detail": "locations",
+  "save": "service-usages"
+}
+
+inspect usages src/service.ts createService --scope src --detail locations [--limit N] [--all] [--save name]
+
+Expand saved usages by focusing the reusable usages index:
+inspect usages --from-file aib:usages:service-usages --focus createService --detail code
+
+Use the saved usages handle with --from-file/from to focus or expand the reusable index.
+
+Directory target:
+Run:
+aib inspect --stdin
+
+Input:
+{
+  "op": "usages",
+  "target": "src/shared",
+  "scope": ["src/app", "src/renderer"],
+  "detail": "summary",
+  "save": "shared-usages"
+}