dsh-ptc-plus 0.4.2 → 0.4.8

package/internal/callable-source-facts.js

@@ -43,6 +43,16 @@ function callableSourceStart(source, node) {
   return start + tokens.getToken().start
 }
 
+function removeCallableSourceMarks(source, prefix, suffix, sources, options) {
+  const tree = parse(prefix + source + suffix, options)
+  const markers = new Set(sources.entries.map(entry => entry.marker))
+  const offset = prefix.length
+  const edits = tree.comments.filter(comment => markers.has(comment.value)
+    && comment.start >= offset && comment.end <= offset + source.length)
+    .map(comment => ({ start: comment.start - offset, end: comment.end - offset, text: '' }))
+  return edits.length === 0 ? source : applySourceEdits(source, identitySourceMap(source.length), edits).code
+}
+
 export function callableMarkerPosition(node, source, comments) {
   if (node.type !== 'ArrowFunctionExpression') return node.body.start + 1
   let start = source.lastIndexOf('=>', node.body.start - 1)
@@ -129,6 +139,7 @@ export function markCallableSources(source, sourceMap = identitySourceMap(source
   const nativeFunctions = typedRecords.map(record => markedNodes.get(record.marker))
     .filter(node => t.isFunction(node) && !isMethod(node)).sort((left, right) => left.start - right.start)
   const nativeRecipes = new Map()
+  const aliasMarkers = []
   const nativeFunctionIndex = start => {
     let low = 0, high = nativeFunctions.length
     while (low < high) {
@@ -175,7 +186,17 @@ export function markCallableSources(source, sourceMap = identitySourceMap(source
       original = lowered.source
       const entries = [...originals].map(([key, text]) => [key, key === marker ? original : text])
       for (const [node, fact] of markedCallableOwners(lowered.emitted, entries)) {
-        sources.aliases.push([lowered.emittedSource.slice(node.start, node.end), fact.original])
+        const generated = lowered.emittedSource.slice(node.start, node.end)
+        aliasMarkers.push([generated, fact.marker])
+        const generatedMethod = isMethod(node)
+        const markerFree = removeCallableSourceMarks(
+          generated,
+          generatedMethod ? 'class Source {' : '(',
+          generatedMethod ? '}' : ')',
+          sources,
+          options,
+        )
+        if (markerFree !== generated) aliasMarkers.push([markerFree, fact.marker])
       }
     }
     // Prefer source-preserving erasure. Runtime TypeScript constructs such as
@@ -202,6 +223,7 @@ export function markCallableSources(source, sourceMap = identitySourceMap(source
     } catch {
       lowerCallable()
     }
+    original = removeCallableSourceMarks(original, prefix, suffix, sources, options)
     entry.buffer = sources.buffers.length
     sources.buffers.push(original)
     entry.start = 0
@@ -209,6 +231,8 @@ export function markCallableSources(source, sourceMap = identitySourceMap(source
     originals.set(marker, original)
     if (!method && t.isFunction(node)) nativeRecipes.set(node, { node, start, end: node.end, text: original })
   }
+  const finalFacts = factMap(sources)
+  for (const [generated, marker] of aliasMarkers) sources.aliases.push([generated, originalText(finalFacts.get(marker))])
   return { ...marked, callableSources: sources, nativeJavaScript }
 }
 
@@ -273,6 +297,18 @@ export function collectCallableSources(code, sources, parserOptions = {}, transf
   }).concat(sources.aliases ?? [])
 }
 
+/** Restore only callable marks whose transformed starts have exact source-map ownership. */
+export function restoreMappedCallableSourceMarks(mapped, input, transformation, sources, parserOptions = {}) {
+  if (sources === undefined || sources.length === 0) return mapped
+  const { tree, owners } = callableSourceOwners(mapped.code, sources, parserOptions,
+    { code: input, map: transformation.map })
+  const edits = [...owners].map(([node, fact]) => {
+    const start = callableMarkerPosition(node, mapped.code, tree.comments)
+    return { start, end: start, text: `/*${fact.marker}*/` }
+  })
+  return edits.length === 0 ? mapped : applySourceEdits(mapped.code, mapped.sourceMap, edits)
+}
+
 /** Emission ranges come from typed nodes and exact generator mappings. */
 export function regionCallableRanges(input, generated, sourceRanges, parserOptions) {
   if (!sourceRanges?.length) return []

package/internal/cell-analysis.js

@@ -20,7 +20,7 @@ import {
 import { applySourceEdits, mapSourcePosition, mapSourceSpan, sourceRangeHasOriginalText } from './source-position-map.js'
 import { SKIP_AST_CHILDREN, walkAst } from './ast-traversal.js'
 import { compileStatefulRoot } from './stateful-root-compiler.js'
-import { CELL_PARSER_PLUGINS, bindCompilerIntrinsics, lowerStatefulDecorators, lowerStatefulResources, lowerNativeLanguageSource, normalizeStatefulScopes } from './repl-scope-normalizer.js'
+import { CELL_PARSER_PLUGINS, bindCompilerIntrinsics, lowerStatefulDecorators, lowerStatefulResources, lowerNativeLanguageSource, normalizationFailureInput, normalizeStatefulScopes } from './repl-scope-normalizer.js'
 import { markCallableSources, collectCallableSources } from './callable-source-facts.js'
 import { LegacyPreflightError, prepareLegacyProgram } from './legacy-cell-analysis.js'
 import { adaptLegacyModuleImports } from './managed-module-operations.js'
@@ -220,6 +220,49 @@ function isFunction(node) {
     || node.type === 'ArrowFunctionExpression'
 }
 
+function lowerCellImportMeta(result, importMeta, originalSource) {
+  if (!result.code.includes('import')) return result
+  const tree = parseSource(result.code, {
+    sourceType: 'unambiguous',
+    errorRecovery: true,
+    allowAwaitOutsideFunction: true,
+    allowImportExportEverywhere: true,
+    allowReturnOutsideFunction: true,
+    allowUndeclaredExports: true,
+    plugins: CELL_PARSER_PLUGINS,
+  }).program
+  const references = []
+  walkAst(tree, (node) => {
+    if (node.type === 'MetaProperty' && node.meta?.name === 'import' && node.property?.name === 'meta') {
+      references.push(node)
+    }
+  })
+  if (references.length === 0) return result
+  if (importMeta === null || typeof importMeta !== 'object'
+    || typeof importMeta.url !== 'string' || typeof importMeta.filename !== 'string'
+    || typeof importMeta.dirname !== 'string') {
+    const node = references[0]
+    throw new ModuleRewriteError('import.meta requires the session module base', mapSourcePosition({
+      line: node.loc.start.line,
+      column: node.loc.start.column + 1,
+    }, result.code, originalSource, result.sourceMap))
+  }
+  const binding = createGeneratedNameAllocator(tree)('import_meta')
+  const directiveEnd = tree.directives.at(-1)?.end ?? tree.interpreter?.end ?? 0
+  const declaration = `\nconst ${binding}={__proto__:null,url:${JSON.stringify(importMeta.url)},filename:${JSON.stringify(importMeta.filename)},dirname:${JSON.stringify(importMeta.dirname)}};\n`
+  const edits = [
+    { start: directiveEnd, end: directiveEnd, text: declaration },
+    ...references.map(node => ({
+      start: node.start,
+      end: node.end,
+      text: binding,
+      mappings: [{ generatedStart: 0, generatedEnd: binding.length,
+        originalStart: node.start, originalEnd: node.end }],
+    })),
+  ]
+  return { ...result, ...applySourceEdits(result.code, result.sourceMap, edits), importMetaBinding: binding }
+}
+
 
 function staticModuleClassification(moduleLoads) {
   const reasons = new Map()
@@ -282,14 +325,16 @@ export function classifyDurability(code, knownBindings = new Set(), {
   const reasons = new Map()
   const addReason = reason => reasons.set(renderDurabilityReason(reason), reason)
   for (const reason of staticModuleClassification(moduleLoads)) addReason(reason)
-  const classifyModule = (source) => {
+  const classifyModule = (source, form) => {
     if (source?.type !== 'Literal' || typeof source.value !== 'string') {
       addReason(DYNAMIC_MODULE_REASON)
       return
     }
     const classification = classifyModuleSource(source.value)
     if (classification.status === 'forbidden') {
-      throw new PreflightError(`cell import of ${source.value} is forbidden because it exposes kernel control`, source)
+      const span = sourceMap === undefined || originalSource === undefined ? declarationSpan(source)
+        : mapSourceSpan(declarationSpan(source), code, originalSource, sourceMap)
+      throw new PreflightError(`cell ${form} of ${source.value} is forbidden because it exposes kernel control`, undefined, span)
     }
     if (classification.reason !== undefined) addReason(classification.reason)
   }
@@ -327,7 +372,7 @@ export function classifyDurability(code, knownBindings = new Set(), {
       nestedScopes = [...scopes, loopBindings(node)]
     }
     if (node.type === 'ImportExpression') {
-      classifyModule(node.source)
+      classifyModule(node.source, 'import')
     }
     const sourceOwnedThis = sourceMap === undefined
       || sourceRangeHasOriginalText(sourceMap, code, originalSource, node.start, node.end)
@@ -336,7 +381,7 @@ export function classifyDurability(code, knownBindings = new Set(), {
     }
     if (node.type === 'CallExpression' && node.callee?.type === 'Identifier' && node.callee.name === 'require'
       && !isBound('require', nestedScopes)) {
-      classifyModule(node.arguments[0])
+      classifyModule(node.arguments[0], 'require')
     }
     if (node.type === 'Identifier' && isReferenceIdentifier(node, parent, parentKey)
       && !isBound(node.name, nestedScopes) && AMBIENT_GLOBALS.has(node.name)
@@ -462,21 +507,31 @@ export function prepareProgram(program, options = {}) {
     let normalized
     let prepared
     let callableSources
+    let diagnosticInput
     const intrinsicContext = { bindings: new Set() }
     try {
       const marked = markCallableSources(program, undefined, { plugins: CELL_PARSER_PLUGINS, allowImportExportEverywhere: true, allowUndeclaredExports: true },
         { lowerNativeSource: lowerNativeLanguageSource, nativeUsing: options.nativeUsing })
+      const moduleMetadata = lowerCellImportMeta(marked, options.importMeta, program)
+      diagnosticInput = moduleMetadata
       callableSources = marked.callableSources
-      normalized = normalizeStatefulScopes(marked.code, marked.sourceMap, { mode: options.languageSemantics,
-        nativeJavaScript: marked.nativeJavaScript, deferDecorators: true, deferResources: true, intrinsicContext })
+      normalized = normalizeStatefulScopes(moduleMetadata.code, moduleMetadata.sourceMap, { mode: options.languageSemantics,
+        callableSources, nativeJavaScript: marked.nativeJavaScript,
+        deferDecorators: true, deferResources: true, intrinsicContext })
+      if (moduleMetadata.importMetaBinding !== undefined) {
+        normalized.internalBindings = new Set(normalized.internalBindings)
+        normalized.internalBindings.add(moduleMetadata.importMetaBinding)
+      }
+      diagnosticInput = normalized
       prepared = compileStatefulRoot(normalized.code, { ...options, sourceMap: normalized.sourceMap,
         internalBindings: normalized.internalBindings, dynamicBindings: normalized.dynamicBindings,
         privateBindings: normalized.privateBindings, originalSource: program })
     } catch (error) {
       if (error instanceof ModuleRewriteError) throw error
       const position = error.loc === undefined ? undefined : { line: error.loc.line, column: error.loc.column + 1 }
-      throw new ModuleRewriteError(error.message, normalized === undefined ? position
-        : mapSourcePosition(position, normalized.code, program, normalized.sourceMap))
+      const failureInput = normalizationFailureInput(error) ?? diagnosticInput
+      throw new ModuleRewriteError(error.message, failureInput === undefined ? position
+        : mapSourcePosition(position, failureInput.code, program, failureInput.sourceMap))
     }
     prepared = { ...prepared, deferredHelpers: normalized.deferredHelpers }
     intrinsicContext.expression = `this[${JSON.stringify(prepared.rootRuntimeName)}].intrinsics`

package/internal/config-spec.js

@@ -96,7 +96,7 @@ export const CONFIG_FIELDS = Object.freeze([
   {
     key: 'userBindingsEnabled',
     type: 'boolean',
-    default: false,
+    default: true,
     label: '启用全局用户 Binding',
     labelEn: 'Enable Global User Bindings',
     description: '管理 TypeScript helper，并将已启用条目作为跨会话的默认 REPL 绑定。',

package/internal/cordis-tools-owner.js

@@ -1,5 +1,7 @@
 import * as CordisTools from '@deepseek-ai/dsh-tool-cordis'
 import * as CordisSkillFilesystem from '@deepseek-ai/dsh-skill-filesystem'
+import { existsSync } from 'node:fs'
+import { createRequire } from 'node:module'
 import { dirname, isAbsolute, join } from 'node:path'
 import { isDeepStrictEqual } from 'node:util'
 import { RUN_CODE } from './runtime-bridge-owner.js'
@@ -8,6 +10,16 @@ const CORDIS_PRESET_ID = 'cordis'
 const CORDIS_SKILL_NAME = 'cordis-plugin-development'
 const CORDIS_SKILL_PROVIDER = 'ptc-plus-cordis'
 const COMPANION_SKILL_TOOL = 'skill'
+const COMPANION_PACKAGE_LAYOUTS = Object.freeze([
+  Object.freeze({
+    name: '@deepseek-ai/dsh-agent-preset',
+    skillRoot: directory => join(directory, 'skills'),
+  }),
+  Object.freeze({
+    name: '@deepseek-ai/dsh-agent-presets',
+    skillRoot: directory => join(directory, 'presets', CORDIS_PRESET_ID, 'skills'),
+  }),
+])
 
 function exactCompanionCandidates(observation) {
   if (Array.isArray(observation)) {
@@ -131,15 +143,51 @@ function requireCompanionServices(agent) {
   return { agentPresets, skills }
 }
 
-async function companionSkillDirectory(agentPresets) {
+function containsCompanionSkill(directory, fileExists) {
+  return fileExists(join(directory, CORDIS_SKILL_NAME, 'SKILL.md'))
+}
+
+/** Resolve the official Cordis companion Skill across DSH preset generations. */
+export async function resolveCompanionSkillDirectory(agentPresets, options = {}) {
+  const fileExists = options.fileExists ?? existsSync
   const preset = await agentPresets.resolve(CORDIS_PRESET_ID)
-  if (typeof preset?.path !== 'string' || !isAbsolute(preset.path)) {
-    throw new Error('ptc-plus: DSH cordis preset did not expose an absolute composition path')
-  }
-  if (typeof preset.broken === 'string' && preset.broken.length > 0) {
+  if (typeof preset?.broken === 'string' && preset.broken.length > 0) {
     throw new Error(`ptc-plus: DSH cordis preset is unavailable: ${preset.broken}`)
   }
-  return join(dirname(preset.path), 'skills')
+  if (preset?.path !== undefined) {
+    if (typeof preset.path !== 'string' || !isAbsolute(preset.path)) {
+      throw new Error('ptc-plus: DSH cordis preset did not expose an absolute composition path')
+    }
+    const directory = join(dirname(preset.path), 'skills')
+    if (!containsCompanionSkill(directory, fileExists)) {
+      throw new Error(`ptc-plus: DSH cordis preset does not contain ${CORDIS_SKILL_NAME}/SKILL.md beside its composition`)
+    }
+    return directory
+  }
+
+  for (const layout of COMPANION_PACKAGE_LAYOUTS) {
+    const pkg = options.packageOf?.(layout.name, options.packageBaseUrl)
+    if (pkg === undefined) continue
+    if (pkg?.name !== layout.name || typeof pkg.dir !== 'string' || !isAbsolute(pkg.dir)) {
+      throw new Error(`ptc-plus: DSH pluginPackages returned an invalid ${layout.name} package resource`)
+    }
+    const directory = layout.skillRoot(pkg.dir)
+    if (containsCompanionSkill(directory, fileExists)) return directory
+  }
+
+  if (options.packageOf === undefined && options.resolveLegacyPackageManifest !== undefined) {
+    let manifest
+    try {
+      manifest = options.resolveLegacyPackageManifest('@deepseek-ai/dsh-agent-presets/package.json')
+    } catch (error) {
+      if (error?.code !== 'MODULE_NOT_FOUND' && error?.code !== 'ERR_PACKAGE_PATH_NOT_EXPORTED') throw error
+    }
+    if (manifest !== undefined) {
+      const directory = join(dirname(manifest), 'presets', CORDIS_PRESET_ID, 'skills')
+      if (containsCompanionSkill(directory, fileExists)) return directory
+    }
+  }
+  throw new Error(`ptc-plus: the active DSH installation does not publish a loadable ${CORDIS_SKILL_NAME} companion Skill through its package-resolution surface`)
 }
 
 async function requireCompanionSkill(agent, skills) {
@@ -260,6 +308,7 @@ export function createCordisToolsOwner(
   ctx,
   cordisPlugin = CordisTools,
   skillFilesystemPlugin = CordisSkillFilesystem,
+  companionResolution = undefined,
 ) {
   if (typeof ctx?.agents?.list !== 'function') {
     throw new Error('ptc-plus: cordisToolsEnabled requires the DSH agents.list API')
@@ -271,6 +320,22 @@ export function createCordisToolsOwner(
   const cordisInspectLeases = createCordisInspectLeases(ctx)
   const scopedCordisPlugin = cordisInspectLeases.plugin(cordisPlugin)
   const scopedSkillPlugin = exactCompanionSkillPlugin(skillFilesystemPlugin)
+  const pluginPackages = ctx.get?.('pluginPackages')
+  const packageBaseUrl = ctx.baseUrl
+  const skillResolution = companionResolution ?? {
+    packageOf: pluginPackages === undefined
+      ? undefined
+      : (name, parentURL) => {
+          if (typeof pluginPackages?.packageOf !== 'function') {
+            throw new Error('ptc-plus: cordisToolsEnabled requires the DSH pluginPackages.packageOf API')
+          }
+          return pluginPackages.packageOf(name, parentURL)
+        },
+    packageBaseUrl,
+    resolveLegacyPackageManifest: pluginPackages === undefined && typeof packageBaseUrl === 'string'
+      ? specifier => createRequire(packageBaseUrl).resolve(specifier)
+      : undefined,
+  }
   let disposed = false
 
   const leafErrors = error => error instanceof AggregateError
@@ -329,6 +394,7 @@ export function createCordisToolsOwner(
 
   const installAgent = (agent) => {
     if (disposed) return Promise.resolve()
+    if (withdrawn.has(agent)) return Promise.resolve()
     const mounted = mounts.get(agent)
     if (mounted !== undefined) {
       return mounted.withdrawn === true ? Promise.resolve() : mounted.activation
@@ -353,13 +419,14 @@ export function createCordisToolsOwner(
     mounts.set(agent, mount)
     mount.activation = Promise.resolve().then(async () => {
       const { agentPresets, skills } = requireCompanionServices(agent)
-      const skillDirectory = await companionSkillDirectory(agentPresets)
+      const skillDirectory = await resolveCompanionSkillDirectory(agentPresets, skillResolution)
       if (mount.disposed) return
 
       const skillFiber = agent.ctx.plugin(scopedSkillPlugin, {
         providerName: CORDIS_SKILL_PROVIDER,
         includeDefaultRoots: false,
-        customSkillDirs: [skillDirectory],
+        bundledSkillDir: skillDirectory,
+        watch: false,
       })
       if (typeof skillFiber?.dispose !== 'function') {
         throw new Error('ptc-plus: DSH Context.plugin did not return a disposable Cordis Skill fiber')
@@ -416,11 +483,11 @@ export function createCordisToolsOwner(
   /**
    * Install for a call the host makes on its own behalf.
    *
-   * DSH 0.1.6 announces `agent/created` serially and rejects `agents.create()`
-   * when a listener rejects, so a scope this owner cannot serve must withdraw
-   * instead of failing an operation another plugin asked for. Install-time
-   * enumeration stays strict: there the plugin speaks for what it claims to
-   * have published, and `ready` reports the same failure.
+   * The public host lifecycle announces `agent/created` serially and rejects
+   * `agents.create()` when a listener rejects, so a scope this owner cannot
+   * serve must withdraw instead of failing an operation another plugin asked
+   * for. Install-time enumeration stays strict: there the plugin speaks for
+   * what it claims to have published, and `ready` reports the same failure.
    */
   const installForHost = (agent) => {
     let activation
@@ -451,8 +518,7 @@ export function createCordisToolsOwner(
       if (disposed) return
       for (const agent of [...pending]) {
         void Promise.resolve().then(() => installAgent(agent)).catch(error => {
-          pending.delete(agent)
-          ctx.logger?.warn?.('ptc-plus: deferred Cordis activation failed', error)
+          withdraw(agent, error)
         })
       }
     })