is there a remote chance to use Gradle Version Catalog with

@file:DependsOn("...")

? 🙈 scripting would have to know where to look for the TOML file, and it's non-trivial to infer. It could traverse starting from the script's location, up the file tree, until it finds

gradle/libs.versions.toml

I need help untangling what's wrong with fix(deps): update ktor monorepo to v3.1.0. Calling

.github/workflows/end-to-end-tests.main.kts

here: https://github.com/typesafegithub/github-workflows-kt/actions/runs/13436465865/job/37545104505?pr=1830 causes:

java.lang.NoClassDefFoundError: kotlinx/io/unsafe/UnsafeBufferOperations

. So far I checked that: • I cannot reproduce it locally (purged all caches, used Java 11) - reproduced it by setting a GitHub token, only then the problematic code path is executed • if I remove

@file:DependsOn("io.github.typesafegithub:action-updates-checker:3.2.1-SNAPSHOT")

and any pieces that depend on functions from it, it works - so this package is to blame •

UnsafeBufferOperations

was introduced in kotlinx-io 0.5.0 • ktor started using kotlinx-io starting 3.1.0 in this commit Something must still depend on kotlinx-io older than 0.5.0, but I cannot pin it down...

Hi - is it possible in

ScriptCompilationConfiguration

to require a specific return type for the script? So that the script will fail to compile if the last expression is not of that type?

Just try scripting K2 with 2.1.20, still some bug. Script like this

object TableVersion : IdTable<String>("TableVersion") {
    // can't use `text` as h2db don't support for primaryKey
    override val id: Column<EntityID<String>> = varchar("table", 64).entityId()
    override val primaryKey: PrimaryKey = PrimaryKey(id) // h2database#2191
    //...
}

will complain

PrimaryKey

class (inner class of Table) is not found. This example works with

-language-version=1.9

I'm trying to get IntelliJ IDEA to recognize my custom script but it just refuses to do it. I've created an empty file at

META-INF/kotlin/script/templates/dev.zt64.composables.ComposableScript

but when I select the script nothing is resolved and the classpath is missing dependencies. I've tried adding

isStandalone(false)

to my compilation configuration as well here is the repository https://github.com/zt64/compose-scripts

I found another very interesting quirk that I cannot explain to myself... How can it be that there is a difference in what the Kotlin compiler does when comparing internal IntelliJ / Gradle compilation with script compilation? I had this function definition in my internal scripting language:

@TransformationDsl
    infix fun <D : Any, VO> SetOperation<S, D>.by(valueMapper: ValueMapper<Any?, VO>) =
        apply { source = source.map(valueMapper) }

When this function is used in "normal IntelliJ" contexts, a call like this compiles and works just fine:

set optional "overallWeightTransportation" from "GrossWeightTransportationQuantity" by unitCodeMapper

If you look very closely to my generics, the generic type

VO

is not really relevant to this function, it has not bounds, the usage of the parameter

valueMapper

when passed to the

map

function does not care about this generic type, as

map

accepts everything. I did not realize this was over-engineered until when compiled with the script compiler I got this error:

set optional "overallWeightTransportation" from "GrossWeightTransportationQuantity" by unitCodeMapper //later mandatory
                                                                                    ^^ Cannot infer type for this parameter. Specify it explicitly.
                                                                                    ^^ Not enough information to infer type argument for 'VO'.

The key question is now: why does it work just fine in IntelliJ, but not in scripting compilation? Solution for my immediate problem was to replace

VO

with

*

of course... but the question remains... ;-)

Showing the intermediate values in scratch files is a wonderful idea!

Wanted to get a sense of people if they are using k-script in CI and if there had been any gotchas or pain-points as compared to shell scripting or python-scripting, when to comes to debugging and other factors.

Is it possible to use Kotlin Scripting as a way to allow extending a C++ program? For example, if I were to create a game engine in C++, and wanted to enable Kotlin scripting, would there be an easy way to do that?

Apologies for the cross post, but perhaps people here have more experience of this?

Running a kotlin Jsr223 script engine, can the "host" programatically loop through all the global symbols inside the ScriptEngine?

I really enjoy being able to write

.kts

scripts instead of `.sh`; keeping more complex scripts in a powerful, familiar language. Unfortunately the usefulness of

kts

is unduly limited by IntelliJ IDE's failure to resolve symbols across

@file:Import

dependencies - this is an essential feature for composing scripts together e.g. importing some library functions from a

common.kts

- meanwhile the scripts still run fine, it's just IDE support that's lacking. This problem has only become more impactful with junie Junie; as the agent sees 'unresolved' false positives and erroneously act upon them, struggling for a fix that never comes. kodee sad This limitation is very sad, given it's been hanging for over 2 years... KTIJ-16352 Scripts / IDE: unresolved reference when trying to import file in main.kts scripts with @Import annotation Any insights into this issue in or outside of JB? Is scripting just abandoned beyond what's needed for Gradle? Such a shame, it's a killer feature in my book.

