@automaton-labs/aib 0.0.6 → 0.0.8

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

@@ -1,45 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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.cycles.md

@@ -1,36 +0,0 @@
-Use cycles to find import cycles in a file or directory scope.
-
-Cycles reports cyclic components, not every possible path through a dense graph.
-It classifies cycles as runtime, type-only, or mixed.
-
-Start broad with summary output.
-Use detail=imports when you need the import edges that explain a cycle.
-Use detail=files when file membership is enough.
-
-Controls:
-scope   file or directory scope
-files   focus cycles that include one or more files
-detail  summary|imports|files
-limit   max cyclic components shown
-
-Run:
-aib inspect cycles <scope>
-
-Inline:
-aib inspect cycles src/features --limit 20
-aib inspect cycles src/features --detail imports --limit 20
-aib inspect cycles --files src/features/service.ts --detail imports
-
-Stdin:
-aib inspect --stdin
-
-Input:
-cycles src/features limit=20
-cycles src/features detail=imports limit=20
-cycles scope=src/features files=[src/features/service.ts] detail=imports
-
-If output hides components and shows a view handle, inspect only the hidden part:
-
-aib view <handle> --offset 2 --limit 2
-aib view <handle> --index 4 --detail imports
-aib view <handle> --index 5 --detail files

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

@@ -1,44 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,137 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,86 +0,0 @@
-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
-local import cycles              cycles
-
-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

@@ -1,30 +0,0 @@
-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

@@ -1,22 +0,0 @@
-Use tree to list a compact directory layout.
-It is useful before focused inspect when you know the area but not the exact file.
-
-Controls:
-scope, depth, minDepth, limit, only, exclude, onlyDirs, ned, nec
-
-Specific:
-depth     max nesting depth; depth=N
-minDepth  hide shallower paths; minDepth=N
-onlyDirs  show directories only; +onlyDirs
-only      only matching files/dirs; only=[...]
-exclude   skip matching files/dirs; exclude=[...]
-ned       no-default-exclude; ignore built-in excludes; +ned
-nec       no-config-exclude; ignore aib.json tree excludes; +nec
-
-Run:
-aib inspect --stdin
-
-Input:
-tree src depth=4 +onlyDirs limit=200 +ned +nec
-tree @svc depth=3 only=["**/*.ts"] exclude=["**/*.test.ts","**/* copy.ts"]
-tree src depth=3 only=["src/services/**"] limit=80

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

@@ -1,59 +0,0 @@
-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"
-}

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

@@ -1,60 +0,0 @@
-Modes: preview/apply or execute.
-Use execute for routine changes.
-Use preview/apply when learning a mutation command or inspecting a large multi-step request before writing files.
-
-If a name is ambiguous, use selectors.
-Run help selectors to refresh selector syntax.
-
-modulePlan is for splitting large files into smaller modules.
-Use it when a large file should be refactored into several target files.
-
-modulePlan orchestrates semantic moves and updates affected references/imports.
-
-If imports created by modulePlan do not match the repo style, run:
-aib help config-setup.import-rules
-
-Use expectEmpty when your modulePlan intent is to move all declarations out of the source file.
-It does not change the move behavior; it only asks output to report remaining source declarations if any remain.
-Use it only when remaining declarations would mean the split did not match your intent.
-Do not use it for partial extractions.
-
-Plan:
-modulePlan preview --stdin
-modulePlan execute --stdin
-modulePlan apply <planId>
-
-Use preview/apply when you want to inspect the plan before writing files.
-Use execute when you want to preview and apply immediately.
-Use --from with captured input handles when rerunning edited large plans.
-
-Split one large source file into several targets:
-Run:
-aib modulePlan execute --stdin
-
-Input:
-{
-  "sourceFile": "src/large-service.ts",
-  "expectEmpty": true,
-  "modules": [
-    {
-      "target": "src/large-service.types.ts",
-      "entities": ["ServiceOptions", "ServiceMode"]
-    },
-    {
-      "target": "src/large-service.core.ts",
-      "entities": ["LargeService", "createLargeService"]
-    }
-  ]
-}
-
-If a large or partial modulePlan request fails, edit the captured input file and rerun with --from.
-For small one-off modulePlan requests, write a corrected request instead.
-
-Latest modulePlan input:
-<session-dir>/inputs/modulePlan/_last.json
-
-Handle:
-aib:input:modulePlan:last
-
-Example:
-modulePlan preview --from aib:input:modulePlan:last