argsbarg 6.1.2 → 6.1.3

package/src/cli-tool/schemagen/schemagen.test.ts

@@ -1,5 +1,5 @@
 import { afterEach, describe, expect, test } from "bun:test";
-import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { discoverSchemaRoots } from "./discover-schema-roots.ts";
@@ -39,105 +39,195 @@ function makeTempProject(): string {
   return root;
 }
 
-function writeTypes(root: string, relDir: string, body: string): void {
-  const dir = join(root, "src", relDir);
-  mkdirSync(dir, { recursive: true });
-  writeFileSync(join(dir, "types.ts"), body);
+function writeSrcFile(root: string, relPath: string, body: string): void {
+  const full = join(root, relPath);
+  mkdirSync(join(full, ".."), { recursive: true });
+  writeFileSync(full, body);
 }
 
 describe("schemagen", () => {
-  test("discovers AppConfig and StatusJsonOutput in full-example", () => {
+  test("discovers @sg types in full-example", () => {
     const roots = discoverSchemaRoots(exampleRoot);
-    expect(roots.map((r) => `${r.kind}:${r.typeName}`).sort()).toEqual(["config:AppConfig", "output:StatusJsonOutput"]);
+    expect(roots.map((r) => r.typeName).sort()).toEqual(["RenderJsonInput", "StatusJsonOutput", "WorkspaceNameInput"]);
   });
 
-  test("maps schema kinds to __generated__ filenames and export names", () => {
-    expect(schemaJsonBasename("output")).toBe("outputSchema.json");
-    expect(schemaJsonBasename("config")).toBe("configSchema.json");
-    expect(schemaExportName("output")).toBe("outputSchema");
+  test("maps type names to __generated__ filenames and export names", () => {
+    expect(schemaJsonBasename("StatusJsonOutput")).toBe("StatusJsonOutputSchema.json");
+    expect(schemaExportName("RenderJsonInput")).toBe("RenderJsonInputSchema");
   });
 
   test("runSchemagen writes __generated__ artifacts in full-example", () => {
     const counts = runSchemagen({ projectRoot: exampleRoot });
-    expect(counts).toEqual({ configRoots: 1, inputRoots: 0, outputRoots: 1 });
+    expect(counts).toEqual({ schemas: 3 });
   });
 
-  test("discovers roots from types.ts with interface and role export", () => {
+  test("discovers @sg roots and writes named schema artifacts", () => {
     const root = makeTempProject();
     const dir = join(root, "src/commands/demo");
-    writeTypes(
+    writeSrcFile(
       root,
-      "commands/demo",
-      `export interface DemoOutput { ok: boolean; }
-
-/** Schemagen root for leaf outputSchema. */
-export type outputType = DemoOutput;
+      "src/commands/demo/types.ts",
+      `/** @sg */
+export interface DemoOutput {
+  ok: boolean;
+}
 `,
     );
 
     const roots = discoverSchemaRoots(root);
     expect(roots).toEqual([
       {
-        kind: "output",
         typeName: "DemoOutput",
         path: "src/commands/demo/types.ts",
         sourcePath: "src/commands/demo/types.ts",
       },
     ]);
     runSchemagen({ projectRoot: root });
-    expect(existsSync(join(dir, "__generated__/outputSchema.json"))).toBe(true);
+    expect(existsSync(join(dir, "__generated__/DemoOutputSchema.json"))).toBe(true);
+    expect(existsSync(join(dir, "__generated__/index.ts"))).toBe(true);
+  });
+
+  test("errors on blank line between @sg JSDoc and export", () => {
+    const root = makeTempProject();
+    writeSrcFile(
+      root,
+      "src/commands/demo/types.ts",
+      `/** @sg */
+
+export interface DemoOutput {
+  ok: boolean;
+}
+`,
+    );
+
+    expect(() => discoverSchemaRoots(root)).toThrow(
+      "src/commands/demo/types.ts: @sg JSDoc must be immediately followed by export interface/type",
+    );
+  });
+
+  test("two @sg types in same directory share one index.ts", () => {
+    const root = makeTempProject();
+    writeSrcFile(
+      root,
+      "src/commands/demo/types.ts",
+      `/** @sg */
+export interface DemoInput {
+  id: string;
+}
+`,
+    );
+    writeSrcFile(
+      root,
+      "src/commands/demo/command.ts",
+      `/** @sg */
+export interface DemoOutput {
+  ok: boolean;
+}
+`,
+    );
+
+    runSchemagen({ projectRoot: root });
+    const generatedDir = join(root, "src/commands/demo/__generated__");
+    const text = readFileSync(join(generatedDir, "index.ts"), "utf8");
+    expect(text).toContain("DemoInputSchema");
+    expect(text).toContain("DemoOutputSchema");
+    expect(existsSync(join(generatedDir, "DemoInputSchema.json"))).toBe(true);
+    expect(existsSync(join(generatedDir, "DemoOutputSchema.json"))).toBe(true);
   });
 
-  test("removes stale JSON files when a schema kind is dropped", () => {
+  test("skips *.test.ts and __generated__ during walk", () => {
     const root = makeTempProject();
-    writeTypes(
+    writeSrcFile(
       root,
-      "commands/demo",
-      `export interface DemoInput { id: string; }
-export interface DemoOutput { ok: boolean; }
-export type inputType = DemoInput;
-export type outputType = DemoOutput;
+      "src/commands/demo/types.test.ts",
+      `/** @sg */
+export interface ShouldNotDiscover {
+  x: string;
+}
+`,
+    );
+    writeSrcFile(
+      root,
+      "src/commands/demo/__generated__/orphan.ts",
+      `/** @sg */
+export interface AlsoSkipped {
+  x: string;
+}
+`,
+    );
+
+    expect(discoverSchemaRoots(root)).toEqual([]);
+  });
+
+  test("removes stale JSON files when a schema root is dropped", () => {
+    const root = makeTempProject();
+    writeSrcFile(
+      root,
+      "src/commands/demo/types.ts",
+      `/** @sg */
+export interface DemoInput {
+  id: string;
+}
+/** @sg */
+export interface DemoOutput {
+  ok: boolean;
+}
 `,
     );
 
     runSchemagen({ projectRoot: root });
     const generatedDir = join(root, "src/commands/demo/__generated__");
-    expect(existsSync(join(generatedDir, "inputSchema.json"))).toBe(true);
-    expect(existsSync(join(generatedDir, "outputSchema.json"))).toBe(true);
+    expect(existsSync(join(generatedDir, "DemoInputSchema.json"))).toBe(true);
+    expect(existsSync(join(generatedDir, "DemoOutputSchema.json"))).toBe(true);
 
-    writeTypes(
+    writeSrcFile(
       root,
-      "commands/demo",
-      `export interface DemoOutput { ok: boolean; }
-export type outputType = DemoOutput;
+      "src/commands/demo/types.ts",
+      `/** @sg */
+export interface DemoOutput {
+  ok: boolean;
+}
 `,
     );
 
     runSchemagen({ projectRoot: root });
-    expect(existsSync(join(generatedDir, "inputSchema.json"))).toBe(false);
-    expect(existsSync(join(generatedDir, "outputSchema.json"))).toBe(true);
+    expect(existsSync(join(generatedDir, "DemoInputSchema.json"))).toBe(false);
+    expect(existsSync(join(generatedDir, "DemoOutputSchema.json"))).toBe(true);
     expect(existsSync(join(generatedDir, "index.ts"))).toBe(true);
   });
 
-  test("removes orphan __generated__ when types.ts manifest is gone", () => {
+  test("removes orphan __generated__ when no roots remain in directory", () => {
     const root = makeTempProject();
     const generatedDir = join(root, "src/orphan/__generated__");
     mkdirSync(generatedDir, { recursive: true });
-    writeFileSync(join(generatedDir, "outputSchema.json"), "{}\n");
-    writeFileSync(join(generatedDir, "index.ts"), "export const outputSchema = {};\n");
+    writeFileSync(join(generatedDir, "DemoOutputSchema.json"), "{}\n");
+    writeFileSync(join(generatedDir, "index.ts"), "export const DemoOutputSchema = {};\n");
 
     runSchemagen({ projectRoot: root });
     expect(existsSync(generatedDir)).toBe(false);
   });
 
-  test("removes __generated__ when types.ts has no discoverable roots", () => {
+  test("errors on duplicate typeName across files", () => {
     const root = makeTempProject();
-    writeTypes(root, "commands/empty", `export type outputType = never;\n`);
-    const generatedDir = join(root, "src/commands/empty/__generated__");
-    mkdirSync(generatedDir, { recursive: true });
-    writeFileSync(join(generatedDir, "outputSchema.json"), "{}\n");
+    writeSrcFile(
+      root,
+      "src/a/types.ts",
+      `/** @sg */
+export interface DupType {
+  a: string;
+}
+`,
+    );
+    writeSrcFile(
+      root,
+      "src/b/types.ts",
+      `/** @sg */
+export interface DupType {
+  b: string;
+}
+`,
+    );
 
-    runSchemagen({ projectRoot: root });
-    expect(existsSync(generatedDir)).toBe(false);
+    expect(() => discoverSchemaRoots(root)).toThrow("duplicate schema root type DupType");
   });
 });

package/src/config/bindings.test.ts

@@ -3,7 +3,7 @@ Tests for config/bindings module.
 */
 
 import { describe, expect, test } from "bun:test";
-import type { CliAppConfigEntry } from "../types.ts";
+import type { CliAppConfigEntry } from "~/core/types.ts";
 import {
   bindingForKey,
   CONFIG_BINDINGS_KEY,

package/src/config/bindings.ts

@@ -2,7 +2,7 @@
 Per-key config binding metadata (`_bindings`) — records how each schema key is satisfied.
 */
 
-import type { CliAppConfigEntry } from "../types.ts";
+import type { CliAppConfigEntry } from "~/core/types.ts";
 
 /** Reserved top-level config file key for per-entry binding metadata. */
 export const CONFIG_BINDINGS_KEY = "_bindings";

package/src/config/bootstrap.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import type { CliAppConfigEntry } from "../types.ts";
+import type { CliAppConfigEntry } from "~/core/types.ts";
 import { shouldWizardPromptConfigKey } from "./bootstrap.ts";
 
 const requiredEntry: CliAppConfigEntry = {

package/src/config/bootstrap.ts

@@ -4,8 +4,9 @@ settings are present before the CLI or MCP server handles a request.
 */
 
 import { readSync } from "node:fs";
-import { readPromptLine as readStdinLine } from "../prompt.ts";
-import type { CliAppConfigEntry, CliProgram } from "../types.ts";
+import type { CliAppConfigEntry, CliProgram, ServerRuntime } from "~/core/types.ts";
+import type { LogEmitter } from "~/log/emitter.ts";
+import { readPromptLine as readStdinLine } from "~/prompt.ts";
 import { bindingForKey, clearFileValue, isKeyAddressed, readBindings, setBinding } from "./bindings.ts";
 import { configEntryRequired, configEntrySensitive, defaultConfigEntryTitle, jsonSchemaRequiredKeys } from "./entry.ts";
 import {
@@ -48,9 +49,40 @@ export interface ConfigBootstrapResult {
   resolved: ResolvedConfig;
 }
 
+/** Options for {@link bootstrapAppConfig}. */
+export interface BootstrapAppConfigOpts {
+  /** `true` = strict validate; `false` = raw read; `"soft"` = validate, log, store error in runtime.state. */
+  validateFile: boolean | "soft";
+  runtime?: ServerRuntime;
+  emitter?: LogEmitter;
+}
+
 /** Read the config file, merge env overrides, and export mapped values into `process.env`. */
-export function bootstrapAppConfig(program: CliProgram, opts: { validateFile: boolean }): ConfigBootstrapResult {
-  const fileData = opts.validateFile ? readAppConfigFile(program) : readAppConfigFileRaw(resolveAppConfigPath(program));
+export function bootstrapAppConfig(program: CliProgram, opts: BootstrapAppConfigOpts): ConfigBootstrapResult {
+  let fileData: Record<string, unknown>;
+  if (opts.validateFile === true) {
+    fileData = readAppConfigFile(program);
+  } else if (opts.validateFile === "soft") {
+    try {
+      fileData = readAppConfigFile(program);
+      if (opts.runtime) {
+        delete opts.runtime.state.configFileError;
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      fileData = readAppConfigFileRaw(resolveAppConfigPath(program));
+      if (opts.runtime) {
+        opts.runtime.state.configFileError = message;
+      }
+      opts.emitter?.emit({
+        level: "warn",
+        message,
+        action: "config.invalid",
+      });
+    }
+  } else {
+    fileData = readAppConfigFileRaw(resolveAppConfigPath(program));
+  }
   const hostEnv = captureMappedHostEnv(program);
   const resolved = resolveAppConfig(program, fileData, hostEnv);
   exportConfigToEnv(program, resolved, hostEnv);

package/src/config/context.test.ts

@@ -6,7 +6,7 @@ import { describe, expect, test } from "bun:test";
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
-import type { CliProgram } from "../types.ts";
+import type { CliProgram } from "~/core/types.ts";
 import { createAppConfigSnapshot } from "./context.ts";
 import { resolveAppConfigDir, resolveAppConfigPath } from "./file.ts";
 import { resolveAppConfig } from "./resolve.ts";

package/src/config/context.ts

@@ -2,7 +2,7 @@
 Handler-facing resolved app config snapshot (ctx.appConfig).
 */
 
-import type { CliProgram } from "../types.ts";
+import type { CliProgram } from "~/core/types.ts";
 import { isFrameworkConfigKey, setBinding } from "./bindings.ts";
 import {
   readAppConfigFileRaw,

package/src/config/entry.ts

@@ -2,7 +2,7 @@
 Shared helpers for program.appConfig schema entries.
 */
 
-import type { CliAppConfigEntry, CliProgram } from "../types.ts";
+import type { CliAppConfigEntry, CliProgram } from "~/core/types.ts";
 
 /** Default title when `CliAppConfigEntry.title` is omitted. */
 export function defaultConfigEntryTitle(key: string): string {

package/src/config/file.test.ts

@@ -6,7 +6,7 @@ import { describe, expect, test } from "bun:test";
 import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
-import type { CliProgram } from "../types.ts";
+import type { CliProgram } from "~/core/types.ts";
 import { CONFIG_BINDINGS_KEY } from "./bindings.ts";
 import { bootstrapAppConfig } from "./bootstrap.ts";
 import {

package/src/config/file.ts

@@ -4,9 +4,9 @@ JSON app config file path helpers and strict read/write.
 
 import { existsSync, mkdirSync, readFileSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { sanitizeToolSegment } from "../mcp/tools.ts";
-import { appConfigLibHome, displayHomePath } from "../paths/host.ts";
-import type { CliProgram } from "../types.ts";
+import type { CliProgram } from "~/core/types.ts";
+import { sanitizeToolSegment } from "~/mcp/tools.ts";
+import { appConfigLibHome, displayHomePath } from "~/paths/host.ts";
 import { isFrameworkConfigKey, validateBindingsShape } from "./bindings.ts";
 import { effectiveJsonSchema } from "./schema.ts";
 import { validateConfigDocument, validateConfigDocumentPartial } from "./validate.ts";

package/src/config/manifest.ts

@@ -2,7 +2,7 @@
 MCP bundle / plugin manifest builders for program.appConfig env-mapped entries.
 */
 
-import type { CliAppConfigEntry, CliProgram } from "../types.ts";
+import type { CliAppConfigEntry, CliProgram } from "~/core/types.ts";
 import {
   configEntryRequired,
   configEntrySensitive,

package/src/config/resolve.test.ts

@@ -3,7 +3,7 @@ Tests for config/resolve module behavior.
 */
 
 import { describe, expect, test } from "bun:test";
-import type { CliProgram } from "../types.ts";
+import type { CliProgram } from "~/core/types.ts";
 import { captureMappedHostEnv, exportConfigToEnv, resolveAppConfig } from "./resolve.ts";
 
 const program: CliProgram = {

package/src/config/resolve.ts

@@ -2,7 +2,7 @@
 Resolve program.appConfig values: defaults, file, env override, export to process.env.
 */
 
-import type { CliAppConfigEntry, CliAppConfigResolveContext, CliProgram } from "../types.ts";
+import type { CliAppConfigEntry, CliAppConfigResolveContext, CliProgram } from "~/core/types.ts";
 import { configEntryRequired, jsonSchemaRequiredKeys } from "./entry.ts";
 import type { AppConfigFileData } from "./file.ts";
 import { displayAppConfigPath } from "./file.ts";

package/src/config/schema.ts

@@ -2,7 +2,7 @@
 Effective JSON Schema for program.appConfig (block schema or all-string synthesis).
 */
 
-import type { CliAppConfigEntry, CliProgram } from "../types.ts";
+import type { CliAppConfigEntry, CliProgram } from "~/core/types.ts";
 import { configEntryRequired, jsonSchemaRequiredKeys } from "./entry.ts";
 
 /** Synthesize a draft-07 object schema with string properties from metadata entries. */

package/src/config/validate.ts

@@ -3,7 +3,7 @@ Draft-07 JSON Schema subset validator for program.appConfig files.
 Aligned with common ts-json-schema-generator output (local $ref, objects, scalars).
 */
 
-import { parseCommaList, parseDate, parseDateTime } from "../formats.ts";
+import { parseCommaList, parseDate, parseDateTime } from "~/core/formats.ts";
 import { isFrameworkConfigKey } from "./bindings.ts";
 
 type JsonSchema = Record<string, unknown>;

package/src/{install → configure/artifacts}/binary-placement.test.ts

@@ -6,7 +6,7 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { chmodSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import type { CliProgram } from "../types.ts";
+import type { CliProgram } from "~/core/types.ts";
 import { isAppInstalled, isExternallyManagedBinary, resolvePathCommand } from "./binary-placement.ts";
 
 const program: CliProgram = {

package/src/{install → configure/artifacts}/binary-placement.ts

@@ -1,6 +1,6 @@
 import { accessSync, constants, realpathSync } from "node:fs";
 import { delimiter, join } from "node:path";
-import type { CliProgram } from "../types.ts";
+import type { CliProgram } from "~/core/types.ts";
 
 /** Resolves a command name on PATH to its real path, if present. */
 export function resolvePathCommand(key: string): string | undefined {

package/src/{install → configure/artifacts}/gh-release-update.ts

@@ -1,7 +1,7 @@
 import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
-import type { CliUpdateGetLatest } from "../types.ts";
+import type { CliUpdateGetLatest } from "~/core/types.ts";
 
 /** Config for {@link ghReleaseUpdateGetLatest}. */
 export interface GhReleaseUpdateConfig {

package/src/{install → configure/artifacts}/install-validate.test.ts

@@ -3,9 +3,9 @@ Tests for install/install-validate module behavior.
 */
 
 import { describe, expect, test } from "bun:test";
-import type { CliProgram } from "../types.ts";
-import { CliSchemaValidationError } from "../types.ts";
-import { cliValidateProgram } from "../validate.ts";
+import type { CliProgram } from "~/core/types.ts";
+import { CliSchemaValidationError } from "~/core/types.ts";
+import { cliValidateProgram } from "~/core/validate.ts";
 
 const base: CliProgram = {
   key: "app",

package/src/{install → configure/artifacts}/mcp-config.ts

@@ -1,6 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
-import type { CliProgram } from "../types.ts";
+import type { CliProgram } from "~/core/types.ts";
 
 export interface McpServerEntry {
   command: string;

package/src/{install → configure/artifacts}/mcp-opencode.test.ts

@@ -6,7 +6,7 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import type { CliProgram } from "../types.ts";
+import type { CliProgram } from "~/core/types.ts";
 import {
   detectOpenCodeMcpConfigPath,
   expectedOpenCodeMcpEntry,

package/src/{install → configure/artifacts}/mcp-opencode.ts

@@ -1,6 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
-import type { CliProgram } from "../types.ts";
+import type { CliProgram } from "~/core/types.ts";
 import { expectedMcpEntry } from "./mcp-config.ts";
 
 export const OPENCODE_CONFIG_SCHEMA = "https://opencode.ai/config.json";

package/src/{install → configure/artifacts}/paths.ts

@@ -1,9 +1,9 @@
 import { existsSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { mcpServerId, sanitizeToolSegment } from "../mcp/tools.ts";
-import { displayHomePath, userHome, xdgConfigHome } from "../paths/host.ts";
-import { skillDirNameForTarget } from "../skill/install.ts";
-import type { CliProgram } from "../types.ts";
+import type { CliProgram } from "~/core/types.ts";
+import { mcpServerId, sanitizeToolSegment } from "~/mcp/tools.ts";
+import { displayHomePath, userHome, xdgConfigHome } from "~/paths/host.ts";
+import { skillDirNameForTarget } from "~/skill/install.ts";
 import { resolveOpenclawConfigPath } from "./mcp-openclaw.ts";
 import { resolveOpenCodeConfigPathForInstall } from "./mcp-opencode.ts";
 
@@ -24,7 +24,7 @@ export interface InstallPaths {
   skillDirName: string;
 }
 
-export { userHome } from "../paths/host.ts";
+export { userHome } from "~/paths/host.ts";
 
 /** Format an absolute path for user-facing install output. */
 export function displayInstallPath(path: string): string {

package/src/configure/artifacts/plan.ts

@@ -0,0 +1,24 @@
+import type { CliProgram } from "~/core/types.ts";
+import type { InstallPaths } from "./paths.ts";
+import { buildInstallPlanFromTargets } from "./target-plan-build.ts";
+import type { InstallAction, InstallOpts } from "./target-types.ts";
+
+export type { InstallAction, InstallActionKind, InstallOpts } from "./target-types.ts";
+
+/** Builds install actions for normal mode (--all / scoped targets). */
+export function buildInstallPlan(root: CliProgram, paths: InstallPaths, opts: InstallOpts): InstallAction[] {
+  return buildInstallPlanFromTargets(root, paths, opts);
+}
+
+/** Builds update/reinstall actions; greenfield fallback when nothing detected. */
+export function buildUpdatePlan(root: CliProgram, paths: InstallPaths, opts: InstallOpts): InstallAction[] {
+  const refresh = buildInstallPlanFromTargets(root, paths, {
+    ...opts,
+    reinstall: true,
+    all: true,
+  });
+  if (refresh.length > 0) {
+    return refresh;
+  }
+  return buildInstallPlanFromTargets(root, paths, { ...opts, reinstall: false, all: true });
+}

package/src/{install → configure/artifacts}/status.test.ts

@@ -6,7 +6,7 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import type { CliProgram } from "../types.ts";
+import type { CliProgram } from "~/core/types.ts";
 import { resolveInstallPaths } from "./paths.ts";
 import { printInstallStatus } from "./status.ts";
 import { resolveInstallTargetPreview } from "./target-scope.ts";

package/src/{install → configure/artifacts}/status.ts

@@ -1,5 +1,5 @@
-import { appConfigStatus } from "../config/bootstrap.ts";
-import type { CliProgram } from "../types.ts";
+import { appConfigStatus } from "~/config/bootstrap.ts";
+import type { CliProgram } from "~/core/types.ts";
 import { buildInstallStatus, detectInstalledArtifacts } from "./detect-installed.ts";
 import { resolveInstallPaths } from "./paths.ts";
 import { resolveInstallTargetPreview } from "./target-scope.ts";

package/src/{install → configure/artifacts}/target-base.ts

@@ -1,4 +1,4 @@
-import type { CliProgram, InstallAgentIntegration } from "../types.ts";
+import type { CliProgram, InstallAgentIntegration } from "~/core/types.ts";
 import type { InstallPaths } from "./paths.ts";
 import type {
   CliInstallArtifactKey,

package/src/{install → configure/artifacts}/target-detect.ts

@@ -1,4 +1,4 @@
-import type { CliProgram } from "../types.ts";
+import type { CliProgram } from "~/core/types.ts";
 import type { InstallPaths } from "./paths.ts";
 import { INSTALL_TARGETS } from "./target-registry.ts";
 import type { InstalledArtifacts, InstallStatus } from "./target-types.ts";

package/src/{install → configure/artifacts}/target-effective.ts

@@ -1,12 +1,11 @@
-import { resolveCapabilities } from "../capabilities.ts";
 import type {
   CliConfigureConfig,
   CliConfigureTargets,
   CliProgram,
   InstallAgentIntegration,
   InstallTargetSpec,
-} from "../types.ts";
-import type { InstallPaths } from "./paths.ts";
+} from "~/core/types.ts";
+import { resolveCapabilities } from "~/runtime/capabilities.ts";
 import {
   AGENT_PAIRS,
   INSTALL_ARTIFACT_KEYS,
@@ -15,7 +14,7 @@ import {
 } from "./target-registry.ts";
 import type { CliInstallArtifactKey, InstallPlanMode } from "./target-types.ts";
 
-export type { InstallTargetSpec, ResolvedInstallTarget } from "../types.ts";
+export type { InstallTargetSpec, ResolvedInstallTarget } from "~/core/types.ts";
 
 export type { InstallPlanMode, InstallScope } from "./target-types.ts";
 
@@ -124,8 +123,3 @@ export function resolveInstallPlanMode(opts: {
   if (opts.all) return "install-all";
   return "install-scoped";
 }
-
-/** @deprecated Use target registry. */
-export function isInstallTargetAvailable(key: CliInstallArtifactKey, root: CliProgram, paths: InstallPaths): boolean {
-  return installTargetForKey(key)?.isAvailable(root, paths) ?? false;
-}

package/src/{install → configure/artifacts}/target-mcp-cli.ts

@@ -1,4 +1,4 @@
-import type { CliProgram } from "../types.ts";
+import type { CliProgram } from "~/core/types.ts";
 import { checkCodexMcpConflict, codexMcpHasServer, mergeCodexMcpConfig, removeCodexMcpConfig } from "./mcp-codex.ts";
 import { expectedMcpEntry } from "./mcp-config.ts";
 import {

package/src/{install → configure/artifacts}/target-mcp-json.ts

@@ -1,4 +1,4 @@
-import type { CliProgram } from "../types.ts";
+import type { CliProgram } from "~/core/types.ts";
 import {
   checkMcpConflict,
   expectedMcpEntry,