Trying to give a shot to kotlin scripting for GH actions and I am stumped on this issue: I want to do something as simple as write something to GH env variables. Not using kotlin scripting I can do

- name: This works
  run: echo SOME_VAR=asd >> $GITHUB_ENV
- name: Using it
  run: echo $SOME_VAR
  env:
    SOME_VAR: ${{ env.SOME_VAR }}

And this works perfectly fine. In Kotlin I try to do:

runCommand("echo SOME_VAR=asd >> \$GITHUB_ENV")

(where runCommand comes from here https://github.com/apollographql/apollo-kotlin/blob/65dd7a44a74ed016988777521248da164de32ea0/scripts/bump-kotlin-nightlies.main.kts#L71C1-L85C2 basically using

ProcessBuilder

) And then I try to do the same exact

Using it

task, but nothing at all gets printed. The contents of

SOME_VAR

are just empty. Is this some issue with ProcessBuilder, or something I am doing which is wrong here?e

Is there a way to debug what's happening when I click "synchronize" in a

*.main.kts

file? Like output or something? It won't import my dependencies but I'm unsure why...

Someone mentioned this to me earlier: Is it possible to use KotlinX serialization in a

*.main.kts

? It would be incredibly useful.

When using the

BasicScriptingHost.eval(...)

function to run script code, is there any way, a script can programmatically add elements to the

reports

property of the

ResultWithDiagnostics

that it returns? In some situations that are caught at runtime of my script, I want to return a warning just like a compiler warning, but my script can only detect this at runtime like when a user does something they are not intended to do. My current "solution" is to log a warning using a logger... but this is really not what I want. I need this information as a side-information along with the result of the script evaluation. So, ideally, in my script, I would like to call a function that adds elements to this collection of

ScriptDiagnostic

elements with a severity of warning... Is that possible?

I'm using kotlin 2.2.0, with

BasicJvmScriptingHost

embedded in an application that's dynamically loading JPMS modules using

ModuleLayer

. I simply want the classloader from this

ModuleLayer

to be visible to the compiler. I"m setting

baseClassLoader

in the host configuration thus:

val hostconf = ScriptingHostConfiguration {
        jvm {
            baseClassLoader(appClassloader)
        }
    }

I've also tried a variety of ways to set the classloader in the

ScriptCompilationConfiguration

but to no avail. I don't want to add explicit jars (e.g.

dependenciesFromClassloader()

). I just want it to use a provided classloader, but it always just uses the main/boot classloader. This is something I've had working at some stage in the pass, but now doesn't seem to. I feel like I'm missing something obvious - it seems to want external files? Please, any pointers?

kodee loving Using a GitHub Actions pipeline? Consider using

.kts

files instead of Bash, to perform more complex steps; like preparing ECS Deployment tasks. The good news is - GitHub Actions images already include

kotlin

, so no complex preparation steps, just

run: kotlin myScript.main.kts

and off you go! kodee happy

What are best practices to test a main.kts script?

Is there some special rule that isn't clear for writing Kotlin Scripting IDE plugins? I find that some JARs that I return from the definition provider don't seem to be on the classpath when the compilation refiner is triggered (But some are... it's very confusing!)

📢 For anyone else writing a custom scripting host you might want to check out this suggestion I filed in YouTrack to swap out the default Maven Resolver bridge with some custom code that uses JBoss ShrinkWrap. It's quite easy, just requires adding two files to your codebase. This resolves a bunch of bugs that can cause weird failures in the IDE or at runtime e.g. the AWS SDK isn't usable via

@file:DependsOn

unless you do this because correct resolution of those artifacts requires Maven model building. There are likely other edge cases too. Please note that I didn't bother implementing any support for options as I don't use them. But it should be easy enough to see how to do it. Hope that helps!

Does context-parameters works with scripting?

We would like to expose code highlighting and completion via REST API for our Kotlin Scripts to be able to develop them on web. Are there any existing solutions for this?

Hello. I am trying to create my own script type and I got the exception that I can't understand. More in the thread

is kotlin scripting currently only supported on jvm?

Is Kotlin scripting defunct?

Where would the best channel be to ask general Kotlin questions?

Is there something else I need here? It looks like my imports aren't being added

I'm trying to add a kotlin script (its in my android app project FWIW, so kotlin exists in the project), but i dont necessarily have kotlin installed on my machine directly. to use kotlin scripting do i need to install kotlin directly?

Hello, I am attempting to embed Kotlin scripting into a project of mine. All is well so far except for the fact that we can't use annotations with

refineConfiguration#onAnnotations

We would like to just implement the basic

DependsOn

,

Repository

,

Import

,and

CompilerOptions

however whenever I specify annotations in

onAnnotations

I get this:

unable to load class kotlin.script.experimental.dependencies.DependsOn.

It seems to error on whichever annotation is first in the list. For the life of me I cannot figure this out.

refineConfiguration {
        onAnnotations(DependsOn::class, Repository::class, Import::class, CompilerOptions::class, handler = AnnotationProcessor())
    }

I can send a link to the repo if needed 🙂 Any help is much appreciated.